三、高级特性
1.切片
L = ['Michael','Sarah','Tracy','Bob','Jack']
L[0:3]
L[:3]#取头不取尾
L[:10:2] #前10个数，每两个取一个
L[::5]#所有数，每5个取一个
L[:]#全选
#tuple/char与list相同
(0,1,2,3,4,5)[:3]
'ABCDEFG'[:3]
2.迭代
iterable：可迭代的
如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们叫做迭代（lteration）
d = {'a':1, 'b':2, 'c':3}
for key in d:
print(key)#因为dict的存储不是按照list的方式顺序排列，所以，迭代出来的结果顺序很可能不一样
a b c
d = {'a':1, 'b':2, 'c':3}
for value in d.values():
print(value)
1 2 3
d = {'a':1, 'b':2, 'c':3}
for k,v in d.items():
print(k,v)
a 1 b 2 c 3
for ch in 'ABC':
print(ch)
A B C
当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行
如何判断一个对象是可迭代对象，方法是通过collections模块的lterable类型判断
from collections import Iterable
isinstance('abc',Iterable) #str是否可迭代
isinstance([1,2,3],Iterable)#list是否可迭代
isinstance(123,Iterable)#整数是否可迭代 #False
python内置的enumerate函数可以把a一个list变成（索引—元素）对，这样就可以在for循环中同时迭代索引和元素本身
for i,value in enumerate(['A','B','C']):
print(i,value)
0 A 1 B 2 C
for x,y in [(1,1),(2,4),(3,9)]:
print(x,y)
1 1 2 4 3 9
3.列表生成式
用来创建列表
list(range(1,11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
生成1*1,2*2,3*3...
L = []
for i in range(1,11):
L.append(i*i)
L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[x for x in range(1,11)]
[x*x for x in range(1,11)]
[x*x for x in range(1,11) if x%2==0]
[m+n for m in 'ABC' for n in 'XYZ'] #['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
运用列表生成式,可以写出非常简洁的代码
d = {'x':'A','y':'B','z':'C'}
for k,v in d.items():
print(k,'=',v)#或者print(k+'='+v)
x = A y = B z = C
[k + '=' + 'v' for k,v in d.items()]
['x=v', 'y=v', 'z=v']
L = ['Hello','World','IBM','Apple']
[s.lower() for s in L] #如果L里面有数字，结果就会报错
['hello', 'world', 'ibm', 'apple']
isinstance函数可以判断一个变量是不是字符串
x = 'abc'
y = 123
isinstance(x,str) #True
isinstance(y,str) #False
4.生成器
import time def generator_fun1(): a = 1 print('现在定义了a变量') yield a b =2 print('现在定义了b变量') yield b g1 = generator_fun1() print('g1:',g1) #打印结果：g1: <generator object generator_fun1 at 0x04870D30>，可以发现g1是个生成器 print('-'*20) #分割线 print(next(g1)) time.sleep(1) #sleep一秒看清楚执行过程 print(next(g1))
通过列表生成式，我们可以直接创建一个列表，但是，收到内存限制，列表容量肯定是有限的，而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面的绝大多数元素占用的空间都白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢，这样就不必创建完整的list,从而节省大量的空间。
例如，学校定制了200000件衣服，当然是生产好了一件一件的拿，或者一批一批的拿，不然等完全生产好再拿，学生都已经毕业
在python中，这种以便循环一遍计算的机制，称作生成器：generator
1）生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方执行
2）生成器表达式：类似于列表推导，但是，生成器返回按需生产结果的一个对象，而不是一次构建一个结果列表
3）本质上是迭代器
4）惰性运算，开发者自定义
生成器优点：
1）延迟计算，一次返回一个结果，也就是说，他不会一次生成所有的结果，这对于大数据量处理，将会非常有用
2）提高代码可读性
要创建一个generator，有很多种方法：
第一种：把一个列表生成式的[]改成（），就创建了一个generator
g = (x*x for x in range(10))
#列表解析 sum([i for i in range(100000)]) #内存占用大，机器容易卡死 #生成器表达式 sum(i for i in range(10000000)) #几乎不占内存
如果要一个一个打印出来，可以通过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
n = n+1
return 'done'
fib(6)
上面的函数和generator仅一步之遥，要把fib函数变成generator，只需要把print(b)改成yield(b)，如果一个函数定义包含yield关键字，那么这个函数就不再是一个普通函数，而是一个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'
f = fib(6) f
<generator object fib at 0x04258FB0>
函数是顺序执行，遇到return语句或者最后一行函数语句就返回，而generator函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处执行
next(f) #1 next(f) #1 next(f) #2 .......
def odd():
print('step 1')
yield 1
print('step 2')
yield(3)
print('step 3')
yield(5) o = odd() o #<generator object odd at 0x04781D30>
调用该generator时，首先生成一个generator对象，然后用next()函数不断获得下一个返回值，遇到yield就返回
o = odd()
next(o) #step1 1
next(o) #step 2 3
next(o) #step 3 5
next(o)单独执行next(o)，执行一次为step1 1，执行两次为step2 3，执行三次为step3 5
可以看到，odd不是普通函数，而是generator，在执行过程中，遇到yield就中断，下次又继续执行写一个yield，执行三次yield后，已经没有yield可以执行了。所以第四次调用next(o)就报错
同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代
def fib(max):
n, a, b =0,0,1
while n<max:
yield b
a, b = b, a+b
n = n+1
return 'done'
f = fib(6) for n in f: print(n)
1 1 2 3 5 8
5.迭代器
给定一个迭代器：[1,2]，dir[1,2].__iter__()是列表迭代器中实现的所有方法，dir[1,2]是列表中实现的所有方法，都是以列表的形式返回给我们，先转换成集合，然后转差集
print(set(dir([1,2].__iter__()))-set(dir([1,2])))
{'__next__', '__setstate__', '__length_hint__'}
在列表迭代器中多了三个方法，分别观察这三个方法都是什么
iter_1 = [1,2,3,4,5,6].__iter__() #获取迭代器中元素的长度 print(iter_1.__length_hint__())
6
iter_1 = [1,2,3,4,5,6].__iter__() #根据索引值指定从哪里开始迭代 print(iter_1.__setstate__(3)) for i in iter_1: print(i)
None 4 5 6
iter_1 = [1,2,3,4,5,6].__iter__() #一个一个的取值 print(iter_1.__next__())
迭代器遵循迭代器协议：必须拥有__iter__方法和__next__方法
range()是可迭代对象，判断是不是迭代器
print('__next__' in dir(range(12))) #查看’__next__‘ 在不在 #False print('__iter__' in dir(range(12))) #查看’__iter__‘ 在不在 #True from collections import Iterator print(isinstance(range(1000000),Iterator)) #验证是不是一个迭代器 #False
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型：如list、tuple、dict、set、str等
一类是generator，包括生成器和带yield的generator function
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable
可以使用isinstance()判断一个对象是否是Iterable对象hangzhifa
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
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出stopIteration错误表示无法继续返回下一个值了
可以被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等Iterable变成Iterator，可以使用iter()函数
isinstance(iter([]), Iterator) #True
isinstance(iter('abc'), Iterator) #True
为何list、dict、str等数据类型不是Iterator？
因为python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误，可以把这个数据流看作是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过过next()实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时他才会计算
Iterator甚至可以表示一个无限大的数据流，例如全体自然数，而使用list是永远不可能存储全体自然数的
小结：
凡是可作用于for循环的对象都是Iterable类型
凡是可作用于next()函数的对象都是Iterator类型，他们表示一个惰性计算的序列
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象
python的for循环本质上就是通过不断调用next()函数实现的