【澳门葡京备用网址】浅谈python中的生成器,魔法方法

目录:

  • 调用3个常备的函数,一般是从函数的第②行代码开始推行,至return语句、万分恐怕具有语句执行达成,能够领略为函数执行到位。一旦函数使用达成,函数中做的有着工作以及保存在一部分变量中的数据都都会丢掉。下次使用该函数时,一切又都从头开首。

  • 生成器能够使得Python模仿协同程序的定义可以完毕。
    *
    协同程序:可以运营的独门函数调用,函数能够暂停大概挂起,并且在急需的时候从程序离开的地点再三再四可能是重新起初运转。

  • 生成器能够目前挂起函数,并保留函数的一些变量等数码,然后下次调用的时候,从上四遍暂停的地点继续执行下去。

一,什么是迭代器协议

15 Python 迭代器和生成器,15python生成器

  一、生成器

练习1

In [1]: def myGen():
   ...:     print("生成器被执行!")
   ...:     yield 1
   ...:     yield 2
   ...:     

In [2]: myGenerator = myGen()

In [3]: next(myGenerator)
生成器被执行!
Out[3]: 1

In [4]: next(myGenerator)
Out[4]: 2

In [5]: next(myGenerator)
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-5-fc98abb8b680> in <module>()
----> 1 next(myGenerator)

StopIteration: 

注意:当函数截至时,抛出一个StopIteration十分。Python中的for循环会自动调用next()方法和拍卖StopIteration非凡,即for循环能够对生成器爆发效益。

1.迭代器协议是指:对象必须提供二个next方法,执行该措施只怕重返迭代中的下一项,要么就挑起2个StopIteration万分,以为止迭代
(只好以往走不可以往前退)

什么样是迭代 (iterable)

  字符串、列表、元组、字典、集合都足以被for循环,说明他们都以可迭代的

  可以直接效率于for循环的目的统称为可迭代对象(Iterable)。

  可以被next()函数调用并频频重临下3个值的目的称为迭代器(Iterator)。

  全数的Iterable均能够因此内置函数iter()来变化为Iterator。

  对迭代器来讲,有八个__next__()就够了。在您采纳for 和 in
语句时,程序就会自动调用即将被处理的目的的迭代器对象,然后利用它的__【澳门葡京备用网址】浅谈python中的生成器,魔法方法。next__()方法,直到监测到1个StopIteration非凡。

  可迭代协议

    大家以后是从结果分析原因,能被for循环的就是“可迭代的”,可是假使正考虑,for怎么通晓何人是可迭代的啊?

    即使大家团结写了两个数据类型,希望那个数据类型里的东西也能够应用for被多少个1个的取出来,那我们就亟须满意for的渴求。这些须要就叫做“协议”。

  可以被迭代要满意的须求就叫做可迭代协议。可迭代协议的定义万分不难,就是里面贯彻了__iter__方法。

澳门葡京备用网址 1

 1 >>> L = [1,2,3]
 2 >>> [x**2 for x in L]
 3 [1, 4, 9]
 4 >>> next(L)
 5 Traceback (most recent call last):
 6   File "<stdin>", line 1, in <module>
 7 TypeError: 'list' object is not an iterator
 8 >>> I=iter(L)
 9 >>> next(I)
10 1
11 >>> next(I)
12 2
13 >>> next(I)
14 3
15 >>> next(I)
16 Traceback (most recent call last):
17   File "<stdin>", line 1, in <module>
18 StopIteration

View Code

  上边例子中,列表L可以被for进行巡回然而无法被内置函数next()用来寻觅下三个值,所以L是Iterable。

  L通过iter进行打包后设为I,I可以被next()用来寻觅下三个值,所以I是Iterator。

澳门葡京备用网址 2

 1 >>> L = [4,5,6]
 2 >>> I = L.__iter__()
 3 >>> L.__next__()
 4 Traceback (most recent call last):
 5   File "<stdin>", line 1, in <module>
 6 AttributeError: 'list' object has no attribute '__next__'
 7 >>> I.__next__()
 8 4
 9 >>> from collections import Iterator, Iterable
