python-函数进阶
1，名称空间
又名name space, 顾名思义就是存放名字的地方，存什么名字呢？举例说明，若变量x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方
名称空间共3种，分别如下
- locals: 是函数内的名称空间，包括局部变量和形参
- globals: 全局变量，函数定义所在模块的名字空间
- builtins: 内置模块的名字空间，通过dir(_builtins_)查看
>>> globals()
{'__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__builtins__': <module 'builtins' (built-in)>,
'x': 1, '__name__': '__main__', '__spec__': None}
>>>
>>> locals()
{'__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>,
'__builtins__': <module 'builtins' (built-in)>,
'x': 1, '__name__': '__main__', '__spec__': None}
>>>
>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError',
'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError',
'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError',
'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
'FileExistsError', 'FileNotFoundError',
'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning'
, 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError',
'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotADirectoryError',
'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError',
'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'ReferenceError',
'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopIteration', 'SyntaxError',
'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError',
'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning',
'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError',
'_', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__',
'__name__', '__package__', '__spec__',
'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',
'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr',
'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float',
'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash',
'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len',
'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next',
'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr',
'reversed', 'round', 'set', 'setattr', 'slice', 'sorted',
'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
2，作用域的查找顺序
不同变量的作用域不同就是由这个变量所在的命名空间决定的
作用域即范围
全局范围：全局存活，全局有效
局部范围：临时存活，局部有效
查看作用域方法 globals(), locals()
作用域的查找顺序
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
- locals 是函数内的名字空间，包括局部变量和形参
- enclosing 外部嵌套函数的名字空间
- globals 全局变量，函数定义所在模块的名字空间
- builtins 内置模块的名字空间
3，for本质
优点（和其它循环(while)相比的）：比whlle等循环功能强大，不仅遍历的对象种类多，而且比普通循环效率更高(自动把遍历对象生成迭代器)
定义：遍历可迭代对象(string,list,dict等)，如果是遍历可迭代对象，for会自动把in后面的可迭代对象转换成迭代器,把所有元素依次加载到内存，遍历完成后自动处理异常
for i in t: # t被for转换成t.__iter__()
print(i)
等效于
t = [1, 2, 3, 4, 5].__iter__() # 可以通过__iter__()方法或iter()内建函数把Iterable类型变成Iterator对象。
# 循环:
while True:
try:
# 获得下一个值:
i = t.next()
print(i)
except StopIteration:
# 遇到StopIteration就退出循环
break
4，闭包
内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包。
说明：闭包指的是内层函数，之所以叫闭包，闭是因为在外层函数内，包是因为和外层函数的变量绑定在一起。
def outer():
n = 10
def inner():
print("inner:", n)
return inner
val = outer()
print(val)
val()
# 执行结果
<function outer.<locals>.inner at 0x0033A390>
inner: 10
闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
保存上次的运行环境(外层函数的的生命周期结束之后，外层函数的变量不被销毁)
def outer(name):
count = [0]
def inner():
count[0] += 1
print('Hello,', name, ', ', str(count[0]) + ' access!')
print(count)
return inner
hello = outer('hy')
hello()
hello()
hello()
###
Hello, hy , 1 access!
[1]
Hello, hy , 2 access!
[2]
Hello, hy , 3 access!
[3]
这里面调用outer的时候就产生了一个闭包——inner,并且该闭包持有自由变量——count，因此这也意味着，当函数outer的生命周期结束之后，count这个变量依然存在，因为它被闭包引用了，所以不会被回收。
另外再说一点，闭包并不是Python中特有的概念，所有把函数做为一等公民的语言均有闭包的概念。不过像Java这样以class为一等公民的语言中也可以使用闭包，只是它得用类或接口来实现。
闭包思考：
1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存
自由变量
def outer(name):
count = [0]
def inner():
count[0] += 1
print('Hello,', name, ', ', str(count[0]) + ' access!')
print(count)
return inner
hello = outer('hy')
hello() # 这个hello其实就是inner
hello()
hello()
1，在闭包中，被调用并改动，引发bug的那个值，是自由变量。
2，在装饰器中，被传进来的，但是未引发bug的那个值，是自由变量。（如装饰器的局部变量被嵌套函数调用并修改，从而引发bug，这个局部变量就是自由变量，从意义上来讲，这个局部变量被引用并改动，导致其不被释放，就会使局部变量升华成类似全局变量）。
比如闭包中这个被传进去的name，被闭包调用并且没有改变，所以就是自由变量。装饰器里面，count被引用并修改了，形成了bug，导致count不被销毁，升华成类似全局变量，它也是自由变量。
5，装饰器
装饰器 = 高阶函数 + 函数嵌套 + 闭包
1，高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
编写高阶函数，就是让函数的参数能够接收别的函数。
只需满足以下任意一个条件，即是高阶函数
接受一个或多个函数作为输入
return 返回另外一个函数本身
# 接受一个或多个函数作为输入
def add(x, y, f):
return f(x)+f(y)
val = add(5, 6, abs) # 参数可以接受函数
print(val)
# return返回另外一个函数本身
def calc(x, y):
return x+y
def add2():
return calc # return可以返回另一个函数
val2 = add2()
print(val2(3, 6))
2，嵌套函数
用于先准备一个函数，即外层函数执行完后，内层函数仍可以使用外层函数的变量，装饰器应用了嵌套函数。
def line_conf(a, b):
def line(x): # 参数其实传到了这里来了
return a * x + b
return line
line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5))
print(line2(5))
###
6
25
这个例子中，函数line与环境变量a,b构 成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个环境变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，利用闭包，使开始赋予的值没有销毁，闭包也具有提高代码可复用性的作用。缺点消耗了内存，没有释放出来
通俗一点：执行的时候，line1=line_conf，带入函数，返回的是line，所以此时line1=line，变量a，b已经传入进去了，后面执行line1(5)的时候，其实就是执行第二行的line(x)。
如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。利用闭包，我们实际上创建了泛函。line函数定义一种广泛意义的函数。这个函数的一些方面已经确定(必须是直线)，但另一些方面(比如a和b参数待定)。随后，我们根据line_conf传递来的参数，通过闭包的形式，将最终函数确定下来。
嵌套函数和闭包的联系：
你可以在一个函数里面嵌套另外一个函数。嵌套（内部）函数对其容器（外部）函数是私有的。它自身也形成了一个闭包。一个闭包是一个可以自己拥有独立的环境与变量的的表达式（通常是函数）。
既然嵌套函数是一个闭包，就意味着一个嵌套函数可以”继承“容器函数的参数和变量。换句话说，内部函数包含外部函数的作用域。
可以总结如下：
- 内部函数只可以在外部函数中访问。
- 内部函数形成了一个闭包：它可以访问外部函数的参数和变量，但是外部函数却不能使用它的参数和变量。
由于内部函数形成了闭包，因此你可以调用外部函数并为外部函数和内部函数指定参数
3，装饰器
装饰函数
定义：装饰器是特殊的闭包（1，自由变量是函数。2，外层函数执行后赋给的变量名和使用装饰器的函数名相同，所以可以不改变用法。3，函数传到闭包中，函数并没有被修改，因此不会产生BUG）
作用：不改动原函数、不改变原函数调用方式的前提下，扩展函数功能，遵循了开放封闭原则
需求一：为源码函数拓展功能，且不改变调用方式
# _*_ encoding:utf-8 _*_ def login(func): print("passer user vertification...") func() def tv(): print("Welcome [%s] to home page") tv = login(tv) # tv的值为None tv() # 这步出错：TypeError: 'NoneType' object is not callable # 输出 passer user vertification... File "D:/PythonProject/0313/str.py", line 14, in <module> tv() TypeError: 'NoneType' object is not callable 问题： 1.调用方法改变了 2.调用端还没有调用 tv()，扩展的功能就先执行了
def login(func): print("passer user vertification...") return func @login #@login等效于tv = login(tv) def tv(): print("Welcome [%s] to tv page") tv() # 输出 # passer user vertification... # Welcome [%s] to tv page # # 问题： # 调用端还没有调用 tv()，扩展的功能就执行执行
def login(func): print("passer user vertification...") return func @login #@login等效于tv = login(tv) def tv(): print("Welcome [%s] to tv page") tv() # 输出 # passer user vertification... # Welcome [%s] to tv page # # 问题： # 调用端还没有调用 tv()，扩展的功能就执行执行
def login(func): def inner(): print("passed user vertification...") func() return inner def home(): print("Welcome [%s] to home page" % name) # @login # tv=login(tv) def tv(): print("Welcome [%s] to tv page") def movie(): print("Welcome [%s] to home movie" % name) tv=login(tv) tv()
def outer(func): def inner(args): print("passed user vertification...") func(args) return inner @outer # 这个@outer相当于将outer下面的函数当outer的参数执行,也即，tv = outer(tv) def tv(name): print("Welcome [%s] to tv page" % name) tv('hy') ### passed user vertification... Welcome [hy] to tv page
需求二：需求一 + 传递参数 + 返回值
def outer(func): def inner(args): print("passed user vertification...") func(args) return inner @outer # 这个@outer相当于将outer下面的函数当outer的参数执行,也即，tv = outer(tv) def tv(name): print("Welcome [%s] to tv page" % name) tv('hy') ### passed user vertification... Welcome [hy] to tv page
def outer(func): # func=tv，函数的地址其实传到了这里 def inner(args): # 参数其实传到了这里（记） print("passed user vertification...") func(args) # tv(name) return inner @outer # == tv=outer(tv)/inner1=outer(tv) # tv=inner，tv()=inner() # 这个@outer相当于将outer下面的函数当outer的参数执行,也即，tv = outer(tv) def tv(name): # 传过去tv函数的地址 print("Welcome [%s] to tv page" % name) tv('hy') # inner('hy') # 第一次@outer:tv函数还在,inner==tv;第二次：tv('hy')==inner('hy') # 第一次执行 # @outer → inner1=outer(tv) #这个tv是函数 # def inner(args): #参数其实传到了这里（记） # print("passed user vertification...") # func(args) # tv(name) # 第二次执行 # tv('hy') → inner1('hy') # 执行结果 passed user vertification... Welcome [hy] to tv page #------------------------- 对比 --------------- def line_conf(a, b): def line(x): # line变量 return a * x + b return line # 没有执行，指向函数的地址 line1 = line_conf(1, 1) # 正常来说，函数调用结束，内部所有变量销毁，但是由于闭包会储存在内存中，利用这个bug，可以执行后面的。 # def line(x): # return a*x + b print(line1(5)) # 正常来说，a,b在这步没有了（但是有） #执行结果###### # 6 # 25
def outer(func): # func=tv def inner(*args, **kwargs): # 参数其实传到了这里 print("passed user vertification...") addfunc = func(*args, **kwargs) print("passed user logout...") return addfunc return inner @outer # tv=outer(tv),tv=inner,tv()=inner() def tv(name): print("Welcome [%s] to tv page" % name) return 6 print(tv('hy')) --------------------------------------------------------------- 关于参数 'hy' 为什么传到了inner，因为第二次tv('hy') = inner1(arg) 总结： 1.装饰器的原理是闭包； 2.闭包的作用是第一次执行后，函数tv还在inner中
def outer(func): # func=tv def inner(*args, **kwargs): # 参数其实传到了这里 print("passed user vertification...") func(*args, **kwargs) return inner @outer # tv=outer(tv),tv=inner,tv()=inner() def tv(name): print("Welcome [%s] to tv page" % name) tv('hy') ####### passed user vertification... Welcome [hy] to tv page
def outer(func): # func=tv def inner(args): # 参数其实传到了这里 print("passed user vertification...") return func(args) return inner @outer # tv=outer(tv),tv=inner,tv()=inner() def tv(name): print("Welcome [%s] to tv page" % name) return 6 print tv('hy') ######## passed user vertification... Welcome [hy] to tv page 6
def outer(func): # func=tv def inner(*args, **kwargs): # 参数其实传到了这里 print("passed user vertification...") return func(*args, **kwargs) return inner @outer # tv=outer(tv),tv=inner,tv()=inner() def tv(name): print("Welcome [%s] to tv page" % name) return 6 print tv('hy') ######## passed user vertification... Welcome [hy] to tv page
需求三：需求二 + 含参装饰器
def wrapper(*wrapperargs): def outer(func): # func=tv def inner(*args, **kwargs): # 参数其实传到了这里 print("passed user vertification...") print '[%s] looks like very [%s]' % (''.join(args), ''.join(wrapperargs)) return func(*args, **kwargs) return inner return outer @wrapper('shuai') # tv=outer(tv),tv=inner,tv()=inner() def tv(name): print("Welcome [%s] to tv page" % name) return 6 print tv('hy') ######## passed user vertification... [hy] looks like very [shuai] Welcome [hy] to tv page 6
def Before(): print('before') def After(): print('after') def wrapper(before_func, after_func): def outer(func): # func=tv def inner(*args, **kwargs): # 参数其实传到了这里 print("passed user vertification...") before_func() after_func() return func(*args, **kwargs) return inner return outer @wrapper(Before, After) def tv(name): print("Welcome [%s] to tv page" % name) return 6 print(tv('hy')) ####### passed user vertification... before after Welcome [hy] to tv page func有返回值+func动态参数+装饰器参数(函数作为参数)
需求四：多层装饰器
def outer(func): def inner(*args,**kwargs): print('log') r=func(*args,**kwargs) print('after') return r return inner def outer2(func): def inner(*args,**kwargs): if LOGIN_INFO['is_login']: r=func() return r else: print('please login') return inner #如果套两层装饰器，就是双层装饰器了，当然也有三层，四层，道理类似 #这里大家可能有疑惑，python在解释有 “@+函数”这种格式的语法时，会自动从里向外解读，再从外向内执行， #也就是最里层的原函数被逐层装饰直到最外层，对应例子里，python先把f2（原函数）发给outer2（里层装饰器），被装饰后的outer2的inner再 #被outer（外层装饰器）装饰，最终返回的是outer的inner函数体。 @outer @outer2 def f2(a,v): print('F2') #当然有人问主函数的调用为啥这样写呢，这个会在模块对于的blog中介绍 if __name__ == '__main__': f2
4，类装饰器
装饰函数
再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。
class Outer(object): def __init__(self, func): self._func = func def __call__(self): self._func() @Outer # tv=Outer(tv) def tv(): print("Welcome to tv page") tv() ### Welcome to tv page
6，生成式
1，列表生成器（推导式）
python一种独特的语法，相当于语法糖的存在，可以帮你在某些场合写出比较精简炫酷的代码，带没有它，也不会有太多的影响。
语法糖指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。
需求：把a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]里面的每个元素+1
# sb版本
>>> b = []
>>> for i in a:b.append(i+1)
>>> a = b
# 普通版本
a = [1,3,4,6,7,7,8,9,11]
for index,i in enumerate(a):
a[index] +=1
print(a)
# 文艺版本
>>> a = map(lambda x:x+1,a)
>>> a
<map object at 0x02861810>
>>> list(a)
[2, 3, 4, 5, 6, 7, 8, 9]
装逼版本（列表生成式版本）
>>> a = [i+1 for i in range(10)] >>> a [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>>a = [i for i in range(5) if i % 2 == 0 and not i == 2]
>>>print(a)
[0,4]
加入三元运算式
# 三元运算加入 a = list(range(10)) c = [i if 8 < 5 else i+1 for i in a]
# 每次都会先执行for i in a,然后再循环前面的部分，每循环一次，前面都会执行一次，挨个得出相应的值并存放 # a可以循环字典，元组，甚至字符串
print(c) # 执行结果 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
面试真题
# 看下面代码回答输出的结果是什么?为什么？ result = [lambda x: x + i for i in range(10)] print(result[0](10)) 这是一个结合了变量作用域、列表推导式和匿名函数的题目，较为复杂，比较考验Python基础知识掌握程度。有同学可能会回答10，其实答案是19，并且result[0~9](10)的结果都是19。 这是因为函数具有调用时才查找变量的特性。在你没调用它之前，它不会保存也不关心它内部变量的具体值。只有等到你调用它的时候，它才逐一去找这些变量的具体值。这里的result[0]被调用的时候，变量i已经循环完毕，变成9了，而不是想象中的动态0-9值。 那如果不想要这样的结果，想要i是循环的值怎么办?不要直接引用上层变量，把变量直接传进来。 result = [lambda x, i=i: x + i for i in range(10)] print(result[0](10))
2，生成器
作用：
1.逐步生成序列，不用像列表一样初始化时就要开辟所有的空间（相当于python2.x的xrange）
2.模拟并发：协程（Python实现协程最简单的方法，就是使用yield）
定义：如果函数中包含yield语法，那这个函数就会变成生成器，这个函数调用时返回一个迭代器，生成器属于迭代器
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
生成器也可以理解为（迭代器对象返回的是函数；特殊的函数；特殊的迭代器（遍历无序数据结构），而特殊在迭代器对象是一个函数，不是列表，字符串（数字）的集合对象。）
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g <generator object <genexpr> at 0x1022ef630>
L是一个list，g是一个generator，如果要一个一个打印出来，使用next()函数获得generator的下一个返回值。
特性：1，取一次创建一次。2，只能往前走，不能回退。
>>> next(g) 0 >>> next(g) 1 >>> next(g) 4 >>> next(g) 9
使用while执行完以后也会报错。
a = list(range(5)) while True: next(a) # 执行结果：正常的执行完以后还是会报错。
生成器循环最好使用for来进行。
使用next，while生产完后会报错，但是用for循环不会报错，而generator也是可迭代对象：
>>> g = (x * x for x in range(4)) >>> for n in g: ... print(n) ... 0 1 4 9
斐波那契数列：除第一个和第二个数外，任意一个数都可由前面两个数相加得到。
1, 1, 2, 3, 5, 8, 13, 21...
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b # 相当于 t = a + b, a = b, b = t
n = n + 1
return 'done'
fib(3)
执行结果：1，1，2，3
利用yield改为生成器
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print('before yield')
yield b # 把函数的执行过程冻结在这一步，并且把b的值返回给外面的next()
print(b)
a, b = b, a+b
n = n+1
return "done"
f = fib(15) # turn function into a generator
next(f) # fitst time call next()
next(f)
next(f)
next(f)
next(f)
# 执行结果
before yield
1
before yield
1
before yield
2
before yield
3
before yield
在函数执行中，有些数据想返回到外部程序里，可以使用yield
里边有yield，函数名一加括号，内部代码根本不执行，只是生成一个生成器对象，
3，生成器调用方法
在python2中，range = list， xrange = 生成器
在python3中，range = 生成器， xrange 没有
4，函数生成器
支持更复杂的步骤，可以使用函数生成器。
def range2(n):
conut = 0
while conut < n:
print('count', count)
count += 1
yield count
new_range = range2(10)
r1 = next(new_range)
print(r1)
r2 = next(new_range) # 相等于 r2 = new_range.__next__
print(r2)
yield vs return
return 返回并中止函数
yield 返回 数据，并冻结当前的执行过程
next 唤醒冻结的函数执行过程，继续执行，直到遇到下一个yield
函数有了yield之后
函数名加()就变得到了一个生成器。
return在生成器里，代表生成器的中止，直接报错。
5，生成器send方法
sent作用：
唤醒并继续执行
发送一个信息到生成器内部
def range2(n):
conut = 0
while conut < n:
print('count', count)
count += 1
sign = yield count
if sign == 'stop':
print('----sign',sign)
break
new_range = range2(3)
n1= next(new_range)
new_range.send('stop')
# 执行结果
count 0
----sign stop
count 1
6，协程函数
利用yield将函数变成一个generater（生成器），整个函数变成一个generater对象，函数返回一个iterable对象（迭代值）
当一个函数在执行过程中被阻塞时，就用yield挂起，然后执行另一个函数。当阻塞结束后，可以用next()或者send()唤醒。相比多线程，协程的好处是它在一个线程内执行，避免线程之间切换带来的额外开销，而且多线程中使用共享资源，往往需要加锁，而协程不需要，因为代码的执行顺序是你完全可以预见的，不存在多个线程同时写某个共享变量而导致出错的情况。
#如果在一个函数内部yield的使用方式是表达式形式的话，如x=yield，那么该函数成为协程函数
def eater(name):
print('%s start to eat food' % name)
food_list = []
while True:
food = yield food_list
print('%s get %s ,to start eat' % (name, food))
food_list.append(food)
print('done')
e = eater('钢蛋')
# print(e)
print(next(e))
print(e.send('包子'))
print(e.send('韭菜馅包子'))
print(e.send('大蒜包子'))
###
钢蛋 start to eat food
[]
钢蛋 get 包子 ,to start eat
done
['包子']
钢蛋 get 韭菜馅包子 ,to start eat
done
['包子', '韭菜馅包子']
钢蛋 get 大蒜包子 ,to start eat
done
['包子', '韭菜馅包子', '大蒜包子']
yield的表达式形式：
yield的表达式形式：
food=yield
def eater(name):
print('%s start to eat' %name)
while True:
food=yield
print('%s eat %s' %(name,food))
e=eater('钢蛋')
#e.send与next(e)的区别
#1.如果函数内yield是表达式形式，那么必须先next(e)
#2.二者的共同之处是都可以让函数在上次暂停的位置继续运行，不一样的地方在于
# send在触发下一次代码的执行时，会顺便给yield传一个值
7，生成器总结
生成器是这样一个函数，它记住上一次返回时在函数体中的位置。对生成器函数的第二次（或第 n 次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。
生成器不仅“记住”了它数据状态；生成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置。
生成器的特点：
- 节约内存
- 迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即是说，在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的
from collections import Iterator #生成器就是一个函数，这个函数内包含有yield这个关键字 def test(): print('one') yield 1 #return 1 g=test() print(g) print(isinstance(g,Iterator)) ### <generator object test at 0x000001E80F8F0780> True --------------------------------------------------------------------- from collections import Iterator #生成器就是一个函数，这个函数内包含有yield这个关键字 def test(): print('one') yield 1 #return 1 g=test() print(g) print(isinstance(g,Iterator)) print(next(g)) ### <generator object test at 0x0000023F1F5E0780> True one #调用next方法时，生成器才执行 1 -------------------------------------------------------------- def countdown(n): print('start coutdown') while n > 0: yield n #1 n-=1 print('done') g=countdown(5) # print(g) # print(next(g)) # print(next(g)) # print(next(g)) # print(next(g)) # print(next(g)) # print(next(g)) # for i in g: #iter(g) # print(i) # while True: # try: # print(next(g)) # except StopIteration: # break ------------------------------------------ >>> def createGenerator() : ... mylist = range(3) ... for i in mylist : ... yield i*i ... >>> mygenerator = createGenerator() # create a generator >>> print(mygenerator) # mygenerator is an object! <generator object createGenerator at 0xb7555c34> >>> for i in mygenerator: ... print(i) 0 1 4
7，迭代式
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
迭代器就类似一个循环，迭代一次，就是相当于循环一次。
可以直接作用于for循环的数据类型：
- 一类是集合数据类型，如
list、tuple、dict、set、str等； - 一类是
generator（生成器），包括生成器和带yield的 generator function。
1，可迭代对象
直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象：
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，知道最后抛出Stopiteration错误表示无法继续。
2，迭代器：是一种数据流
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
可以使用isinstance()判断一个对象是否是Iterator对象：
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
3，小结
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python3的for循环本质上就是通过不断调用next()函数实现的，例如：
for x in [1, 2, 3, 4, 5]:
pass
实际上完全等价于：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break
8，函数中的一些大坑
①函数的默认函数一定要是不变对象(immutable)
- str
- int
- float
- tuple
- 数值型（number）
看下面一个例子:
def foo(bar=[]):
bar.append('a')
return bar
print(foo())#['a']
print(foo())#['a','a']
print(foo())#['a','a','a']
乍一眼一看，每次调用foo()，变量bar都应该重置为[]啊，为什么上一次的结果会进行保留呢？
从Python文档中可以找到这样一句话
Important warning: The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls:
翻译过来就是：重要警告：默认值只计算一次。当默认值是可变对象（如列表，字典或大多数类的实例）时，这会有所不同。例如，以下函数会累积在后续调用中传递给它的参数。
这个原因是由于默认参数只计算一次，因为list 是可变数据类型，函数每次调用时，L 是同一个对象的引用。就相当于全局变量一般了
改进方法：
def foo(bar=None):
if bar is None:
bar=[]
bar.append('a')
print(foo())#['a']
print(foo())#['a']
print(foo())#['a']
记住，默认参数一定要是不可变类型