[转载] python迭代器、生成器和装饰器

参考链接：有效地在Python中使用迭代

文章目录

生成器生成器表达式(generator expression)通过使用yield关键字定义生成器并行前戏高潮

迭代器迭代器概述iter()函数创建迭代器创建一个迭代器(类)内置迭代器工具count无限迭代器cycle 无限迭代器，从一个有限序列中生成无限序列：itertools的子模块 islice 控制无限迭代器输出的方式

装饰器高阶函数嵌套函数高阶函数+嵌套函数 = 装饰器类装饰器带参数的decorator实例---登录认证

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

生成器表达式(generator expression)

L = [x + 1 for x in range(10)]

print(L)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

列表生成式复习

实现列表元素加1，列表生成式与其它方法比较：

#普通方法1

b = []

for i in range(10):

b.append(i+1)

print(b)

#普通方法2

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for index,i in enumerate(a):

a[index] +=1

print(a)

#map,lambda

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a = map(lambda x:x+1, a)

print(list(a))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

g = (x + 1 for x in range(10))

print(g)

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数（or __next__()）获得generator的下一个返回值：

next(g)

g.__next__()

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误

上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

g = (x * x for x in range(10))

for n in g:

print(n,end=";")

0;1;4;9;16;25;36;49;64;81;

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误

通过使用yield关键字定义

生成器对象是通过使用yield关键字定义的函数对象，因此，生成器也是一个函数。生成器用于生成一个值得序列，以便在迭代器中使用。

"""

第一是直接作为脚本执行，

第二是import到其他的python脚本中被调用（模块重用）执行。

因此if __name__ == '__main__': 的作用就是控制这两种情况执行代码的过程，

在if __name__ == '__main__':下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而import到其他脚本中是不会被执行的。

"""

def myYield(n):

while n>0:

print('开始生成。。。')

yield n

print('完成一次。。。')

n -= 1

if __name__ == '__main__':

a = myYield(3)

print('已经实例化生成器对象')

# a.__next__()

# print('第二次调用__next__()方法：')

# a.__next__()

已经实例化生成器对象

yield 语句是生成器中的关键语句，生成器在实例化时并不会被执行，而是等待调用其__next__()方法才开始运行。并且当程序运行完yield语句后就会“吼（hold）住”，即保持当前状态且停止运行，等待下一次遍历时才恢复运行。

程序运行的结果中的空行后的输出“已经实例化生成器对象”之前，已经实例化了生成器对象，但生成器并没有运行（没有输出‘开始生成’）。当第一次手工调用__next__()方法之后，才输出‘开始生成’，标志着生成器已经运行，而在输出‘’第二次调用__next__()方法‘’之前并没有输出‘完成一次’，说明yield语句运行之后就立即停止了。而第二次调用__next__()方法之后，才输出‘完成一次’，说明生成器的回复运行是从yield语句之后开始运行的

return_value = a.__next__()

print(return_value)

开始生成。。。

print('第二次调用__next__()方法：')

第二次调用__next__()方法：

return_value = a.__next__()

print(return_value)

完成一次。。。

开始生成。。。

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

def fib(max):

n, a, b = 0, 0, 1

while n < max:

print(b)

a, b = b, a + b

n = n + 1

return 'done'

注意，赋值语句：

a, b = b, a + b

相当于：

t = (b, a + b) # t是一个tuple

a = t[0]

b = t[1]

上面的函数可以输出斐波那契数列的前N个数：

fib(5)

'done'

上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

def fib(max):

n,a,b = 0,0,1

while n < max:

#print(b)

yield b

a,b = b,a+b

n += 1

return 'well done'

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

f = fib(5)

print(f)

print(list(f))

#重新实例化生成器对象

f = fib(5)

[1, 1, 2, 3, 5]

print(f.__next__())

print("干点别的事")

print(f.__next__())

干点别的事

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

StopIteration Traceback (most recent call last)

<ipython-input-18-9609f54647c6> in <module>

5 print(f.__next__())

6 print(f.__next__())

----> 7 print(f.__next__())

StopIteration: well done

用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

g = fib(6)

while True:

try:

x = next(g)

print('g:', x)

except StopIteration as e:

print('Generator return value:', e.value)

break

g: 1

g: 2

g: 3

g: 5