10 >>> isinstance(L, Iterable)
11 True
12 >>> isinstance(L, Iterator)
13 False
14 >>> isinstance(I, Iterable)
15 True
16 >>> isinstance(I, Iterator)
17 True
18 >>> [x**2 for x in I]    
19 [25, 36]

View Code

  二 、课时49课后习题及答案

练习2

In [6]: for i in myGen():
   ...:     print(i)
   ...:     
生成器被执行!
1
2

2.可迭代对象:完毕了迭代器协议的靶子(怎样促成:对象内部定义三个__iter__()方法)

迭代器

迭代器遵循迭代器协议:必须持有__iter__方法和__next__方法。

全体访问生成器的力量,能够访问到生成器的值,类似于生成器的__next__主意,三个一个值壹个值得去迭代,只好够依据顺序的去寻找。

特点:

澳门葡京备用网址 3

1 print('__next__' in dir(range(12)))  #查看'__next__'是不是在range()方法执行之后内部是否有__next__
2 print('__iter__' in dir(range(12)))  #查看'__next__'是不是在range()方法执行之后内部是否有__next__
3 
4 from collections import Iterator
5 print(isinstance(range(100000000),Iterator))  #验证range执行之后得到的结果不是一个迭代器

View Code

 

以生成器的点子贯彻斐波那契数列

In [7]: def fibs():
   ...:     a = 0
   ...:     b = 1
   ...:     while True:
   ...:         a , b = b ,a + b
   ...:         yield a
   ...:         

In [8]: for each in fibs():
   ...:     if each > 100:
   ...:         break
   ...:     print(each)
   ...:   
结果如下:  
1
1
2
3
5
8
13
21
34
55
89

3.切磋是一种约定,可迭代对象已毕了迭代器协议,python的里边工具(如for循环,sum,min,max函数等)使用迭代器协议访问对象。

yield from

澳门葡京备用网址 4

 1 def gen1():
 2     for c in 'AB':
 3         yield c
 4     for i in range(3):
 5         yield i
 6 
 7 print(list(gen1()))
 8 
 9 def gen2():
10     yield from 'AB'
11     yield from range(3)
12 
13 print(list(gen2()))

View Code

*********************

推导式(列表、字典、集合

  • 1.列表推导式

In [1]: a = [i for i in range(100) if not( i % 2 )and i % 3]

In [2]: print(a)
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]

注意:上述列表推导式求得是100以内,能被2整除,但无法被3整除的全体整数。

  • 2.字典推导式

In [3]: b = {i:i % 2 == 0 for i in range(10)}

In [4]: print(b)
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}
  • 3.会见推导式

In [5]: c = {i for i in [1,1,2,3,3,4,5,5,5,5,7,8,9,41]}

In [6]: print(c)
{1, 2, 3, 4, 5, 7, 8, 9, 41}
  • 4.生成器推导式

In [7]: e = (i for i in range(10))

In [8]: e
Out[8]: <generator object <genexpr> at 0x000001B8579DBF10>

注意:generator就是生成器的意趣,用一般的小括号括起来的正是生成式推导式,表明如下:

In [11]: next(e)
Out[11]: 0

In [12]: next(e)
Out[12]: 1

In [13]: next(e)
Out[13]: 2

In [14]: next(e)
Out[14]: 3

In [15]: next(e)
Out[15]: 4

In [16]: next(e)
Out[16]: 5
for循环打印出剩余的:
In [17]: for each in e:
    ...:     print(each)
    ...:     
6
7
8
9
  • 生成器推导式假如作为函数的参数,可以直接写推导式,不用加小括号:

In [1]: sum(i for i in range(100) if i % 2)
Out[1]: 2500

二,for循环的真面目

生成器

  1.生成器函数:常规函数定义,不过,使用yield语句而不是return语句重返结果。yield语句四次回到3个结实,在每一种结果中间,挂起函数的景观,以便下次重它离开的地点继续执行

  2.生成器表明式:类似于列表推导,不过,生成器重回按需发生结果的壹个目的,而不是五回营造二个结实列表

 

