Python高级-函数式编程
第一章 函数式编程
1、生成器
通过列表⽣成式,我们可以直接创建⼀个列表。但是,受到内存限制,列表容量肯定是有限的。⽽且,创建⼀个包含100万个元素的列表,不仅占⽤很⼤的存储空间,如果我们仅仅需要访问前⾯⼏个元素,那后⾯绝⼤多数元素占⽤的空间都⽩⽩浪费了。所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从⽽节省⼤量的空间。在Python中,这种⼀边循环⼀边计算的机制,称为⽣成器:generator。创建生成器,列表生成式,我们知道,只要将最外一层的中括号,改为小括号
列表生成器:对象,保存了产生元素的算法,同时会记录游标的位置
y = [x + 1 for x in range(10) if x % 2 == 0]
#创建一个生成器:第一种生成器创建方式:通过列表生成式来创建
g = (x + 1 for x in range(10) if x % 2 == 0)
print(g) #<generator object <genexpr> at 0x00000267A278C110>
创建 y 和 g 的区别仅在于最外层的 [ ] 和 ( ) , y 是⼀个列表,⽽ g 是⼀个⽣成器。我们可以直接打印出L的每⼀个元素,但我们怎么打印出g的每⼀个元素呢?如果要⼀个⼀个打印出来,可以通过 next() 函数获得⽣成器的下⼀个返回值:
#遍历生成器中元素的4种方式
#1.通过next(g)来遍历生成器元素内容
next(g) #1
next(g) #3
next(g) #5
next(g) #7
next(g) #9
next(g) #没有数据了
#next调用次数过多会抛异常(越界)
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
next(g)
StopIteration
#2.通过循环打印出来,建议使用for循环获取生成器里的元素
h = (x + 1 for x in range(10) if x % 2 == 0)
for i in h:
print(i)
1
3
5
7
9
#3.通过object内置的__next__方法,实际的next也是基于 __next__ 方法调用
print(h.__next__());
'''4.send(arg),但是生成器的第一个值(第一次调用)必须使用send(None),后面的就没有限制
send发送过来的值,f.next()等价f.send(None),不好用,输出结果不是预期的''''
print(h.send(None))
print(h.send(''))
成器保存的是算法,每次调⽤ next(g) ,就计算出 g 的下⼀个元素的值,直到计算到最后⼀个元素,没有更多的元素时,抛出 StopIteration 的异常。当然,这种不断调⽤ next() 实在是太繁琐了,虽然是点一次出现一次,但正确的⽅法是使⽤ for 循环,因为⽣成器也是可迭代对象。所以,我们创建了⼀个⽣成器后,基本上永远不会调⽤next() ,⽽是通过 for 循环来迭代它,并且不需要关心StopIteration 异常。
所以,我们创建了一个生成器后,基本上不会调用 next() ,而是通过 for 循环来迭代它,并且不需要关心StopIteration 的错误。generator非常强大。如果推算的算法比较复杂,用类似列表生成式的 for 循环无法实现的时候,还可以用函数来实现。比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, …
斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易:
# 定义一个斐波那契函数
def fib_a(times):
# 初始化
n = 0
a, b = 0, 1
while n < times:
print(b)
a, b = b, a + b
n += 1
return 'done'
z = fib_a(5)
print(z)
# 打印结果如下
1
1
2
3
5
done
仔细观察,可以看出,fib_a函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。也就是说,上面的函数和generator仅一步之遥。要把 fib 函数变成generator,只需要把 print(b) 改为 yield(b) 就可以了:
yield一般用于创建生成器,作用就是返回后面变量的值给生成器
#2.第二种创建生成器的方法:yield
def fib_a(times):
# 初始化
n = 0
a, b = 0, 1
while n < times:
yield(b) #或yield b,v=yeild(b) 返回None,因为yield没有返回值
a, b = b, a + b
n += 1
return 'done'
#那此时调用方法和之前一样,可以使用next试试
f = fib_a(5) #f是生成器,保存了生成器的算法
print(next(f))
在上⾯fib 的例⼦,我们在循环过程中不断调⽤ yield ,就会不断中断。当然要给循环设置⼀个条件来退出循环,不然就会产⽣⼀个⽆限数列出来。同样的,把函数改成generator后,我们基本上从来不会⽤ next() 来获取下⼀个返回值,⽽是直接使⽤ for 循环来迭代:
def fib_a(times):
# 初始化
n = 0
a, b = 0, 1
while n < times:
yield(b)
a, b = b, a + b
n += 1
return 'done'
for i in fib_a(5):
print(i)
但是⽤for循环调⽤generator时,发现拿不到generator的return语句的返回值。如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的value中:
def fib_d(times):
# 初始化
n = 0
a, b = 0, 1
while n < times:
yield (b)
a, b = b, a + b
n += 1
return 'done'
f = fib_d(5)
#我们通过有限的值捕获异常,拿到return的值
while True:
try:
x = next(f)
print("value:%d" % x)
except StopIteration as e:
print("⽣成器返回值:%s" % e.value)
break
⽣成器是这样⼀个函数,它记住上⼀次返回时在函数体中的位置。对⽣成器函数的第⼆次(或第 n 次)调⽤跳转⾄该函数中间,⽽上次调⽤的所有局部变量都保持不变。⽣成器不仅“记住”了它数据状态;⽣成器还“记住”了它在流控制构造(在命令式编程中,这种构造不只是数据值)中的位置。⽣成器的特点:
- 节约内存
- 迭代到下⼀次的调⽤时,所使⽤的参数都是第⼀次所保留下的,在整个所有函数调⽤的参数都是第⼀次所调⽤时保留的,⽽不是新创建的
2、迭代器
迭代是访问集合元素的⼀种⽅式。迭代器是⼀个可以记住遍历的位置的对象。迭代器对象从集合的第⼀个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。
我们已经知道,可以直接作用于 for 循环的数据类型有以下几种:
一类是集合数据类型,如 list 、 tuple 、 dict 、 set 、 str 等;
一类是 generator ,包括生成器和带 yield 的generator function。
这些可以直接作用于 for 循环的对象统称为可迭代对象: Iterable 。
那我们怎么判断一组数据或是一组数据对象是不是 Iterable 对象呢?
可以使⽤ isinstance() 判断⼀个对象是否是 Iterable 对象
from collections.abc import Iterable
print(isinstance([], Iterable)) #True
print(isinstance({
}, Iterable)) #True
print(isinstance('1', Iterable)) #True
print(isinstance((x for x in range(10) if x % 2 == 0), Iterable)) #True
print(isinstance(10, Iterable)) #False
⽣成器不但可以作⽤于 for 循环,还可以被 next() 函数不断调⽤并返回下⼀个值,直到最后抛出 StopIteration 错误表示⽆法继续返回下⼀个值了。
可以被next()函数调⽤并不断返回下⼀个值的对象称为迭代器:Iterator。可以使⽤isinstance() 判断⼀个对象是否是Iterator 对象,这里就产生一个疑问了,生成器都是 Iterator 对象, list 、 dict 、 str 是不是Iterator ?为什么?。
list 、 dict 、 str 不是 Iterator ,因为Python的 Iterator 对象表示的是一个数