假装有标题 打卡2

假装有标题 打卡2

python的特性：

#切片
d=['a',3,'ahng',2333]
for x in d[1:3]: #截取列表索引号为1，2的元素，不包含3，类似左闭右开[1,3)
    print(x)
for x in d[-3:-1]: #切片同样支持负号倒数取元素,此时为左开右闭
    print(x)
#迭代
#字典迭代举例
f={'a':97,'b':98,'c':99}
#迭代输出key
for x in f:
    print (x)
#迭代输出value
for x in f.values():
    print (x)
#列表生成式
#[表达式 for ... in ... if ...]
l=[x*x for x in range(1,10)]#创建1到9的平方的数列
for x in l:
    print (x)    
l=[x*x for x in range(1,9) if x%2==1]#创建1到9中奇数的平方的数列
for x in l:
    print (x)
l=[x+y for x in 'abc' for y in 'def'] #利用双层循环创建一个全排列列表
for x in l:
    print (x)

​
#生成器
#例子：
l=(x*x for x in range (1,10)) #此时l是一个生成器
#>>> l
# at 0x000001D3F0672740>
#生成器generator保存的是算法，可以通过next(l)取得l的下一个值
#generator是可以迭代的,如下
for x in l:
   print (x)
#稍复杂的generator  
def isprimenumber(n):
    for i in range(2,n):
        if n==2:
            return 1
        if n%i==0:
            return 0
    return 1
def generator (max):
    for x in range (2,max):
        flag=isprimenumber(x)
        if flag==1:
            yield x  
#普通函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
#而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
for y in generator(100):
    print (y) 

​

生成器的使用案例——杨辉三角：

def triangle():
    l=[1]
    while 1:
        yield l
        m=[l[i]+l[i+1] for i in range (0,len(l)-1)]
        l=[1]+m+[1] #列表可以拼接
r=[]
n=1
for t in triangle():
    r.append(t)
    n=n+1
    if n>=10:
        break
for x in r:
    print(x)

map函数：

#map函数接收两个参数，一个是函数，另一个是iterator如列表list等
#例子
def f(x):
    return x*x
r=map(f,range(1,10)) 
l=list(r)#r是一个惰性的iterator，需要通过list()计算并传递给一个列表
for x in l:
    print(x)

reduce函数：

#reduce函数，是把一个函数作用于一个序列，这个函数必须接收两个参数
#reduce会把函数返回的结果再次与序列的下一个元素传递给该函数，再次计算，直到最后一个元素
from functools import reduce
def f(x,y):
    return x+y
print(reduce(f,[1,2,3,4])) #通过reduce求和
#例子，把字符串数字转换数字
def fn(x,y):
    return (x*10+y)
def char2num(s):
    d={'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
    return d[s]
string='1234567890'
print(reduce(fn,map(char2num,string)))
#map(char2num,string)把字符串转换成一个数字的iterator，fn再转换成数值

类和实例：

#类和实例，类相当于一个模板，实例是根据模板创建的一个对象，
#根据同一个类创造的模板可能包含不同的数据
#创建一个类
class book(object): #所有的类最终都继承自object
    pass
chinese=book()#根据book这个类创建一个实例chinese
chinese.author='lihua'#给chinese这个实例绑定了一个属性author，值为一个字符串'lihua'
class student (object):
    def __init__(self,number,score): #创建一给student的实例时必须输入name和score的值
        self.__number=number  #__表示number无法被外部直接访问改变
        self.__score=score
    def print_score(self): #创建一个方法来打印score
        print(self.__score)
    def set_score(self,newscore):
        self.__score=newscore
    def get_number (self):
        return self.__number
        

lihua=student(123,59) #创建一个实例
lihua.set_score(100)
lihua.print_score()
print(lihua.get_number())

继承

class aaa(object):
    def printstr(self):
        print('aaa')
class bbb(aaa): #类bbb继承自aaa，所以虽然bbb本身没有定义任何方法，但仍可使用printstr
    pass
class ccc(aaa): #类ccc也继承自aaa，但他自身定义了方法printstr，所以覆盖了他所继承的aaa中的printstr方法
    def printstr(self):
        print('ccc')
class ddd(object): #类ddd没有继承自aaa但自身定义了方法printstr
    def printstr(self):
        print('ddd')
def printtwice(ppp):
    ppp.printstr()
    ppp.printstr()
AAA=aaa()
BBB=bbb()
CCC=ccc()
DDD=ddd()    
AAA.printstr()
BBB.printstr()
CCC.printstr()
DDD.printstr()
printtwice(aaa())
printtwice(ccc())
printtwice(ddd())#ddd虽然没有继承自aaa，但有方法printstr所以依然可以使用

类属性和实例属性：

class aaa (object):
    num=0 #aaa.num是一个类属性
    #每次创建一个实例的时候，就会调用__init__函数，因此每创建一个实例num会加一
    def __init__(self,i,j): #i,j 是实例的属性
        self.i=i
        self.j=j
        aaa.num=aaa.num+1#类属性可以在类里面调用
example=aaa(1,2)
example2=aaa(3,4)
print(aaa.num)