生成器Generator:

澳门葡京备用网址 ,  本质:迭代器(所以自带了__iter__方法和__next__措施,不需求我们去完结)

  特点:惰性运算,开发者自定义

生成器函数

  多个包括yield关键字的函数就是2个生成器函数。yield可以为我们从函数中重临值,但是yield又不一致于return,return的履行代表程序的甘休,调用生成器函数不会得到重临的切实的值,而是得到贰个可迭代的对象。每便得到这一个可迭代对象的值,就能拉动函数的进行,获取新的重临值。直到函数执行已毕。

  仅仅拥有生成某种东西的能力,假设不用__next__艺术是获取不到值得。

  创造三个生成器函数

澳门葡京备用网址 5

 1 >>> def scq():
 2     print("11")
 3        # 当函数代码块中遇到yield关键字的时候,这个函数就是一个生成器函数
 4     yield 1
 5     print("22")
 6     yield 2
 7     print("33")
 8     yield 3
 9 
10 
11 # 把生成器赋值给一个对象
12 
13 >>> r = scq()
14 
15 # 查看r的苏剧类型并且输出r的值
16 
17 >>> print(type(r),r)
18 <class 'generator'> <generator object scq at 0x000001F117D8DF10> 
19 
20 # 当执行生成器的__next__的时候,代码会按照顺序去执行,当执行到yield时会返回并
21 # 提出,yield后面的值就是返回值,然后记录代码执行的位置,并退出
22 
23 >>> ret = r.__next__()
24 11
25 
26 # 第二次执行的时候会根据上次代码执行的位置继续往下执行
27 
28 >>> ret = r.__next__()
29 22
30 >>> ret = r.__next__()
31 33
32 
33 # 如果__next__获取不到值的时候就会报StopIteration错误
34 
35 >>> ret = r.__next__()
36 Traceback (most recent call last):
37   File "<stdin>", line 1, in <module>
38 StopIteration

View Code

  利用生成器创造两个range

澳门葡京备用网址 6

 1 # 创建一个生成器函数,函数名是range,n是传入的参数,也是输出的数的最大值
 2 def range(n):
 3     # 默认从0开始
 4     start = 0
 5     # 进入while循环,如果最小值小于最大值就进入循环
 6     while start < n:
 7         # 第一次返回start,下面代码不执行
 8         yield start
 9         # 第二次进来的时候start = start + 1,然后进入下一次循环
10         start += 1
11 
12 # 停止的参数为5
13 obj = range(5)
14 # 第一个数赋值给n1
15 n1 = obj.__next__()
16 # 第二个数赋值给n2
17 n2 = obj.__next__()
18 # 第三个数赋值给n3
19 n3 = obj.__next__()
20 # 第四个数赋值给n4
21 n4 = obj.__next__()
22 # 第五个数赋值给n5
23 n5 = obj.__next__()
24 
25 # 输出这五个数的值
26 print(n1,n2,n3,n4,n5)
27 
28 # 执行结果
29 
30 C:\Python35\python.exe F:/Python_code/sublime/Week5/Day03/s1.py
31 0 1 2 3 4
32 
33 Process finished with exit code 0

View Code

  生成器监听文件输入的例题

澳门葡京备用网址 7

 1 import time
 2 
 3 
 4 def tail(filename):
 5     f = open(filename)
 6     f.seek(0, 2) #从文件末尾算起
 7     while True:
 8         line = f.readline()  # 读取文件中新的文本行
 9         if not line:
10             time.sleep(0.1)
11             continue
12         yield line
13 
14 tail_g = tail('tmp')
15 for line in tail_g:
16     print(line)

View Code

 总结移动平均值(1)

澳门葡京备用网址 8

 1 def averager():
 2     total = 0.0
 3     count = 0
 4     average = None
 5     while True:
 6         term = yield average
 7         total += term
 8         count += 1
 9         average = total/count
10 
11 
12 g_avg = averager()
13 next(g_avg)
14 print(g_avg.send(10))
15 print(g_avg.send(30))
16 print(g_avg.send(5))

