Python里使用来迭代。

    常用可迭代对象有list、tuple、dict、字符串等。示例：
    list：

    输出：

    1. 1
    2. 2
    3. 1 2
    4. 3 4

    上面的for循环里，同时引用了两个变量，在Python里是很常见的。

    tuple：

    1. for x in (1,2):
    2.     print(x)

    输出：

    1. 1
    2. 2

    dict：

    1. dict = {"name":"yjc", "age":18}
    2. for v in dict:
    3.     print(v, dict[v])
    5. for v in dict.values():
    6.     print(v)
    8. for k,v in dict.items():
    9.     print(k,v)

    输出：

    1. name yjc
    2. age 18
    4. yjc
    5. 18
    7. age 18
    8. name yjc

    dict默认迭代的key，可以使用dict.values()获取value；还可以使用dict.items()同时获取key和value。

    字符串也是可迭代对象：

    1. for ch in 'abcd':
    2.     print(ch)

    输出：

    1. a
    2. b
    3. c
    4. d

    如果要对list实现类似Java那样的下标循环可以使用内置的enumerate函数——可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

    1. for k,v in enumerate([1,2]):
    2.     print(k,v)

    输出：

    1. 0 1
    2. 1 2

    那么，如何判断一个对象是否可迭代呢？可以使用collections模块里的Iterable判断：

    1. from collections import Iterable
    3. print(isinstance([1,2], Iterable));

    输出：

    1. True

    任何可迭代对象都可以作用于for循环，包括我们自定义的数据类型，只要符合迭代条件，就可以使用for循环。

    示例：

    输出：

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

    以上代码相当于：

    1. list = []
    2. for x in range(1,10):
    3.     list.append(x*x) 
    4. print(list)

    看到这里大家应该理解Python列表生成式的含义了。运用列表生成式，可以写出非常简洁的代码。

    我们再看几个示例：
    1)输出偶数：

    1. list = [x for x in range(1,10) if x % 2 == 0 ]
    2. print(list)

    输出：

    1. [2, 4, 6, 8]

    2)笛卡尔积

    1. b = "XYZ"
    2. list = [m+n for m in a for n in b]
    3. print(list)

    输出：

    1. ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ']

    3)大写转小写

    1. list = [s.lower() for s in ['I', 'Love', 'Python', 100] if isinstance(s,str)]
    2. print(list)

    输出：

    1. ['i', 'love', 'python']

    这里使用isinstance()判断类型，因为非字符串类型没有方法，Python会报错，所以这里加了个判断：

    1. >>> isinstance('love', str)
    2. True
    3. >>> isinstance(100, str)
    4. False

    前面我们使用列表生成式可以很方便的生成一个我们需要的列表。但是如果生成一个很大的列表，会比较占内存，例如range(1,10000000)，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都浪费了。

    生成器(generator)不同于列表，它根据写好的算法，能够推算出下一个元素。生成器不属于list类型，属于generator类型。要创建一个生成器，第一种方法就是把列表生成式最外面的[]的改成()就行了：

    1. L = [x for x in range(1,10) if x % 2 == 0 ]
    2. print(type(L))
    3. print(L)
    5. g = (x for x in range(1,10) if x % 2 == 0 )
    6. print(type(g))
    7. print(g)

    输出：

    1. <class 'list'>
    2. [2, 4, 6, 8]
    4. <class 'generator'>
    5. <generator object <genexpr> at 0x01EAEE90>

    我们不能像list那样直接打印出generator。如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

    输出：

    1. 2
    2. 4
    3. 6
    4. 8
    5. Traceback (most recent call last):
    6.   File "/1.py", line 6, in <module>
    7.     print(next(g))

    我们可以使用for循环迭代generator：

    1. g = (x for x in range(1,10) if x % 2 == 0 )
    2. for x in g:
    3.     print(x)

    输出：

    1. 2
    2. 4
    3. 6
    4. 8

    for循环遇到StopIteration会停止迭代，不会扔出异常。

    下面，我们引入生成器的另外一种创建方法，使用yield关键字。函数里如果有yield关键字，那么它将不再是一个函数，而是一个生成器，遇到yield中断，下次又从上次中断的地方继续执行。示例：

    1. def test():
    2.     print('step 1:')
    3.     yield 11
    4.     print('step 2:')
    5.     yield 22
    6.     return 'ok'
    8. g = test()
    9. print(g)
    10. print(next(g))
    11. print(next(g))
    12. print(next(g))

    输出：

    1. <generator object test at 0x005BEC38>
    2. step 1:
    3. step 2:
    4. 22
    5. Traceback (most recent call last):
    6.   File "D:\Users\Desktop\1.py", line 12, in <module>
    7.     print(next(g))

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

    函数改成generator后，同样可以使用for循环迭代：

    1. for x in test():
    2.     print(x)

    下面是斐波拉契数列生成的函数，大家自行看有啥区别：

    1. def fib(n):
    2.     a,b,i=0,1,1
    3.     while i <= n:
    4.         a,b = b,a+b
    5.         i+=1
    6.         print(b)
    8. def gfib(n):
    9.     a,b,i=0,1,1
    10.     while i <= n:
    11.         a,b = b,a+b
    12.         i+=1
    13.         yield b
    15. fib(6)
    16. gfib(6)

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

    1. >>> g = fib(6)
    2. >>> while True:
    3. ...     try:
    4. ...         x = next(g)
    5. ...         print('g:', x)
    6. ...     except StopIteration as e:
    7. ...         print('Generator return value:', e.value)
    8. ...         break
    9. ...
    10. g: 1
    11. g: 1
    12. g: 2
    13. g: 3
    14. g: 5
    15. g: 8
    16. Generator return value: done

    可以直接作用于for循环的一类是list、tuple、dict、set、str，另一类是generator。这些对象统称为可迭代对象：Iterable。

    可以直接作用于next()的对象称为迭代器：Iterator。迭代器既可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

    使用isinstance()判断一个对象是否是Iterable对象或者Iterator对象：

    1. >>> from collections import Iterable
    2. >>> isinstance([], Iterable)
    3. True
    5. >>> from collections import Iterator
    6. >>> isinstance((x for x in range(10)), Iterator)
    7. True

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

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

    1. >>> isinstance(iter([]), Iterator)
    2. True
    3. >>> isinstance(iter('abc'), Iterator)
    4. True

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

    1.     pass

    实际上完全等价于：