Python高级（一） 函数式编程

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 次）调⽤跳转⾄该函数中间，⽽上次调⽤的所有局部变量都保持不变。⽣成器不仅“记住”了它数据状态；⽣成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置。⽣成器的特点：

1. 节约内存
2. 迭代到下⼀次的调⽤时，所使⽤的参数都是第⼀次所保留下的，在整个所有函数调⽤的参数都是第⼀次所调⽤时保留的，⽽不是新创建的

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 对象表示的是一个数