View Code

 总括移动平均值(2)预激协程的装饰器

澳门葡京备用网址 9

 1 def init(func):  #在调用被装饰生成器函数的时候首先用next激活生成器
 2     def inner(*args,**kwargs):
 3         g = func(*args,**kwargs)
 4         next(g)
 5         return g
 6     return inner
 7 
 8 @init
 9 def averager():
10     total = 0.0
11     count = 0
12     average = None
13     while True:
14         term = yield average
15         total += term
16         count += 1
17         average = total/count
18 
19 
20 g_avg = averager()
21 # next(g_avg)   在装饰器中执行了next方法
22 print(g_avg.send(10))
23 print(g_avg.send(30))
24 print(g_avg.send(5))

View Code

列表推导式和生成器表达式

澳门葡京备用网址 10

 1 #老男孩由于峰哥的强势加盟很快走上了上市之路,alex思来想去决定下几个鸡蛋来报答峰哥
 2 
 3 egg_list=['鸡蛋%s' %i for i in range(10)] #列表解析
 4 
 5 #峰哥瞅着alex下的一筐鸡蛋,捂住了鼻子,说了句:哥,你还是给我只母鸡吧,我自己回家下
 6 
 7 laomuji=('鸡蛋%s' %i for i in range(10))#生成器表达式
 8 print(laomuji)
 9 print(next(laomuji)) #next本质就是调用__next__
10 print(laomuji.__next__())
11 print(next(laomuji))

View Code

一、生成器

补充:

运维条件:Anaconda3 中的Jupyter
QTConsole,还是能动用PyCharm或然python3自带的IDLE(适合新手学习运用)
下载地址:
<a
href=”;

python学习交换群:463024091
作者qq:1070457631

循环全部目的,全都以采用迭代器协

种种推导式详解

  推导式的老路

    在此以前大家早就学习了最简易的列表推导式和生成器表明式。但是除此之外,其实还有字典推导式、集合推导式等等。

    下边是二个以列表推导式为例的推导式详细格式,同样适用于其他推导式。

澳门葡京备用网址 11

1 variable = [out_exp_res for out_exp in input_list if out_exp == 2]
2   out_exp_res:  列表生成元素表达式,可以是有返回值的函数。
3   for out_exp in input_list:  迭代input_list将out_exp传入out_exp_res表达式中。
4   if out_exp == 2:  根据条件过滤哪些值可以。

View Code

列表推导式

  例一:30以内装有能被3整除的数

澳门葡京备用网址 12

1 multiples = [i for i in range(30) if i % 3 is 0]
2 print(multiples)
3 # Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

View Code

  例二:30以内全体能被3整除的数的平方

澳门葡京备用网址 13

1 def squared(x):
2     return x*x
3 multiples = [squared(i) for i in range(30) if i % 3 is 0]
4 print(multiples)

View Code

  例三:找到嵌套列表中名字含有五个‘e’的富有名字

澳门葡京备用网址 14

1 names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
2          ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
3 
4 print([name for lst in names for name in lst if name.count('e') >= 2])  # 注意遍历顺序,这是实现的关键

View Code

字典推导式

  例一:将多个字典的key和value对调

澳门葡京备用网址 15

1 mcase = {'a': 10, 'b': 34}
2 mcase_frequency = {mcase[k]: k for k in mcase}
3 print(mcase_frequency)

View Code

  例二:合并大小写对应的value值,将k统1/10小写

澳门葡京备用网址 16

1 mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
2 mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys()}
3 print(mcase_frequency)

View Code

聚拢推导式

  例:统计列表中每一种值的平方,自带去重成效

澳门葡京备用网址 17

1 squared = {x**2 for x in [1, -1, 2]}
2 print(squared)
3 # Output: set([1, 4])

View Code

练习题:

  例1:  过滤掉长度小于3的字符串列表,并将剩余的转换到大写字母

  例2:  求(x,y)其中x是0-5中间的偶数,y是0-5中间的奇数组成的元祖列表

  例3:  求M中3,6,9结缘的列表M = [[1,2,3],[4,5,6],[7,8,9]]

