python done函数_python-函数进阶

python-函数进阶

1，名称空间

又名name space, 顾名思义就是存放名字的地方，存什么名字呢？举例说明，若变量x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方

名称空间共3种，分别如下

locals: 是函数内的名称空间，包括局部变量和形参

globals: 全局变量，函数定义所在模块的名字空间

builtins: 内置模块的名字空间，通过dir(_builtins_)查看

>>> globals()

{'__doc__': None, '__package__': None, '__loader__': ,

'__builtins__': ,

'x': 1, '__name__': '__main__', '__spec__': None}

>>>

>>> locals()

{'__doc__': None, '__package__': None, '__loader__': ,

'__builtins__': ,

'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()

# 执行结果

.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 _*_

deflogin(func):print("passer user vertification...")

func()deftv():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 tv()

TypeError:'NoneType' object is notcallable

问题：1.调用方法改变了2.调用端还没有调用 tv()，扩展的功能就先执行了

v1

deflogin(func):print("passer user vertification...")returnfunc

@login#@login等效于tv = login(tv)

deftv():print("Welcome [%s] to tv page")

tv()#输出#passer user vertification...#Welcome [%s] to tv page#

#问题：#调用端还没有调用 tv()，扩展的功能就执行执行

v2

deflogin(func):print("passer user vertification...")returnfunc

@login#@login等效于tv = login(tv)

deftv():print("Welcome [%s] to tv page")

tv()#输出#passer user vertification...#Welcome [%s] to tv page#

#问题：#调用端还没有调用 tv()，扩展的功能就执行执行

v2.1

deflogin(func):definner():print("passed user vertification...")

func()returninnerdefhome():print("Welcome [%s] to home page" %name)#@login # tv=login(tv)

deftv():print("Welcome [%s] to tv page")defmovie():print("Welcome [%s] to home movie" %name)

tv=login(tv)

tv()

v3.1 加个闭包

defouter(func):definner(args):print("passed user vertification...")

func(args)returninner

@outer#这个@outer相当于将outer下面的函数当outer的参数执行,也即，tv = outer(tv)

deftv(name):print("Welcome [%s] to tv page" %name)

tv('hy')###

passed user vertification...

Welcome [hy] to tv page

v3.2 加个闭包

需求二：需求一 + 传递参数 + 返回值

defouter(func):definner(args):print("passed user vertification...")

func(args)returninner

@outer#这个@outer相当于将outer下面的函数当outer的参数执行,也即，tv = outer(tv)

deftv(name):print("Welcome [%s] to tv page" %name)

tv('hy')###

passed user vertification...

Welcome [hy] to tv page

func无返回值+普通参数

def outer(func): #func=tv，函数的地址其实传到了这里

def inner(args): #参数其实传到了这里(记)

print("passed user vertification...")

func(args)#tv(name)

returninner

@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#------------------------- 对比 ---------------

defline_conf(a, b):def line(x): #line变量

return a * x +breturn line #没有执行，指向函数的地址

line1= line_conf(1, 1) #正常来说，函数调用结束，内部所有变量销毁，但是由于闭包会储存在内存中，利用这个bug，可以执行后面的。#def line(x):#return a*x + b

print(line1(5)) #正常来说，a,b在这步没有了(但是有)

#执行结果#######6#25

func无返回值 + 普通参数 理解

def outer(func): #func=tv

def inner(*args, **kwargs): #参数其实传到了这里

print("passed user vertification...")

addfunc= func(*args, **kwargs)print("passed user logout...")returnaddfuncreturninner

@outer#tv=outer(tv),tv=inner,tv()=inner()

deftv(name):print("Welcome [%s] to tv page" %name)return 6

print(tv('hy'))---------------------------------------------------------------关于参数'hy'为什么传到了inner，因为第二次tv('hy') =inner1(arg)

总结：1.装饰器的原理是闭包；2.闭包的作用是第一次执行后，函数tv还在inner中

func无返回值 + 普通参数 + 新函数

def outer(func): #func=tv

def inner(*args, **kwargs): #参数其实传到了这里

print("passed user vertification...")

func(*args, **kwargs)returninner

@outer#tv=outer(tv),tv=inner,tv()=inner()

deftv(name):print("Welcome [%s] to tv page" %name)

tv('hy')#######

passed user vertification...

Welcome [hy] to tv page

func无返回值 + 动态参数

def outer(func): #func=tv

def inner(args): #参数其实传到了这里

print("passed user vertification...")returnfunc(args)returninner

@outer#tv=outer(tv),tv=inner,tv()=inner()

deftv(name):print("Welcome [%s] to tv page" %name)return 6

print tv('hy')########

passed user vertification...

Welcome [hy] to tv page6

func有返回值 + 普通参数

def outer(func): #func=tv

def inner(*args, **kwargs): #参数其实传到了这里

print("passed user vertification...")return func(*args, **kwargs)returninner

@outer#tv=outer(tv),tv=inner,tv()=inner()

deftv(name):print("Welcome [%s] to tv page" %name)return 6

print tv('hy')########

passed user vertification...

Welcome [hy] to tv page

func有返回值 + 动态参数

需求三：需求二 + 含参装饰器

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)returninnerreturnouter

@wrapper('shuai') #tv=outer(tv),tv=inner,tv()=inner()

deftv(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 page6

func有返回值+func动态参数+装饰器动态参数

defBefore():print('before')defAfter():print('after')defwrapper(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)returninnerreturnouter

@wrapper(Before, After)deftv(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动态参数+装饰器参数(函数作为参数)

func有返回值+func动态参数+装饰器参数(函数作为参数)

需求四：多层装饰器

defouter(func):def inner(*args,**kwargs):print('log')

r=func(*args,**kwargs)print('after')returnrreturninnerdefouter2(func):def inner(*args,**kwargs):if LOGIN_INFO['is_login']:

r=func()returnrelse:print('please login')returninner#如果套两层装饰器，就是双层装饰器了，当然也有三层，四层，道理类似#这里大家可能有疑惑，python在解释有 “@+函数”这种格式的语法时，会自动从里向外解读，再从外向内执行，#也就是最里层的原函数被逐层装饰直到最外层，对应例子里，python先把f2(原函数)发给outer2(里层装饰器)，被装饰后的outer2的inner再#被outer(外层装饰器)装饰，最终返回的是outer的inner函数体。

@outer

@outer2deff2(a,v):print('F2')#当然有人问主函数的调用为啥这样写呢，这个会在模块对于的blog中介绍

if __name__ == '__main__':

f2

随意组合上面几种类型装饰器

4，类装饰器

装饰函数

再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

classOuter(object):def __init__(self, func):

self._func=funcdef __call__(self):

self._func()

@Outer#tv=Outer(tv)

deftv():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

>>> 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

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))whileTrue:

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 importIterator#生成器就是一个函数，这个函数内包含有yield这个关键字

deftest():print('one')yield 1 #return 1

g=test()print(g)print(isinstance(g,Iterator))###

True---------------------------------------------------------------------

from collections importIterator#生成器就是一个函数，这个函数内包含有yield这个关键字

deftest():print('one')yield 1 #return 1

g=test()print(g)print(isinstance(g,Iterator))print(next(g))###

True

one#调用next方法时，生成器才执行

1

--------------------------------------------------------------

defcountdown(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

------------------------------------------

>>> defcreateGenerator() :

... mylist= range(3)

...for i inmylist :

...yield i*i

...>>> mygenerator = createGenerator() #create a generator

>>> print(mygenerator) #mygenerator is an object!

>>> for i inmygenerator:

...print(i)

01

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']

记住，默认参数一定要是不可变类型