g: 8

Generator return value: well done

from itertools import islice

def fib():

a,b = 0,1

while True:

yield b

a,b = b,a+b

f = fib()

print(list(islice(f ,0,10)))

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

生成器在Python中是一个非常强大的编程结构，可以用更少地中间变量写流式代码，此外，相比其它容器对象它更能节省内存和CPU，当然它可以用更少的代码来实现相似的功能。现在就可以动手重构你的代码了，但凡看到类似

def something():

result= []

for ... in ...：

result.append(x)

return result

都可以用生成器函数来替换：

def iter_something():

result = []

for ... in ...：

yield x

杨辉三角

期待输出:

[1]

[1, 1]

[1, 2, 1]

[1, 3, 3, 1]

[1, 4, 6, 4, 1]

[1, 5, 10, 10, 5, 1]

[1, 6, 15, 20, 15, 6, 1]

[1, 7, 21, 35, 35, 21, 7, 1]

[1, 8, 28, 56, 70, 56, 28, 8, 1]

[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

def triangles():

result = [1]

while True:

yield result

result = [1] + [result[i] + result[i+1] for i in range(len(result)-1)] + [1]

n = 0

results = []

for t in triangles():

print(t)

results.append(t)

n = n + 1

if n == 10:

break

if results == [

[1],

[1, 1],

[1, 2, 1],

[1, 3, 3, 1],

[1, 4, 6, 4, 1],

[1, 5, 10, 10, 5, 1],

[1, 6, 15, 20, 15, 6, 1],

[1, 7, 21, 35, 35, 21, 7, 1],

[1, 8, 28, 56, 70, 56, 28, 8, 1],

[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

print('测试通过!')

else:

print('测试失败!')

[1]

[1, 1]

[1, 2, 1]

[1, 3, 3, 1]

[1, 4, 6, 4, 1]

[1, 5, 10, 10, 5, 1]

[1, 6, 15, 20, 15, 6, 1]

[1, 7, 21, 35, 35, 21, 7, 1]

[1, 8, 28, 56, 70, 56, 28, 8, 1]

[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

测试通过!

生成器并行

前戏

def gen():

a = yield 1

print('yield a % s' % a)

b = yield 2

print('yield b % s' % b)

c = yield 3

print('yield c % s' % c)

return "happy ending"

r = gen()

x = next(r)

print('next x %s' % x)

y = r.send(10)

print('next y %s' %y)

z = next(r)

print('next z %s' % z)

try:

a = next(r)

except StopIteration as e:

print(e)

next x 1

yield a 10

next y 2

yield b None

next z 3

yield c None

happy ending

运行过程说明：

第一步：r = gen()，实例化一个生成器对象第二步：调用next() ，遇到yield 暂停，返回值1，赋值给x第三步：打印x的值第四步：传值10，在暂停处接受值10，赋值给a，继续运行，打印a的值，遇到第二个yield，暂停，返回值2，赋值给y第五步：打印y的值第六步：调用next() ，打印b值，遇到第三个yield暂停，返回值3，赋值给z第七步：打印z值第八步：调用next()，打印c的值，报StopIteration错误，用try。。。except捕获错误

高潮

import time

import random

food = ["韭菜鸡蛋","猪肉白菜","猪肉荠菜","羊肉白菜","猪肉大葱","虾仁海鲜"]

def consumer(name):

print("%s 准备吃包子啦!" %name)

while True:

baozi = yield 'n'

print("[%s]馅包子来了,被[%s]吃了!" %(baozi,name))

def producer(name):

c1 = consumer('大儿子')

c2 = consumer('小儿子')

c1.__next__()

c2.__next__()

print("%s开始准备做包子啦" % name)

for i in range(6):

print("第%d次做了%s个包子"%(i+1,len(food)))

time.sleep(random.randint(1,3))

f1 = food[i]

c1.send(f1)

food.append(f1)

random.shuffle(food)

c2.send(food[i])

producer('老子')

大儿子准备吃包子啦!

小儿子准备吃包子啦!

老子开始准备做包子啦

第1次做了6个包子

[韭菜鸡蛋]馅包子来了,被[大儿子]吃了!

[韭菜鸡蛋]馅包子来了,被[小儿子]吃了!

第2次做了7个包子

[韭菜鸡蛋]馅包子来了,被[大儿子]吃了!

[猪肉大葱]馅包子来了,被[小儿子]吃了!

第3次做了8个包子

[韭菜鸡蛋]馅包子来了,被[大儿子]吃了!

[猪肉大葱]馅包子来了,被[小儿子]吃了!

第4次做了9个包子

[猪肉白菜]馅包子来了,被[大儿子]吃了!

[羊肉白菜]馅包子来了,被[小儿子]吃了!

第5次做了10个包子

[虾仁海鲜]馅包子来了,被[大儿子]吃了!

[韭菜鸡蛋]馅包子来了,被[小儿子]吃了!

第6次做了11个包子

[韭菜鸡蛋]馅包子来了,被[大儿子]吃了!

[虾仁海鲜]馅包子来了,被[小儿子]吃了!

迭代器

迭代器概述

可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型,如list,tuple,dict,set,str等一类是generator ，包括生成器和带yeild的generator function

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

a = [i for i in range(10)]

next(a)

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

TypeError Traceback (most recent call last)

<ipython-input-23-8981550fe3e0> in <module>

1 a = [i for i in range(10)]

----> 2 next(a)

TypeError: 'list' object is not an iterator

list，dict，str虽然是Iterable，却不是Iterator

from collections import Iterator

from collections import Iterable

print(isinstance(a,Iterator))

print(isinstance(a,Iterable))

print(isinstance({},Iterable))

print(isinstance('abc',Iterable))

False

True

生成器就是一个迭代器

a = (i for i in range(10))

print(next(a))

print(isinstance(a,Iterator))

True

iter()函数创建迭代器

iter（iterable）#一个参数，要求参数为可迭代的类型

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

print(isinstance({},Iterator))

print(isinstance('abc',Iterator))

print(isinstance(iter({}),Iterator))

print(isinstance(iter('abc'),Iterator))

False

True

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

小结

凡是可作用于for循环的对象都是Iterable类型；凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:

print(x,end=',')

1,2,3,4,5,

实际上完全等价于：

# 首先获得Iterator对象:

it = iter([1, 2, 3, 4, 5])

# 循环:

while True:

try:

# 获得下一个值:

x = next(it)

print(x,end=',')

except StopIteration:

# 遇到StopIteration就退出循环

break

1,2,3,4,5,

创建一个迭代器(类)

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行

__iter__() 方法返回一个特殊的迭代器对象，这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

from itertools import islice

class Fib:

def __init__(self):

self.prev = 0

self.curr = 1

def __iter__(self):

return self

def __next__(self):

self.prev,self.curr = self.curr,self.prev+self.curr

return self.curr

f = Fib()

print(list(islice(f ,0,10)))

[1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Fib既是一个可迭代对象（因为它实现了 __iter__方法），又是一个迭代器（因为实现了 __next__方法)

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:

def __init__(self):

self.a = 1

def __iter__(self):

return self

def __next__(self):

if self.a <= 20:

x = self.a

self.a += 1

return x

else:

raise StopIteration

myclass = MyNumbers()

myiter = MyNumbers()

# myiter = iter(myclass)

for x in myiter:

print(x,end=",")

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,

内置迭代器工具

比如 itertools 函数返回的都是迭代器对象

count无限迭代器

from itertools import count

counter = count(start=10)

print(next(counter))

print(next(counter)) #python内建函数next()对itertools创建的迭代器进行循环

cycle 无限迭代器，从一个有限序列中生成无限序列：

from itertools import cycle

colors = cycle(['red','black','blue'])

print(next(colors))

red

black

blue

red

black

itertools的子模块 islice 控制无限迭代器输出的方式

islice的第二个参数控制何时停止迭代，迭代了11次后停止，从无限的序列中生成有限序列：

from itertools import count

counter = count(start=10)

i=4

print(next(counter))

while i > 0:

print(next(counter))

i -= 1

from itertools import count

for i in count(10):

if i > 14 :

break

else:

print(i)

from itertools import islice

from itertools import count

for i in islice(count(10),5):

print(i)

from itertools import cycle

from itertools import islice

colors = cycle(['red','black','blue'])

limited = islice(colors,0,4)

for x in limited:

print(x)

red

black

blue

red

装饰器

器，代表函数的意思

装饰器：本质是函数（装饰其他函数）就是为其他函数添加附加功能

每个人都有的内裤主要功能是用来遮羞，但是到了冬天它没法为我们防风御寒，咋办？我们想到的一个办法就是把内裤改造一下，让它变得更厚更长，这样一来，它不仅有遮羞功能，还能提供保暖，不过有个问题，这个内裤被我们改造成了长裤后，虽然还有遮羞功能，但本质上它不再是一条真正的内裤了。于是聪明的人们发明长裤，在不影响内裤的前提下，直接把长裤套在了内裤外面，这样内裤还是内裤，有了长裤后宝宝再也不冷了。装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。

原则：

1 不能修改被装饰的函数的源代码2 不能修改被装饰的函数的调用方式

实现装饰器知识储备：

1 函数即“”变量“” 2 高阶函数 a 把一个函数名当做实参传给另一个函数 b 返回值中包含函数名

高阶函数

import time

def bar():

time.sleep(3)

print('in the bar')

def test2(func):

print(func)

return func

print(test2(bar)) #调用test2，打印bar的内存地址，返回bar的内存地址，又打印

bar=test2(bar) # 返回的bar的内存地址，赋值给bar

bar() #run bar

in the bar

嵌套函数

x = 0

def grandpa():

x = 1

print(x)

def dad():

x =2

print(x)

def son():

x =3

print(x)

son()

dad()

grandpa()

高阶函数+嵌套函数 = 装饰器

import time

def timer(func): #timer(test1) func=test1

def deco(*args,**kwargs): #非固定参数

start_time=time.time()

func(*args,**kwargs) #run test1()

stop_time = time.time()

print("the func run time is %s" %(stop_time-start_time))

return deco

@timer #test1=timer(test1) 把deco的内存地址返回给test1

def test1():

time.sleep(1)

print('in the test1')

@timer # test2 = timer(test2) = deco test2(name) =deco(name)

def test2(name,age):

print("test2:",name,age)

test1() #实际上是在执行deco

test2("alex",22)

in the test1

the func run time is 1.001246452331543

test2: alex 22

the func run time is 0.00011372566223144531

类装饰器

没错，装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法

class Foo(object):

def __init__(self, func):

self._func = func

def __call__(self):

print ('class decorator runing')

self._func()

print ('class decorator ending')

@Foo

def bar():

print ('bar')

bar()

class decorator runing

bar

class decorator ending

装饰器可以把与业务逻辑无关的代码抽离出来，让代码保持干净清爽，而且装饰器还能被多个地方重复利用。比如一个爬虫网页的函数，如果该 URL 曾经被爬过就直接从缓存中获取，否则爬下来之后加入到缓存，防止后续重复爬取。

def web_lookup(url, saved={}):

if url in saved:

return saved[url]

page = urllib.urlopen(url).read()

saved[url] = page

return page

pythonic

import urllib.request as urllib # py3

def cache(func):

saved= {}

def wrapper(url):

if url in saved:

return saved [url]

else:

page = func(url)

saved [url] = page

return page

return wrapper

@cache

def web_lookup(url):

return urllib.urlopen(url).read()

用装饰器写代码表面上感觉代码量更多，但是它把缓存相关的逻辑抽离出来了，可以给更多的函数调用，这样总的代码量就会少很多，而且业务方法看起来简洁了。

带参数的decorator

def log(text):

def decorator(func):

def wrapper(*args, **kw):

print('%s %s():' % (text, func.__name__))

return func(*args, **kw)

return wrapper

return decorator

还差最后一步。因为我们讲了函数也是对象，它有__name__等属性，但你去看经过decorator装饰之后的函数，它们的__name__已经从原来的’now’变成了’wrapper’：

@log('execute')

def now():

print('2015-3-25')

now()

now.__name__

execute now():

2015-3-25

'wrapper'

因为返回的那个wrapper()函数名字就是’wrapper’，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：

import functools

def log(text):

def decorator(func):

@functools.wraps(func)

def wrapper(*args, **kw):

print('%s %s():' % (text, func.__name__))

return func(*args, **kw)

return wrapper

return decorator

@log('execute')

def now():

print('2015-3-25')

now()

now.__name__

execute now():

2015-3-25

'now'

那么不带参数decorator，也是一样的

import functools

def log(func):

@functools.wraps(func)

def wrapper(*args, **kw):

print('call %s():' % func.__name__)

return func(*args, **kw)

return wrapper

实例—登录认证

import functools

user,passwd = 'sun' ,'123'

def auth(auth_type):

print("auth func:",auth_type)

def decorator(func):

@functools.wraps(func)

def wrapper(*args,**kwargs):

print('wrapper func args:',*args,**kwargs)

if auth_type == 'local':

username = input('Username:').strip()

password = input("Password:").strip()

if user == username and passwd == password:

print("\033[32;1mUser has passed authentication\033[0m")

res = func(*args, **kwargs)

print("--after authentication--")

return res

else:

exit("\033[31;1mInvalid username or password\033[0m")

elif auth_type == 'ldap':

res = func(*args, **kwargs)

print("搞毛线ldap,不会。。。。")

return res

return wrapper

return decorator

def index():

print("welcome to index page")

@auth(auth_type='local')

def home():

print("welcome to home page")

return 'from home'

@auth(auth_type='ldap')

def bbs():

print("welcome to bbs page")

index()

print(home()) #wrapper

bbs()

auth func: local

auth func: ldap

welcome to index page

wrapper func args:

Username:sun

Password:123

[32;1mUser has passed authentication[0m

welcome to home page

--after authentication--

from home

wrapper func args:

welcome to bbs page

搞毛线ldap,不会。。。。

[转载] python迭代器、生成器和装饰器相关推荐

[转载] Python学习笔记——用装饰器decorator和Memoization记忆化提高效率，原理讲清楚了
参考链接: 在Python中使用装饰器进行记忆 Python学习笔记--用装饰器decorator和Memoization记忆化提高效率装饰器Memoization记忆化运用`functools`中 ...
python全栈开发—什么是迭代器生成器、装饰器、数据序列化，建议收藏
迭代器&生成器装饰器软件目录结构规范作业:ATM项目开发 1.列表生成式,迭代器&生成器列表生成式孩子,我现在有个需求,看列表[0, 1, 2, 3, 4, 5, 6, 7, ...
Day4 - 迭代器生成器、装饰器、Json pickle 数据序列化、软件目录结构规范
---恢复内容开始--- 本节内容迭代器&生成器装饰器 Json & pickle 数据序列化软件目录结构规范作业:ATM项目开发 1.列表生成式,迭代器&生成器列表 ...
[转载] python学习笔记——@property装饰器
参考链接: Python @property装饰器上篇:https://blog.csdn.net/qq_42489308/article/details/89423412 @property装饰器 ...
Python 三大利器：迭代器、生成器、装饰器
Python 中的三大利器包括: 迭代器.生成器.装饰器,利用好它们才能开发出最高性能的代码,涉及到的内置模块 itertools 提供迭代器相关的操作. 迭代器迭代是Python最强大的功能之一, ...
python迭代器、生成器及装饰器
迭代器迭代是Python最强大的功能之一,是访问集合元素的一种方式:迭代器是一个可以记住遍历的位置的对象:迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束.迭代器只能 ...
python之路6-迭代器、生成器、装饰器
1.迭代器&生成器列表生成式现在有个需求,列表[1,2,3,4,5,6,7,,8,9],要求把列表里的每个值加1,如何实现? 方法一: list = [1,2,3,4,5,6,7,8,9] ...
Python基础（八）--迭代，生成器，装饰器与元类
目录 Python基础(八)--迭代,生成器,装饰器与元类 1 迭代 1.1 可迭代对象与迭代器 1.2 自定义迭代类型 1.3 迭代合体 2 生成器 2.1 什么是生成器 2.2 生成器表达式 2. ...
python 生成器装饰器_对Python生成器、装饰器、递归的使用详解
1.Python生成器表达式 1).Python生成器表达式语法格式: (expr for iter_var in iterable) (expr for iter_var in iterable ...
递归函数、生成器、装饰器
递归函数.生成器.装饰器递归: 在函数执行中调用自身必须有边界条件,递归前进段和递归返回段 python中递归有层次限制递归函数实现阶乘 def fact(n): if n <= 1:r ...

[转载] python迭代器、生成器和装饰器

[转载] python迭代器、生成器和装饰器相关推荐

最新文章

热门文章