澳门葡京备用网址 18

1 1.[name.upper() for name in names if len(name)>3] 
2 2.[(x,y) for x in range(5) if x%2==0 for y in range(5) if y %2==1] 
3 3. [row[2] for row in M]

View Code

 

总结:

  1.把列表解析的[]互换()得到的就是生成器表达式

  2.列表解析与生成器表明式都以一种有益的编程方式,只然则生成器表明式更省去内存

  3.Python不但利用迭代器协议,让for循环变得愈加通用。大多数放到函数,也是行使迭代器协议访问对象的。例如,
sum函数是Python的嵌入函数,该函数使用迭代器协议访问对象,而生成器已毕了迭代器协议,所以,大家得以一贯那样总计一文山会海值的和:

澳门葡京备用网址 19

1 sum(x ** 2 for x in range(4))
2 
3 # 而不用多此一举的先构造一个列表:
4 
5 sum([x ** 2 for x in range(4)]) 

View Code

可迭代对象:

  拥有__iter__方法

  特点:惰性运算

  例如:range(),str,list,tuple,dict,set

迭代器Iterator:

  拥有__iter__方法和__next__方法

  例如:iter(range()),iter(str),iter(list),iter(tuple),iter(dict),iter(set),reversed(list_o),map(func,list_o),filter(func,list_o),file_o

生成器Generator:

  本质:迭代器,所以具有__iter__方法和__next__方法

  特点:惰性运算,开发者自定义

利用生成器的助益:

1.延迟统计,一回回到七个结出。约等于说,它不会三次生成全部的结果,这对于大数据量处理,将会极度实用。

**2.增高代码可读性**

澳门葡京备用网址 20

1 #列表解析
2 sum([i for i in range(100000000)])#内存占用大,机器容易卡死
3  
4 #生成器表达式
5 sum(i for i in range(100000000))#几乎不占内存

View Code

生成器相关的面试题

  生成器在编程中生出了众多的听从,善用生成器可以支持我们缓解广大扑朔迷离的标题

  除此之外,生成器也是面试题中的重点,在形成部分成效之外,人们也想出了不少魔性的面试题。
  面试题(1)

澳门葡京备用网址 21

 1 def demo():
 2     for i in range(4):
 3         yield i
 4 
 5 g=demo()
 6 
 7 g1=(i for i in g)
 8 g2=(i for i in g1)
 9 
10 print(list(g1))
11 print(list(g2))

View Code

  面试题(2)

澳门葡京备用网址 22

 1 def add(n,i):
 2     return n+i
 3 
 4 def test():
 5     for i in range(4):
 6         yield i
 7 
 8 g=test()
 9 for n in [1,10]:
10     g=(add(n,i) for i in g)
11 
12 print(list(g))

View Code

  tail&grep

澳门葡京备用网址 23

 1 def demo():
 2     for i in range(4):
 3         yield i
 4 
 5 g=demo()
 6 
 7 g1=(i for i in g)
 8 g2=(i for i in g1)
 9 
10 print(list(g1))
11 print(list(g2))
12 
13 复制代码
14 复制代码
15 
16 def add(n,i):
17     return n+i
18 
19 def test():
20     for i in range(4):
21         yield i
22 
23 g=test()
24 for n in [1,10]:
25     g=(add(n,i) for i in g)
26 
27 print(list(g))
28 
29 复制代码
30 复制代码
31 
32 import os
33 
34 def init(func):
35     def wrapper(*args,**kwargs):
36         g=func(*args,**kwargs)
37         next(g)
38         return g
39     return wrapper
40 
41 @init
42 def list_files(target):
43     while 1:
44         dir_to_search=yield
45         for top_dir,dir,files in os.walk(dir_to_search):
46             for file in files:
47                 target.send(os.path.join(top_dir,file))
48 @init
49 def opener(target):
50     while 1:
51         file=yield
52         fn=open(file)
53         target.send((file,fn))
54 @init
55 def cat(target):
56     while 1:
57         file,fn=yield
58         for line in fn:
59             target.send((file,line))
60 
61 @init
62 def grep(pattern,target):
63     while 1:
64         file,line=yield
65         if pattern in line:
66             target.send(file)
67 @init
68 def printer():
69     while 1:
70         file=yield
71         if file:
72             print(file)
73 
74 g=list_files(opener(cat(grep('python',printer()))))
75 
76 g.send('/test1')
77 
78 协程应用:grep -rl /dir

