Python 基础学习笔记之：切片、迭代、列表生成式、生成器、迭代器

Python中，对序列的操作可以说是最最常见的操作了，熟悉相应序列（可迭代对象）的操作，能大大加快编码的效率。

切片

对一个 list 、tuple 或者字符串取部分元素是很常见的操作，使用切片的操作就是 obj[m:n:step]，其中 m 和 n 都可以不输入，关键的是那个冒号，如果没有冒号，就不是切片了，而是取单个元素，最后一个 step 表示步长。

使用切片返回的还是一个序列。查看例子：

>>> L = list(range(100))
>>> L[0:1]           
[1]
>>> L[:1]
[1]
>>> L[-2:]           # 取后两个，从后先前取，用负数，-1是最后一个元素
[99]
>>> L[-2:-1]
[98]
>>> L[:10]
>>> L[-10:]
>>> L[:10:2]        # 前10个数，每两个取一个
>>> L[::5]          # 所有数，每5个取一个
>>> L[:]            # 什么都不写，只写[:]就可以原样复制一个list：

迭代

Python 的 for 循环抽象程度要高于 Java 的 for 循环，因为 Python 的 for 循环不仅可以用在 list 或 tuple 上，还可以作用在其他可迭代对象上。比如 dict:

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
a
c
b

默认情况下，dict 迭代的是 key。如果要迭代 value，可以用 for value in d.values()，如果要同时迭代 key 和 value，可以用 for k, v in d.items()。
由于字符串也是可迭代对象，因此，也可以作用于for循环：

>>> for ch in 'ABC':
...     print(ch)
...
A
B
C

所以，当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。那么，如何判断一个对象是可迭代对象呢？方法是通过 collections 模块的 Iterable 类型判断：

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

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

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

上面的for循环里，同时引用了两个变量，在Python里是很常见的，比如下面的代码：

>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print(x, y)
...
1 1
2 4
3 9

列表生成式

列表生成式即 List Comprehensions，是 Python 内置的非常简单却强大的可以用来创建 list 的生成式。比如要生成 [1x1, 2x2, 3x3, ..., 10x10] 这样的列表，我们可以这么搞：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

要生成的元素放前面，后面跟一个 for 语句。for 循环后面还可以加上 if 判断：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还可以使用两层循环：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

常见应用场景
列出当前目录下的所有文件和目录名：

>>> import os # 导入os模块，模块的概念后面讲到
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public']

for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

最后把一个list中所有的字符串变成小写：

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

生成器

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

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

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

>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

list 中的元素可以直接打印出来，生成器的元素不能一下子全部打印，但是可以通过 next() 方法来一个一个的取出来。

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
...
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

我们讲过，generator 保存的是算法，每次调用 next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出 StopIteration 的错误。
generator 是一个可迭代对象，因此可以使用 for 循环来迭代：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)

for 循环可以处理 StopIteratioin 错误，只有很少的情况下我们才用 next() 方式来对生成器取值。

第二种方式：
当生成 generator 的推算算法很复杂时，我们就需要使用这个方式，比如我们定义一个每次返回一个斐波纳切数的生成器：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

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

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

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

上面 fib 的例子，我们在循环过程中不断调用 yield，会一直进行下去，会产生一个无限数列出来，使用 for 来迭代生成器，因为 for 不处理 StopIteration 错误，就会永远拿不到 return 返回的值，这时我需要用 while 来处理：

while True:
     try:
         x = next(g)
         print('g:', x)
     except StopIteration as e:
         print('Generator return value:', e.value)
         break

显示捕获异常就可以拿到 return 返回的值。

迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

• 集合数据类型，如list、tuple、dict、set、str等；
• generator，包括生成器和带 yield 的 generator function。

这些可以直接作用于 for 循环的对象统称为可迭代对象：Iterable。上面已经提到过可以使用 isinstance() 判断一个对象是否是 Iterable 对象。

上面的生成器除来可以被迭代以外，还可以用 next() 来取下一个值。可以被 next() 函数调用并不断返回下一个值的对象称为迭代器：Iterator。我们也可以使用 isinstance() 判断一个对象是否是 Iterator 对象：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是 Iterator 对象，但 list、dict、str 虽然是 Iterable，却不是 Iterator。把 list、dict、str等变成 Iterator 可以使用 iter() 函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

Iterator 迭代器本身是一个惰性序列，只有用 for 或显示的用 next() 调用才能进行值输出。