Python学习之路-Day4

1.函数

函数定义

def  func(aa):         def:表示函数的关键字  func:函数名，即函数的名称，可根据函数名调用函数

    print('.....')        print()..等等：函数体，函数中进行一系列的逻辑计算

    pass                  aa:参数，为函数体提供数据

    return 3            return:返回值，当函数执行完毕后，可以给调用者返回数据

func()                   执行函数

func('name')         传入一个参数执行函数

2.迭代器

迭代器是访问集合元素的一种方式

迭代器对象从集合的第一个元素开始访问直到所有元素被访问完结束。

定义一个迭代器：

name = iter(['liu','alex'])

print(name.__next__())  #每次只能取一个 3.X版本

print(name.next())  #2.X版本

3.生成器（generator）

定义：一个函数调用时返回一个迭代器，那这个函数就叫做生成器，如果函数中包含yield语法，那这个函数就会变成生成器。

def cash_money(amount):
while amount>0:
amount -= 100
yield 100             #循环到此处时，会跳出循环并将100这个值传递给next
print("quqianlaile")

atm  = cash_money(500)
print(type(atm))              #本例出现yield,此时该函数变成生成器
print(atm.__next__())
print(atm.__next__())
print('hfhdfdsf')
print(atm.__next__())

<class 'generator'>
100
quqianlaile
100
hfhdfdsf
quqianlaile
100

本列是yield实现异步
 1 import time

def consumer(name):
print("%s 准备吃包子" %name)
while True:
baozi = yield                                #此处yield可以返回和接收值，接收值时用send进行传递
print("包子【%s】来了,被[%s]吃了"%(baozi,name))

def producer(name):
c=consumer('A')
c2=consumer('B')
c.__next__()
c2.__next__()
print('开始做包子。。')
for i in range(10):
time.sleep(1)
print('做2包子')
c.send(i)        #send传递值给yield
c2.send(i)
producer('liu')

4.装饰器

装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作

def login(func):                                           def login(func):
print('welcome to..')                                     print('welcome to..')
return func                                                  return func
@login  #此处装饰器，装饰tv函数，相当于tv=login(tv)
def tv(name):                                              def tv(name):
print('page name.[%s]...'%name)                            print('page name.[%s]...'%name)

tv= login(tv)                                               tv('alex')
tv('alex')                        @login执行login函数，把自己装饰的函数名当作参数login(tv),tv函数重新定义login(tv)返回值

多参数装饰器demo
 1 def Login(request,kargs):
print('before')
return 33
def ErrorHandle(request,kargs):
print('after')

def Filter(before_func,after_func):
def outer(main_func):
def wrapper(request,kargs):
before_result=before_func(request,kargs)
main_result=main_func(request,kargs)
after_result=after_func(request,kargs)
return  wrapper
return outer

@Filter(Login,ErrorHandle)
def Index(requst,kargs):
print('index')
return 'home page...'

Index('liu','qiang')

5.递归

递归算法是一种直接或间接的调用自身算法的过程。

def calc(n):
print(n)
if n/2 > 1:
res = calc(n/2)
print('res:',res)
print('N:',n)
return  n

calc(10)

#斐波那契数列
def func(arg1,arg2,stop):
if arg1==0:
print(arg1,arg2)
arg3= arg1+arg2
print(arg3)
if(arg3<stop):
func(arg2,arg3,stop)

func(0,1,30)

6.算法

a=i for i in range(4)<==>相当于下面的方式得出的结果

a=[] 

for i in rang(4):

    a.append(i)

#简单算法
def binary_seach(data_source,find_n):
mid = int(len(data_source)/2)
if len(data_source)>1:
if data_source[mid]>find_n:
print('data in left of [%s]'%data_source[mid])
print(data_source[:mid])
binary_seach(data_source[:mid],find_n)
elif data_source[mid]<find_n:
print('data in right of [%s]'%data_source[mid])
print(data_source[mid:])
binary_seach(data_source[mid:],find_n)
else:
print('found fins_n',data_source[mid])
else:
print('cannot found')
if __name__=='__main__':
data = list(range(1,600))
print(data)
binary_seach(data,420)

#二维数组算法
data=[[col for col in range(4)] for row in range(4)]  #此处可以产生一个二维数组
print(data)
for i in data:
print(i)

print('------------')
for r_index,row in enumerate(data):
for c_index in range(r_index,len(row)):
tmp=data[c_index][r_index]
data[c_index][r_index]=row[c_index]
data[r_index][c_index]=tmp
print('------------')
for r in data:
print(r)

for i in range(len(data)):
a=[data[i][i] for row in range(4)]
print(a)