View Code

 

Python 迭代器和生成器,15python生成器
什么是迭代 (iterable) 字符串、列表、元组、字典、集合
都足以被for循环,表明他们 都以可迭代的…

**********************

for循环可以遍历(字符串,列表,元组,字典,集合,文件对象),但是这几个都不是可迭代对象,只可是在for循环式,调用了她们之中的__iter__措施,把她们成为了可迭代对象。

生成器的上学并不关乎魔法方法,甚至它巧妙地避开了类和对象,仅通过普通地函数就足以已毕了。

下一场for循环调用可迭代对象的__next__主意去取值,而且for循环会捕捉StopIteration至极,以平息迭代。

生成器其实是迭代器的一种完结。

 

  • 生成器的发喜宝(Hipp)(Beingmate)(Meadjohnson)边是为了使得Python更为简单,因为,迭代器须要我们本身去定义二个类和促成相关的法门,而生成器则只需求在一般的函数中增进四个yield语句即可。
  • 另一方面,生成器的发明,使得Python模仿协同程序的概念可以贯彻。所谓协同程序,就是能够运作得独立函数调用,函数可以暂停恐怕挂起,并在必要得时候从程序离开得地点持续可能另行早先。
#:用while去模拟for循环做的事情
l=[1,2,3,4,5,6]
diedai_l=l.__iter__()
while True:
    try:
        print(diedai_l.__next__())
    except StopIteration:#捕捉到异常后退出
        break

对此调用1个一般性的Python函数,一般是从函数的首先行代码开头执行,停止于return语句、至极、恐怕函数全部语句执行完成。一旦函数将控制权交还给调用者,就意味着全部了事。函数中做的享有工作以及保存在一些变量中的数据都将遗失。再一次调用这几个函数时,一切将初叶创造。

 

Python是由此生成器来完结类似于协同程序的定义:生成器可以临时挂起函数,并保存函数的有的变量等数码,然后在重复调用它的时候,从上次浅尝辄止的职位继续执行下去。

三,怎么样查看是或不是可迭代的或然不是迭代器

举个例证:

 

 

from collections import Iterable
from collections import  Iterator
a=range(10)
a=range(10)
print(isinstance(a,Iterator))#查看是不是迭代器
print(isinstance(a,Iterable))#查看是不是可迭代的
>>> def myGen():
    print("生成器被执行!")
    yield 1
    yield 2


>>> myG = myGen()
>>> next(myG)
生成器被执行!
1
>>> next(myG)
2
>>> next(myG)
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    next(myG)
StopIteration

 

正如我们所见,当函数甘休的时候,1个StopIteration很是就会抛出。由于Python的for循环会自动调用next()方法和处理StopIteration卓殊,所以for循环当然也是能够对生成器暴发效益的:

四,什么是生成器

>>> for i in myGen():
    print(i)


生成器被执行!
1
2

可以明白为一种数据类型,那种数据类型自动完结了迭代器协议(其余的数据类型要求调用自个儿置于的__iter__主意),所以生成器就是可迭代对象

像前边介绍的斐波那契的例证,也足以用生成器来完成:

五,生成器在python中的表现形式

>>> def fibs():
    a = 0
    b = 1
    while True:
        a,b = b,a + b
        yield a



>>> for each in fibs():
    if each > 100:
        break
    print(each)


1
1
2
3
5
8
13
21
34
55
89

 

事到近日,你应当早就很好的控制了列表推到式子(并没有,哭唧唧),那上边那些列表推导式表达的是啥意思:

