Python基础+刷廖雪峰教程笔记（二）——迭代、生成器、高级函数、装饰器、偏函数

由于在深度学习的路上，发现自己两年前学习的python有些遗忘，在面向对象这一块尤其不熟悉，故刷一遍廖雪峰老师的官方教程，梳理一下遗漏的知识点。

参考网址：https://www.liaoxuefeng.com/wiki/1016959663602400

1.迭代

如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。

demo1:

#字典类型的迭代
d = {'a': 1, 'b': 2, 'c': 3}
#默认情况下，dict迭代的是key
for key in d:
    print(key)

print('-' *50)
#迭代value
for value in d.values():
    print(value)

print('-' *50)
#同时迭代key和value
for k, v in d.items():
    print(k, v)

out1:

a
b
c
--------------------------------------------------
1
2
3
--------------------------------------------------
a 1
b 2
c 3

判断对象是否可迭代：

通过collections.abc模块的Iterable类型判断

demo2:

from collections.abc import Iterable
res1 = isinstance('abc', Iterable) # str是否可迭代
print(res1)
res2 = isinstance([1,2,3], Iterable) # list是否可迭代
print(res2)
res3 = isinstance(123, Iterable) # 整数是否可迭代
print(res3)

out2:

True
True
False

2.enumerate函数

Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身。

demo3:

for i, value in enumerate(['A', 'B', 'C']):
     print(i, value)

out3:

0 A
1 B
2 C

3.列表生成式

在一个列表生成式中，for前面的if … else是表达式，而for后面的if是过滤条件，不能带else。

demo4:

L1 = [x for x in range(1, 11) if x % 2 == 0]
L2 = [x if x % 2 == 0 else -x for x in range(1, 11)]#for前面的部分是一个表达式，它必须根据x计算出一个结果
print(L1)
print(L2)

out4:

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

4.生成器

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

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

demo5：

L = [x * x for x in range(10)]
print(L)
g = (x * x for x in range(10))#将[]改成()
print(g)
print(next(g))#通过next()函数获得generator的下一个返回值,打印出来
print(next(g))
print(next(g))
print('-' * 50)
#使用for循环，因为generator也是可迭代对象
g = (x * x for x in range(10))
for n in g:
     print(n)

out5:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x000001FE92699308>
0
1
4
--------------------------------------------------
0
1
4
9
16
25
36
49
64
81

定义generator的另一种方法：如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generato。

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

demo6:

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

#调用该generator时，首先要生成一个generator对象
#然后用next()函数不断获得下一个返回值

o = odd()
print(next(o))
print(next(o))
print(next(o))
print(next(o))
    

out6:

step 1
1
step 2
3
step 3
5
Traceback (most recent call last):
  File "C:\Users\邓富元\Desktop\1.py", line 16, in <module>
    print(next(o))
StopIteration

odd不是普通函数，而是generator，在执行过程中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield可以执行了，所以，第4次调用next(o)就报错。

5.迭代器

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

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

demo7:

#可以使用isinstance()判断一个对象是否是Iterable对象
from collections.abc import Iterable
print(isinstance([], Iterable))
print(isinstance('abc', Iterable))
print(isinstance(100, Iterable))
print('-' * 50)

#可以使用isinstance()判断一个对象是否是Iterator对象
from collections.abc import Iterator
print(isinstance((x for x in range(10)), Iterator))
print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abc', Iterator))

out7:

True
True
False
--------------------------------------------------
True
False
False
False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

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

demo8:

from collections.abc import Iterator
print(isinstance(iter([]), Iterator))
print(isinstance(iter('abc'), Iterator))

out8:

True
True

总结：

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；（列表[]换成（）就变成生成器generator）

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

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

6.高阶函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

demo9:

def add(x, y, f):
    return f(x) + f(y)

print(add(-5, 6, abs))

out9:

11

7.map()和reduce()函数

map()函数。map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

reduce()函数。reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

demo10:

from functools import reduce
def f(x):
    return x * x

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))#结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list


def add(x, y):
    return x + y

res = reduce(add, [1, 3, 5, 7, 9])
print(res)

out10：

[1, 4, 9, 16, 25, 36, 49, 64, 81]
25

8.filter()函数

Python内建的filter()函数用于过滤序列。

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

注意：filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

demo11:

#删掉偶数，只保留奇数
def is_odd(n):
    return n % 2 == 1

res = list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
print(res)

out11:

[1, 5, 9, 15]

9.函数作为返回值

不需要立刻求和，而是在后面的代码中，根据需要再计算，则可以不返回求和的结果，而是返回求和的函数。

demo12:

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

#调用lazy_sum()时，返回的并不是求和结果，而是求和函数
f = lazy_sum(1, 3, 5, 7, 9)
print(f)
#调用函数f时，才真正计算求和的结果
print(f())

out12:

<function lazy_sum.<locals>.sum at 0x0000023547416620>
25

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”.

demo13:

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print(f1(), f2(), f3())

out13:

9,9,9

不是1， 4， 9而是9， 9， 9的原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

10.匿名函数

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

demo14:

#把匿名函数赋值给变量
f1 = lambda x: x * x
print(f1)
print(f1(5))

#把匿名函数作为返回值返回
def build(x, y):
    return lambda: x * x + y * y

f2 = build(2, 3)
print(f2())

out14:

<function <lambda> at 0x0000020EF6499158>
25
13

11.装饰器

函数对象有一个__name__属性，可以拿到函数的名字。
demo15：

def now():
    print('2015-3-25')

print(now.__name__)#前后各两个下划线

out15:

now

增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

本质上，decorator就是一个返回函数的高阶函数。

demo16:

#定义一个能打印日志的decoretor
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

#因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数
#借助Python的@语法，把decorator置于函数的定义处

@log
def now():
    print('2015-3-25')

now()#调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志
#把@log放到now()函数的定义处，相当于执行了语句now = log(now)

out16:

call now():
2015-3-25

(装饰器部分不太懂，以后用到再具体看）

12.偏函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。要注意，这里的偏函数和数学意义上的偏函数不一样。

在介绍函数参数的时候，我们讲到，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2。

demo17:

print(int('12345',base=8))#按八进制转换,即12345为8进制的数
print(int('12345',16))#按十六进制转换
print(int('1010',base=2))#按二进制转换

#创建一个偏函数
import functools
int2 = functools.partial(int, base=2)
print(int2('1000000'))
#也可以在函数调用时传入其他值
print(int2('1000000',base=10))

#创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数
max2 = functools.partial(max, 10)#把10作为*args的一部分自动加到左边

out17:

5349
74565
10
64
1000000
10

简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。