切片
取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循环中同时迭代索引和元素本身：>>> 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[]和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
凡是可作用于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