1.生成器函数:常规函数定义,然而,使用yield语句而不是return语句重临结果。yield语句一回回到一个结出,在各种结果中间,挂起函数的情事,以便下次重它离开的地点继续执行

>>> a = [i for i in range(100) if not(i%2) and i%3]

 

实则下边那些列表推导式求得就是100以内,能被2整除但不可以被3整除的具有整数:

2.生成器表明式:就如于列表推导,但是,生成器重回按需爆发结果的一个目的,而不是五次打造五个结实列表

>>> a
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]

 

python3除了有列表推导式,还有字典推导式:

六,生成器的独到之处

>>> b = {i:i%2 == 0 for i in range(10)}
>>> b
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

Python使用生成器对延期操作提供了接济。所谓延迟操作,是指在急需的时候才发生结果,而不是随即发生结果。那也是生成器的根本利益。

再有集合推导式:

七,生成器函数

>>> c = {i for i in [1,1,2,3,3,4,5,5,5,6,7,7,8]}
>>> c
{1, 2, 3, 4, 5, 6, 7, 8}

 

那是还是不是有字符串推导式和元组推导式呢?试一试:

澳门葡京备用网址 24澳门葡京备用网址 25

>>> d = "I love zww"
>>> d
'I love zww'
#计算移动平均值
def wrap(func):
    def inner(*args,**kwargs):
        ret = func()
        next(ret)
        return  ret
    return inner
@wrap
def averanger():
    total=0
    day=0
    avrage=0
    while True:
        day_nub=yield  avrage
        total+=day_nub
        day+=1
        avrage=total / day
avg=averanger()
print(avg.send(15))
print(avg.send(22))

哦,不行,因为在双引号内,全数的东西都成为了字符串,所以不存在字符串推导式,那元组推导式呢?

View Code

>>> e = (i for i in range(10))
>>> e
<generator object <genexpr> at 0x000002001EC4CB88>

八,生成器表明式

嘿?就像是这些不是什么样推导式嘛。generator,多么熟练的单词,就是生成器嘛!没错用普通小括号括起来的正是生成器推导式,来证实一下:

 

>>> next(e)
0
>>> next(e)
1
>>> next(e)
2
>>> next(e)
3
>>> next(e)
4
#列表解析
sum([i for i in range(100000000)])#内存占用大,机器容易卡死

#生成器表达式
sum(i for i in range(100000000))#几乎不占内存

用for语句把剩余的给打印出来:

 

>>> for each in e:
    print(each)


5
6
7
8
9

九,生成器总计

还有一个特点更牛,生成器推导式尽管作为函数的参数,可以直接写推导式,而不用加小括号:

1.是可迭代对象

>>> sum(i for i in range(100) if i % 2)
2500

 

【增加阅读】增加你的 Python:解释 yield 和
Generators(生成器)

2.落实了延期测算,省外存,

 

 

*******************************

3.生成器本质和其余的数据类型一样,都以兑现了迭代器协议,只不过生成器附加了一个延迟计算外省存的好处,其余的可迭代对象可没有那一点好处,

二 、课时49课后习题及答案

 

*******************************

  • 语法上和函数类似:生成器函数和常规函数大概是同一的。它们都以运用def语句进行定义,差异在于,生成器使用yield语句重回两个值,而常规函数使用return语句再次回到一个值
  • 机动完结迭代器协议:对于生成器,Python会自动完毕迭代器协议,以便利用到迭代背景中(如for循环,sum函数)。由于生成器自动完成了迭代器协议,所以,大家得以调用它的next方法,并且,在未曾值可以回来的时候,生成器自动发出StopIteration至极
  • 气象挂起:生成器使用yield语句重返五个值。yield语句挂起该生成器函数的状态,保留丰盛的音讯,以便之后从它离开的地方继续执行

澳门葡京备用网址 26

 

澳门葡京备用网址 27

澳门葡京备用网址 28

澳门葡京备用网址 29

澳门葡京备用网址 30

澳门葡京备用网址 31

澳门葡京备用网址 32

 澳门葡京备用网址 33

 预言后文如何?请君耐心等待.

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website