函数的定义： def test(x): "The function definitions" x+=1 return x def:定义函数的关键字 test：函数名 （）：内可定义形参 "":文档描述（非必要，但是强烈建议为你的函数添加描述信息） x+=1：泛指代码块或程序处理逻辑 return：定义返回值 调用运行：可以带参数也可以不带 函数名()
为什么要定义函数
打个比方。如果公司老板要求你写一个监控程序，当CPUMemoryDisk等指标超过阈值时即发邮件报警。代码如下
while True： if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
虽然说上面的代码实现了功能。但是发现重复的代码写的太多了。就显得很low逼。这样就存在两个问题
1.重复代码太多。不符合高端程序员气质
2.如果日后需要修改发邮件的这段代码，比如加入群发功能，那么就需要在所有发送邮件的位置进行修改
如何解决这个问题呢？
只要将重复部分的代码提出来，放到一个公共的位置，起个名字，以后谁想用这段代码。直接通过这个名字调用一下就可以了
def 发送邮件(内容) #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 while True： if cpu利用率 > 90%: 发送邮件('CPU报警') if 硬盘使用空间 > 90%: 发送邮件('硬盘报警') if 内存占用 > 80%: 发送邮件('内存报警')
总结使用函数的好处：
1.代码重用
2.保持一致性，易维护
3.可扩展性
python的函数有两种：
内置函数与自定义函数
内置函数：
在文章的最下面
自定义函数：
def funcname(test): ''' 文档注释 :return: ''' print ('hello',test) return 123 funcname('lhc') #函数的定义与调用
只有函数名后面有()才会调用函数的内容。如果后面不接()那么这个名字只是显示出这个函数的内存地址
print (funcname) <function funcname at 0x00000000026A7518>
return意义
return代表着返回值，表示在函数运行结束后的一个值。将返回值赋予一个变量，那么可以看到打印结果。在函数中如果出现return，那么就代表这这个函数运行结束，后面的操作将不会在执行例2
def funcname(test): ''' 文档注释 :return: ''' print ('hello',test) return 123 res=funcname('lhc') print (res)
例2 def funcname(test): ''' 文档注释 :return: ''' print ('hello',test) return 123 print ('*'*20) print ('*'*20) print ('*'*20) res=funcname('lhc') print (res)
注意：即使不加返回值的话，那么python也会自动返回一个值为None
返回值：
0个——>None
1个——>该返回什么返回什么
多个——>返回元组形式
返回值可以是任意类型
三种函数的定义：
无参函数 def f1(): ''' 文档注释 :return: ''' print ('In the f1') f1() 有参函数 def f2(x,y,z): ''' 文档注释 :return: ''' print ('In the f2',x,y,z) f2(1,2,3) 空函数 def f3(): ''' 文档注释 :return: ''' pass f3() #开发工程常用函数
def my_sum2(x,y): ''' 定义两个相加之和 :param x: :param y: :return: ''' # res=x+y # return res return x+y #也可以这么写 print (my_sum2(1,2)) #return可以返回任何数据类型，也可以return任何表达式 def my_max(x,y): ''' 比较两个数字最小值 :param x: :param y: :return: ''' # if x>y: # return x # else: # return y return x if x>y else y print (my_max(1,2))
三种函数的调用形式：
def my_max(x,y): return x if x>y else y # print (my_max(1,2)) #语句形式 my_max(1,2) # 常用语没有返回值的函数 #表达式形式 res=my_max(1,2) print (res) # 需要拿到返回值 #作为参数 res=my_max(10,my_max(11,12)) print (res)
形式参数与实际参数：
这个就是形式参数
只有在被调用（或者被传值）才会暂用内存空间
这个就是实际参数。真实占用内存空间
PS：在python中名字没有任何的储值功能，任何的赋值都是绑定一个名字到一个值
参数的动态性：
#参数的动态性
def foo(x,y):
return x+y
print (foo(1.2,3))
print (foo('a','b'))
print (foo(1,'a'))
这样做有好处也有坏处，同类型想加没有问题，但是像print(foo(1,'a'))那么就会报错。怎么解决请往下看
解决方法：
1 def foo(x,y): ''' :param x: int :param y: int :return: int ''' return x+y 定义文档注释，但是起不到限定作用 2 def foo(x,y): if type(x) is int and type(y) is int: return x+y print (foo(1,2)) 进行判断 3 def foo(x:int,y:int)->int: return x+y print(foo(1,2))
实际参数与形式参数的调用：
#实参：按位置传值（受位置影响） def foo(x,y): print (x) print (y) foo(1,2) #实参：安关键字传值(不受位置影响） def foo(x,y): print (x) print (y) foo(y=1,x=2) # 注意问题一：针对同一个形式参数，你可以按照位置或者按照关键字传值，但是只能用一种方式 foo(1,x=1,y=2) #报错 #注意问题二：按关键字传值，必须在按位置传值的右边 foo(x=1,2) #报错
#位置参数,默认参数，*args可变参数，**kwargs def foo(x,y,z): print (x) print (y) print (z) #位置参数，必须要传值 foo(1,2,3) #默认参数，在定义参数的时候给一个默认的值。 def foo(x,y=10): print (x) print (y) foo(1) foo(1,3) foo(1,y=1) #默认参数通常是把那种变化比较小的参数定义成默认参数。 #默认参数一定要定义成一个不可变的类型 #注意默认参数必须要写的位置参数右边 def foo(x=1,y): pass #报错 #默认参数在定义时就已经被赋了一个明确的值。后期的变化对其无效 name=123 def foo(x,y=name): print (x) print (y) name='abc' foo(1)
# 注意针对任何形式的参数都有两种传值操作(位置与关键字)
总结默认参数的好处：
1.降低了函数调用的复杂性
2.可用来扩展函数功能
*args
def foo(x,y,*args): print(x) print(y) print(args) foo(1,2,3,4)
将函数剩余的参数变成元组，即使函数与参数相等，那么将会输出一个空元组
def foo(x,y,*args): print(x) print(y) print(args) foo(1,2,*[3,4,5])
*的作用是‘监听’位置参数，*args等待接收的参数必须是按位置来的
凡事遇到带*的参数，那么我们就把它看着是位置参数
例如：
def foo(x,y,a,b,c): print(x) print(y) print(a,b,c) foo(*[1,2,3,4,5])
如果多一个参数或者少一个参数 那么就会报错
如果*的后面参数是一个数据类型，而不是一个具体的参数名，那么就把那个数据类型打散
**kwargs
def foo(x,y,**kwargs): print(x) print(y) print(kwargs) foo(1,y=2,z=1,b=2,c=5)
**kwargs会将多的关键字参数组合成一个字典格式，与上面的*args作用一样。但是，要在*args后面。因为*args可以看做一个位置参数，而**kwargs可以看成一个关键字参数。基于我们上面说的，关键字参数要在位置参数的后面。它们两个可以一起组合使用。
组合使用后，后期函数的扩展性将会很好
def foo(x,y,z): print(x) print(y) print(z) foo(**{'x':1,'z':3,'y':2})
在实参上操作：看到实参前面有**后面接入一个字典{'x':1,'z':3,'y':2}，那么就把它看做x=1，z=3，y=2.就变成了关键字传值了，那么如果多一个值或者少一个值的话会报错
def foo(x,y,z=3): print(x) print(y) print(z) def bar(*args,**kwargs): #args=(1,2,3) kwargs={'x':1,'y':2,'z':3} foo(*args,**kwargs) #foo(*(1,2,3),**{'x':1,'y':2,'z':3}) #foo(1,2,3,x=1,y=2,z=3) bar(1,2,3,x=1,y=2,z=3)
函数是第一类对象（函数对象）
在python中所有的名字都没有储值功能，什么是名字，比如说定义函数的名字，定义变量的名字等等。
概念：指的是函数可以被当做数据来处理。
数据值的处理方式：
可以被引用
def foo(): print('foo') f1=foo f1()
可以当做另外一个参数的值
def foo(): print('foo') def bar(func): print(func) bar(foo)
可以当做返回值
def foo(): print('foo') def bar(func): return func f=bar(foo) print(f) f()
*注意：如果函数当做参数，或者返回值当做参数，满足了其中一个，这个函数可以称作为高级函数
一个值可以当做容器类型的一个元素
def foo(): print('foo') func_dic={ 'foo':foo } func_dic['foo']()
函数嵌套
1.函数的嵌套调用
在一个函数内部调用另一个函数
面向过程的编程 def my_max2(x,y): if x>y: return x else:return y def my_max4(a,b,c,d): res1=my_max2(a,b) res2=my_max2(res1,c) res3=my_max2(res2,d) return res3 print(my_max4(1,23423,5435,0)) def my_max2(x,y): return x if x>y else y def my_max4(a,b,c,d): return my_max2(my_max2(my_max2(a,b),c),d) print(my_max4(1,23423,54353,0)) 函数的可读性很差 不推荐
2.函数的嵌套定义
在函数内部再定义一个函数
def f1(): def f2(): print('in the f2') f2() f1()
命名空间（Namespaces）
命名空间即名称空间，存放名字的地方，反映的是名字与值的绑定
x=1 #就是将x与1绑定 del x #则是将x与1的绑定删除
在Python中分三种命名空间
1.局部命名空间
def foo(): x=1 def bar():pass #foo()函数中的定义就说局部命名空间，可以理解为有缩进的
2.全局命名空间
import time x=1 class ClassName:pass def foo():pass #顶头写，没有缩进，只要Python这个代码一执行，他们就会放到全局命名空间中
3.內建命名空间
python程序要想运行，需要靠python解释器来执行，解释器属于一个软件，而解释器中写好的名字就叫內建名字，比如：sum，print 等等。
Python加载名字顺序
內建命名空间-->全局命名空间-->局部命名空间(在函数名被调用的时候才会加载，执行完毕后进行释放)
globals() 与 locals()
使用上面两个函数可以查看全局名称与局部名称
x=1 def func(): y=2 x=3 print('in the func') print(globals()) print(locals()) 执行结果： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0043A410>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled/day5/命名空间与作用域.py', '__cached__': None, 'x': 1, 'func': <function func at 0x006567C8>} {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0043A410>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled/day5/命名空间与作用域.py', '__cached__': None, 'x': 1, 'func': <function func at 0x006567C8>} 可以发现上面两行一模一样，因为gloabls在全局中输出，所以全局的局部还是全局
在局部中打印
x=1 def func(): y=2 x=3 def bar():pass print(locals()) print(globals()) func() {'bar': <function func.<locals>.bar at 0x003FD780>, 'x': 3, 'y': 2} {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0043A410>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled/day5/命名空间与作用域.py', '__cached__': None, 'x': 1, 'func': <function func at 0x004C6738>} 同样的在局部中打印局部变量。
特殊的if
x=1 if 1: aaaaaaaaaaaaaaaaaaaaaaa=1 def func(): y=2 x=3 def bar():pass print(locals()) print(globals()) func() {'bar': <function func.<locals>.bar at 0x0041D780>, 'x': 3, 'y': 2} {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0045A410>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/PycharmProjects/untitled/day5/命名空间与作用域.py', '__cached__': None, 'x': 1, 'aaaaaaaaaaaaaaaaaaaaaaa': 1, 'func': <function func at 0x004967C8>} 虽然if下面的子代码没有顶头写，但是也属于全局变量
查看內建名称
作用域
按照作用范围以及产生消亡的时间，可以把这三个命名空间分成两个区域
反映就是一种查找顺序，比如说在局部域查找名字，局部域没有，查找全局，全局没有查找內建
定义在全局的变量为全局变量。全局变量全局有效。
定义在局部的变量为局部变量，局部变量局部有效，函数执行的时候存活，函数结束后被释放
x=1 def f1(): x=10 def f2(): x=20000 print (x) return f2 f=f1() print(f) x=20 f() x=1 def f1(): x=10 def f2(): # x=20000 print (x) return f2 f=f1() print(f) x=20 f()
闭包
定义函数其实就是命名一个名字，然后把函数的代码打包赋值给这个名字，定义函数就是一个打包的过程。
而闭包的概念是：本质就是一个内部函数。特点，必须包含对外部函数作用域(非全局作用域)名字的引用
def f1(): x=1 def f2(): print(x) return f2 func=f1() x=10 func()
也就是f2函数打包了一段代码，特殊之处是，他是一个包含对外部函数状态引用的函数。在返回f2的时候，并不是单纯的再返回里面的代码，是返回这个代码并且把这个代码外面想要的值一并返回。如果自己的函数体内有值，那么它就不是闭包函数。
如何查看是不是闭包函数
def f1(): x=1 y=2 def f2(): print(x) print(y) return f2 func=f1() print(func.__closure__[0].cell_contents) print(func.__closure__[1].cell_contents)
闭包的厉害之处——惰性计算
from urllib.request import urlopen def page(url): def get(): return urlopen(url).read() return get #通常来说闭包函数定义完后应该返回来 baidu=page('http://www.baidu.com') print(baidu())
什么时候调用，直接就加括号可以
装饰器
比如公司写入一个软件后，稳定后就要遵循开放封闭原则。（就是开放了就要关闭，类似于上线后，项目的源代码就不能再更改了，能不动就净量别动。可能会导致连锁反应，进而导致程序崩溃），但是上线后不可能就不扩展，扩展还不能修改源代码包括函数的调用方式，那么就出现了'装饰器'
装饰器：本身功能是装饰别人，被装饰着可以是任何可调用对象。装饰器本身也可以是任何可调用对象
#需求，统计函数执行时间 #装饰器需要遵循的原则：1：不能修改源代码 #2：不能修改调用方式 #装饰器功能是在遵循1和2的前提下为被装饰对象添加新功能
import time def timer(func): #2.这一步是把下面的index给了func，而这一步index是属于最原始的，最原始的意思就是还没装饰的 def wapper(): start_time=time.time() func() time.sleep(3) stop_time=time.time() print('run time is %s' %(start_time -start_time)) return wapper @timer #1.index=timer(index) 3.最后闭包函数执行结束后，会return返回一个wapper，这个wapper就是此时的index def index(): print('welcome to index') index() # 4最后这里index的调用就是在调用wapper
#无参装饰器 @timer #@后面跟一个新名字。timer()是装饰器，就是一个函数。 #@timer就是把正下方的函数名传进去‘@timer(index)'执行后会得到一个结果，这个结果重新赋值给index 'index=@timer(index)' def index(): print('welcome to index') index()
#有参数装饰器 @auth(auth_type='file') #只要是名字加括号，第一件事就是立马执行，有返回值则返回值，没有则返回None #auth(auth_type='file')会的到一个结果 --->比如 func --->在转换成上面的@func ---> 会读正下方的函数名 index=func(index) def index(): print('welcome to index') index()
import time def timer(func): #这一步是把下面的home给了func，而这一步home是属于最原始的，最原始的意思就是还没装饰的 def wapper(user): start_time=time.time() func(user) #2.这个func就是下面的home源代码，给一个参数user，但是func属于wapper 所以还要给wapper一个参数 stop_time=time.time() print('run time is %s' %(start_time -start_time)) return wapper @timer def home(user): time.sleep(2) print('home %s'%user) home('lhc') #1.运行home就是运行装饰后的home即上面的wapper 即wapper('lhc').但是运行会报错，因为上面的装饰器函数中没有定义参数 #所以就要变成有参的装饰器 #3.最后home执行就变成了wapper执行
整合有参与无参
import time def timer(func): def wapper(*args,**kwargs): start_time=time.time() func(*args,**kwargs) stop_time=time.time() print('run time is %s'%(start_time-stop_time)) return wapper @timer def index(): print('welcome index') index() @timer def home(user): print('welecome to home %s'%user) home('lhc')
如果一个装饰器装饰了两个函数，那么都没偶参数或者都有参数，那么很简单，但是其中一个有参另一个无参，那么就无法写死了，这时候就可以用*args和**kwargs 通过*args来接受位置参数，**kwargs来接受关键字参数，在
定义wapper参数为*args和**kwargs那么不论你之前传入的参数是什么样的wapper都会将你原封不动的打开。
认证装饰器
user_l=[ {'user':'lhc','passwd':'123'}, {'user':'zxb','passwd':'456'}, {'user':'hj','passwd':'789'}, ] def auth(func): # def func(func): def wapper(*args,**kwargs): name=input('name').strip() passwd=input('passwd').strip() for i in user_l: if name != i['user'] or passwd != i['passwd']: print('gun') break res = func(*args, **kwargs) else: print('auth successful') res = func(*args, **kwargs) return res return wapper @auth def home(user): print('welcome to home %s'%user) return user+'666' res=home(user='lhc') print(res)
认证装饰器2
#!/usr/bin/env python #coding=utf-8 import time user_l=[ {'user':'lhc','passwd':'123'}, {'user':'zxb','passwd':'456'}, {'user':'hj','passwd':'789'}, ] login_user={'username':None,'login':False} def auth(auth_type): def deco(func): def wapper(*args,**kwargs): # print('====================',auth_type) if auth_type =='file': if login_user['username'] and login_user['login']: res = func(*args, **kwargs) return res name=input('name:').strip() passwd=input('passwd:').strip() for i in user_l: if name == i['user'] and passwd == i['passwd']: print('auth successful') print('auth type is file') login_user['username'] = name login_user['login'] = True res = func(*args, **kwargs) return res elif auth_type=='ladp': print('login type is ladp successfull') res=func(*args,**kwargs) return wapper return deco @auth(auth_type='ladp') #func---->@func---->index=func(index) def index(): print('welcome index') index() @auth(auth_type='file') def home(user): print('welecome to home %s'%user) return user+'666' res=home('lhc') print(res)
注意：如果原函数里面有文档注释信息的话，那么要导入一个functools模块中的functools.wraps(func)并装饰到wrapper函数上面
import functools def temer(func): @functools.wraps(func) def wrapper(*args,**kwargs): '这是wrapper函数' g=func(*args,**kwargs) return g return wrapper @temer def index(): '这是index函数' print('welcome') # index() print(help(index))
上面中装饰器的意思就是让wrapper保持原函数的注释信息.记住就行
迭代器
迭代：更新换代，描述的是一种重复的过程，在Python中跟重复动作有关的关键字有for，while。
l=[1,2,3,4] for i in range(len(l)): print(l[i]) i=0 while i <len(l): print(l[i]) i+=1
按照上面的方法进行循环的通过下标来实现的
但是针对没有下标的数据类型，我们再想迭代他们的，就必须提供一种不按下标取值的方式，针对这种情况，python已经为很多数据类型内置了一个叫__iter__的方法
例
d={'a':1,'b':2}
print(d.__iter__)
print([].__iter__)
数据类型凡是有__iter__方法都是可迭代的iterable，执行这个方法得到的结果就是迭代器iterator
只要是迭代器，他下面内置一个__next__方法
通过执行这个__next__方法得到的结果
循环字典的key值，
如果再次循环一次会出现一个叫StopIteration的“错误”，但是这个StopIteration并不是报错，是代表一种结束的标志。
代表字典没有值了
包括列表也是一样的
l=[1,2,3,4] i=iter(l) #1.__iter__() while l: print(next(i)) #i.__next__()
l=[1,2,3,4] i=iter(l) #1.__iter__() while l: try: print(next(i)) #i.__next__() except StopIteration as e: break
dict={'a':1,'b':2,'c':3}
d=iter(dict)
while 1:
try:
# print(next(d))
print(dict[next(d)])
except StopIteration:
break
迭代器的厉害之处就是对于那种没有下标的数据类型进行循环，包括文件
dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}
dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}
dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}dict={'a':1,'b':2,'c':3}
dict={'a':1,'b':2,'c':3}
with open('test') as f: print (f) print(f.__iter__) for line in f: print(line)
前提是必须是可迭代的，也就是__iter__方法
这样做的好处是
1：提供了一种同意的迭代方式，（之前只能按照下标去迭代，现在可以用next方法来执行）
2：惰性计算：可以省内存。对比列表来说，迭代器是一次取一个值读到内存中，而列表是将列表中所有的元素都读到内存中。
有好就有坏，他的缺点是
1：迭代器看起来就像一个序列，但是你永远无法预知迭代器的长度。因为它一次取一次值，永远不知它取多少次值，因为它每次只取一个值
2：不能倒着迭代，更像是一次性的，只能有一遍
可迭代的：只要有__iter__方法，都是可迭代的，只要能被for循环迭代的都是可迭代的对象
迭代器：既有__iter__方法又有__next__
验证是否可迭代
from collections import Iterable,Iterator
print(isinstance('abcsdad',Iterable))
from collections import Iterable,Iterator
print(isinstance('[]',Iterable))
from collections import Iterable,Iterator
print(isinstance('()',Iterable))
from collections import Iterable,Iterator
print(isinstance('{}',Iterable))
#通过上面的命令可以查看是否可迭代
print(isinstance({}.__iter__(),Iterator))
print(isinstance(().__iter__(),Iterator))
print(isinstance([].__iter__(),Iterator))
print(isinstance('asdasd'.__iter__(),Iterator))
#通过使用__iter__变成迭代器
with open('test') as f:
print(f.__next__())
print(isinstance(f,Iterable))
print(isinstance(f,Iterator))
#文件就是一个迭代器
生成器
凡事在函数内部有yield关键字，那么这个函数就是一个生成器
def foo(): print('第一次执行') yield 1 print('第二次执行') yield 2 print('第三次执行') yield 3 print('第四次执行') yield 4 g=foo() print(g)
得到的结果是
<generator object foo at 0x0065A030> #generator就是生成器
函数加括号调用首相会检查语法有没有错误，其次是执行 然后检查函数当中有没有yield 于是这个执行会变成一个生成器
print(isinstance(g,Iterator)) #通过这个命令来查看发现生成器就是一个迭代器，那么它就是一个序列，跟字典列表..一样 也就可以用next取值
例子中的函数加括号并不会执行，而是通过next来执行
注意：这个执行并不会全部执行，而是遇到一个yield后停止执行，通过next进行执行，然后继续执行，直到遇到一个新的yield后又会停止，再通过next来执行。下一次的执行基于上一次执行的位置开始
如果函数中有yield那么就可以把函数当成序列来看（迭代器来看）
def foo(): print('第一次执行') yield 1 print('第二次执行') yield 2 print('第三次执行') yield 3 print('第四次执行') yield 4 g=foo() for i in g: print(i) #通过生成器来for循环函数
这个的厉害之处就是函数已经不是函数了 而是一段数据流 ，取一个值，然后暂停，下一次在取一个值...。（节约内存）
yield的功能：
1.yield是为函数定制__iter__和__next__方法，这就提供了一种自定义迭代器的优雅的方法
2.yield就像于return，return可以返回什么yield也可以。但是可以返回多次
3.生成器本质就是一个数据流，next(生成器)才会触发生成器函数的一次执行，下一次next会从上次暂停的位置继续执行，直到重新遇到一个yield
协程函数
协助程序函数，本质就是生成器（包含yield）
def eater(): print('start to eat') while True: food=yield print('is eating food:%s' %food) test=eater() next(test) #先next一次 来"唤醒"协成函数 #然后下面的操作都是test.send(值) test.send('bread')#将值发给yield ...
函数间交互
def eater(): print('start to eat') while True: food=yield print('is eating food:%s' %food) def Send(): test = eater() next(test) #这函数中的这个操作触发上面的函数 test.send('bread') #send操作传值给上面函数 test.send('milk') Send() #区别在于两个函数间的交互
函数交互的关键就是第一步唤起操作，有的时候很多人都容易忘记这步操作。
所以定义为成一个装饰器，那样可以通过装饰器直接唤起初始化操作
def init(func): def wapper(*args,**kwargs): g=func(*args,**kwargs) next(g) return g return wapper @init def eater(): print('start to eat') while True: food=yield print('is eating food:%s' %food) e=eater() e.send('111111111')
协程函数模仿grep -rl '想要查问的字符串'
首先在E盘下面建立一个test文件夹，然后在test下面递归的创建几个文件夹和文件进行测试
import os import functools def init(func): @functools.wraps(func) def wapper(*args,**kwargs): '这是wrapper' g=func(*args,**kwargs) next(g) return g return wapper def get_file(abs_path,target): '生产一个个的文件绝对路径' g=os.walk(abs_path) for topdir,cdir,files in g: for file in files: abs_file_path=r'%s\%s' %(topdir,file) target.send(abs_file_path) @init def opener(target): '打开文件获取句柄' while True: abs_file_path=yield with open(abs_file_path) as f: target.send((f,abs_file_path)) @init def get_lines(target): '读取文件每一行' while True: f,abs_file_path=yield for line in f: target.send((line,abs_file_path)) @init def grep(pattern,target): '过滤行得到想要的信息' while True: line,abs_file_path=yield if pattern in line: target.send((abs_file_path)) @init def printer(): while True: abs_file_path=yield print(abs_file_path) file_name=get_file(r'E: est',opener(get_lines(grep('python',printer()))))
上面这种方法属于一种面向过程的编写思路。核心就面向过程，将大问题分成多个小步骤，然后一步一步的进行执行，最后再穿插起来。
面向过程包括（liunx内核c语言写的，c语言就是典型的面向过程，github，apache等等都是典型的代表）。最开始编程就是面向过程。
凡事必有好坏
优势：
将复杂的问题变得清晰。解决程序复杂度
劣势：
可扩展性极其差，无法修改。这个过程建成后，无法执行别的操作，只能执行grep -rl
基本不变的场景最适合面向过程（例如操作系统，数据库这种软件）
对于现在的互联网状况，需求经常改变的情况，出现了另外一种编程思想：面向对象
在python中还有一种函数就是內建函数
內建函数随着解释器的启动而启动
print(abs(-1)) #求绝对值 print(all([1,2,3,'a',0,[]])) #for循环查看迭代器中所有的元素，如果有一个元素为False那么则为Flash，除非所有元素都为True则为True,或者迭代器为空 print(all(''))#for循环查看迭代器中所有的元素，如果有一个元素为False那么则为Flash，除非所有元素都为True则为True,或者迭代器为空 print(any([1,2,3,'a',0,[]])) #同上面一样，但是迭代器中有一个元素是True则返回Ture print(any('')) print(bin(123)) #10进制转二进制 print(bytes('你好',encoding='utf-8')) #将字符串转行成二进制，后面要指定一个编码格式 s='你好' print(bytes(s,encoding='utf-8')) print(s.encode(encoding='utf-8')) print(s.encode(encoding='utf-8').decode(encoding='utf-8')) print(callable(all)) #是否可调用,只要名字加()就是可调用 print(chr(123)) #字符编码表：一张表中数字所对应的字符串 print(ord('{')) #字符编码表：将字符串转换成数字 compile。#python的执行过程是通过解释器，在解释之前会进行一个编译过程。 s='for i in range(10):print("i")' code=compile(s,'','exec') #'' 可以指定代码来自哪个文件，加不加都行。exec代表着一组语句 print(code) exec(code) 模拟语句 s='1+2+3' code=compile(s,'','eval') eval(code) print(eval(code)) 模拟表达式 exec跟eval都是在字符串中提取有用的信息 b=complex(1-2j) print(b,type(b)) print(b.real,b.imag) #实部运算与需部运算 dir() #查看函数下面方法 print(divmod(10,3)) #得到元组，前面为余数，后面为商，前端分页功能 format() #格式化字符串和数字 print('{}::::::::{}'.format(1,2)) print('{1}::::{1}::::{0}'.format(1,2)) frozenset #定义集合 print(globals()) #查看全局变量 print(locals()) #查看局部变量 res='123abc' print(hash(res)) #生成hash值 print(max(1,2,3,4)) #比较最大值 比较类型为可迭代，只能同类型比较 print(min(1,2,3,4)) #比较最大值 比较类型为可迭代，只能同类型比较 lambda sorted print(pow(2,3,3)) #第一个数字代表一个数字，后面的数字代表他的几次方，最后一个数为前两个数的结果取余 a=[1,2,3] print(reversed(a)) for i in reversed(a): print(i) #取反 print(round(3.5)) #四舍五入 l=[1,2,3,4,5,6,7] print(l[2:5:2]) s=slice(2,5,2) print(l[s]) #大量列表都用切割[2:5:2]那样可以使用slice，节约代码。没啥软用 print(sum([-1,2,3,4])) #只能接受纯数字的迭代器，可以设定初始值 zip #拉链 name=['tom','jack','lucy'] age=['10','20','30'] a=zip(name,age) for i in a: print(i) #一一对应，组成一个个元组,如果无法对应，将停止zip，不会报错
# salaries={ # 'lhc':3000, # 'hj':100000000, # 'dh':10000, # 'ys':2000 # } #取出工资最高的人名 # d=zip(salaries.values(),salaries.keys()) # print(max(d)[1]) #虽然可以这么实现但是，但是用下面的方法更好些 # def get_val(k): # return salaries[k] # print(max(salaries,key=get_val)) #max salaries就是在for循环salaries 将key传给上面的函数，然后返回一个value进行对比，得出的结果输出key值 #这么虽然实现了，但是特别麻烦不能每次都顶一个函数，特别的low #后来有个新的方法，如果定义的函数的函数体就是一条return（一次性函数）就是lambda(匿名函数) # func=lambda k:salaries[k] # lambda 的参数不需要括号,return也不需要写 # print(func('lhc')) # 这么玩就没意思了，lmabda本身的含义就是没有名字 # print(max(salaries,key=lambda k:salaries[k])) #最终的结果 # min与max是一样的 #排序 # print(sorted(salaries)) # print(sorted(salaries,key=lambda x:salaries[x])) #从小到大排序 # print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #从大到小
salaries={ 'lhc':8000, 'hj':100000000, 'dh':10000, 'ys':1000 } # filter 过滤 res=filter(lambda k:salaries[k] > 3000,salaries) #两个参数第二个属于一个可迭代对象，前面是一个函数名，这个函数的返回值一定是True或者False， for i in res: print(i)
l=['lhc','hj','dh','ys'] #给其他人都加上123 # 正常定义 # n_l=[] # for i in l: # i+='123' # n_l.append(i) # print(n_l) #代码非常冗长，所以请看下面 res=map(lambda i:i+'_123',l) #通过map函数可也用一行代码写出结果，首先后面还是传入一个列表，然后for循环一次取值赋给i，i加上123返回 最后输出 print(res) 在lambda中无法加入if判断，只能全部都加123
from functools import reduce #需求1加到一百 res=reduce(lambda x,y:x+y,range(101),10) #后面的10 位初始值因为for循环相加就是通过一个初始值然后依次循环相加，所以可以指定初始值也可以不指定初始值 print(res) #在python2.7中可以直接调用reduce，但是在python3.0中将reduce添加到functools模块中