Python之高级特性（切片，迭代，列表生成式，生成器）

切片

取list或者tuple中的部分元素采用切片操做。

在list中取前N个元素，也就是索引为0-(N-1)的元素，能够用循环：

>>> r = []
>>> n = 3
>>> for i in range(n):
...     r.append(L[i])
...
>>> r
['Michael', 'Sarah', 'Tracy']

取list中前3个元素，用一行代码就能够完成切片：

>>>L[0:3]

['Michael', 'Sarah', 'Tracy']

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3.既索引0，1，2这三个元素。若是第一个索引是0还能够省略0。即为L[:3]。

L[1:3]表示从1开始，取出2个元素。

此外，python支持L[-1]取倒数第一个元素，那么python一样支持倒数切片。倒数第一个元素是-1.

取后10个数：

>>>L[-10:]

取前11-20个数：

>>>L[10：20]

前10个数字，每2个取一个：

>>>L[:10:2]

[0,2,4,6,8]

全部数，每5个取一个：

>>>L[::5]

甚至什么都不写，只写[:]就能够原样复制一个list：

 

tuple也是一种list，惟一区别是tuple不可变。所以，tuple也能够用切片操做，只是操做的结果还是tuple：

>>>(0,1,2,3,4,5,6)[：3]

（0，1，2）

字符串'xxx'也能够当作是一种list，每一个元素就是一个字符。所以，字符串也能够用切片操做，只是操做结果还是字符串：

>>>'acdsgag'[:3]

'acd'

>>>'adfzxcqwe'[:2]

'dzcw'

迭代：

若是给定一个list或tuple，咱们能够经过for循环来遍历这个list或tuple，这种遍历咱们称 迭代（Iteration）。

在Python中，迭代是经过for...in来完成的，而不少语言好比c或者java，迭代list是 经过下标完成的，好比Java代码：

dict的迭代：

>>>d = {'a':1, 'b':2, 'c':3}

>>> for key in d:

　　　　print(key)

a

b

c

如何判断一个对象是可迭代对象呢？方法是经过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循环中同时迭代索引和元素自己：enumeratefor

>>> for i, value in enumerate(['A', 'B', 'C']): ... print(i, value) ... 0 A 1 B 2 C
for循环里，同时引用了两个变量，在Python里是很常见的，好比下面的代码：for

>>> for x, y in [(1, 1), (2, 4), (3, 9)]: ... print(x, y) ... 1 1 2 4 3 9
生成器：
建立一个list[]和tuple()，list中的每个元素能够打印出来，而tuple是一个generator。能够经过next（）函数得到generator的下一个返回值：或者使用for循环。由于generator也是一个可迭代的对象。
g=(x*x for x in range(10))
　　for n in g:
　　　　print(n)
0
1
4
9
16
25
36
49
64
81
斐波拉契数列，用函数打印出来：
def fib(max):
　　n,a,b=0,0,1
　　while n<max:
　　　　print(b)
　　　　a,b=b,a+b #赋值语句 至关于 t=(b,a+b)其中t是一个tuple a=t[0] b=t[1]
　　　　n=n+1
　　return 'done'

>>> fib(6)
1
1
2
3
5
8
'done'
上面的函数和generator仅一步之遥。要把fib函数转换成generator，只须要把print(b)改成yield b 就能够了：
def fib(max):
　　n,a,b = 0,0,1
　　while n<max:
　　　　yield b
　　　　a, b=b, a+b
　　　　n = n+1
　　return 'done'
这就是定义generator的另一种方法。若是一个函数定义中包含yield关键字，那么这个函数再也不是一个普通函数，而是一个generator：
>>> f = fib(6)
>>> f
generator和函数的执行顺序不同。generator是在每次调用next()的时候执行。遇到yield语句返回，再次执行的时候从上次返回的yield语句处继续执行。
def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3) print('step 3')
    yield(5)
调用该generator时，首先要生成一个generator对象，而后用next()函数不断得到下一个返回值：
>>>o = odd()
>>>next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
能够看到，odd不是普通函数，而是generator，在执行过程当中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield能够执行了，因此，第4次调用next(o)就报错。
把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：
>>>for n in fib(6)
　　print(n)
1
1
2
3
5
8
可是用for循环调用generator时，发现拿不到generator的return语句的返回值。若是想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done
迭代器
直接做用于for循环的数据类型有如下几种：
一类是集合数据类型，如：List,tuple,dict,set, str等；
一类是generator;包括生成器和带yield的generator function。
这些能够直接做用于for循环的对象统称为可迭代对象：Itemable。
可使用isinstance()判断一个对象是不是Itemable对象：
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
可使用isinstance()判断一个对象是不是Iterator对象：生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可使用iter()函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
>>> fib(6)
1
1
2
3
5
8
'done'
上面的函数和generator仅一步之遥。要把fib函数转换成generator，只须要把print(b)改成yield b 就能够了：
def fib(max):
　　n,a,b = 0,0,1
　　while n<max:
　　　　yield b
　　　　a, b=b, a+b
　　　　n = n+1
　　return 'done'
这就是定义generator的另一种方法。若是一个函数定义中包含yield关键字，那么这个函数再也不是一个普通函数，而是一个generator：
>>> f = fib(6)
>>> f
generator和函数的执行顺序不同。generator是在每次调用next()的时候执行。遇到yield语句返回，再次执行的时候从上次返回的yield语句处继续执行。
def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3) print('step 3')
    yield(5)
调用该generator时，首先要生成一个generator对象，而后用next()函数不断得到下一个返回值：
>>>o = odd()
>>>next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
能够看到，odd不是普通函数，而是generator，在执行过程当中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield能够执行了，因此，第4次调用next(o)就报错。
把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：
>>>for n in fib(6)
　　print(n)
1
1
2
3
5
8
可是用for循环调用generator时，发现拿不到generator的return语句的返回值。若是想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done
迭代器
直接做用于for循环的数据类型有如下几种：
一类是集合数据类型，如：List,tuple,dict,set, str等；
一类是generator;包括生成器和带yield的generator function。
这些能够直接做用于for循环的对象统称为可迭代对象：Itemable。
可使用isinstance()判断一个对象是不是Itemable对象：
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
可使用isinstance()判断一个对象是不是Iterator对象：生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可使用iter()函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
>>> f = fib(6)
>>> fdef odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3) print('step 3')
    yield(5)
oddyieldyieldyieldnext(o)next()forforreturnStopIterationStopIterationvalue>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done
迭代器
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
isinstance()IteratorIteratorlistdictstrIterableIteratorlistdictstrIterableIteratoriter()>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

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

凡是可做用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过能够经过iter()函数得到一个Iterator对象。

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

for x in [1, 2, 3, 4, 5]: pass 

实际上彻底等价于：

# 首先得到Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 得到下一个值: x = next(it) except StopIteration: # 遇到StopIteration就退出循环 break