1.迭代器 iterator
iter 函数,构造集合。
next 方法依次返回迭代器的值
In [42]: li
Out[42]: [1, 2, 3, 4, 5]
In [43]: it = iter(li)
In [44]: it.next()
Out[44]: 1
In [45]: it.next()
Out[45]: 2
当所有的元素都返回完的时候,会抛出一个StopIterator 的异常。
list,tuple,set 都属于集合。
for 语句,当将一个列表传递给for 语句的时候,实际上for 语句会将列表转换为迭代器,然后隐示的地执行该迭代器。
2. 字典 dict
2.1 定义与初始化 In [46]: d = {}
In [47]: type(d)
Out[47]: dict
In [48]: d = {‘a‘:1,‘v‘:‘k‘}
In [49]: d
Out[49]: {‘a‘: 1, ‘v‘: ‘k‘}
在字典中key是不允许重复的,所以字典中的key必须是可hash的对象。
2.2字典的操作
2.2.1 keys 将字典的所有key作为一个列表返回In [50]: d
Out[50]: {‘a‘: 1, ‘v‘: ‘k‘}
In [51]: d.keys()
Out[51]: [‘a‘, ‘v‘]
2.2.2 iterkeys 将字典的所有key作为一个迭代器返回
In [52]: d.iterkeys()
Out[52]: <dictionary-keyiterator at 0x12ff7e0>
In [53]: it = d.iterkeys()
In [54]: it.next()
Out[54]: ‘a‘
2.2.3 values 返回一个列表,该列表是所有元素的值
In [55]: d
Out[55]: {‘a‘: 1, ‘v‘: ‘k‘}
In [56]: d.values()
Out[56]: [1, ‘k‘]
2.2.4 items ,返回一个列表,列表中的每个元素是一个元组,元组中的两个值分别是key和value
In [57]: d
Out[57]: {‘a‘: 1, ‘v‘: ‘k‘}
In [58]: d.items()
Out[58]: [(‘a‘, 1), (‘v‘, ‘k‘)]
遍历一个字典:
In [59]: for v in d.values():
....:
print v
....:
1
k
In [60]: for k,v in d.items():
....:
print "%s => %s" % (k,v)
....:
a => 1
v => k
2.3.5 get ,按照key取值,若存在则返回,否则返回None
In [61]: d.get(‘a‘)
Out[61]: 1
还可以给get 传递第二个参数,表示若key不存在,则返回某个值。
In [65]: d.get(‘xx‘,100)
Out[65]: 100
2.2.6 has_key ,判断某个key是否存在
In [63]: d.has_key(‘a‘)
Out[63]: True
In [64]: d.has_key(‘aa‘)
Out[64]: False
2.3给字典增加一个键值对:
In [66]: d = {}
In [67]: d[‘c‘] = 1
In [68]: d
Out[68]: {‘c‘: 1}
In [69]: d[‘xx‘] = 100
In [70]: dOut[70]: {‘c‘: 1, ‘xx‘: 100}
In [71]: d[‘xx‘] = 200
In [72]: d
Out[72]: {‘c‘: 1, ‘xx‘: 200}
2.4update 操作
In [73]: d
Out[73]: {‘c‘: 1, ‘xx‘: 200}
In [74]: d.update({‘a‘:1,‘b‘:2})
In [75]: d
Out[75]: {‘a‘: 1, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
2.5 python字典为引用传值,如:
In [76]: d
Out[76]: {‘a‘: 1, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
In [77]: d1 = d
In [78]: d1[‘a‘] = 200
In [79]: d1
Out[79]: {‘a‘: 200, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
In [80]: d
Out[80]: {‘a‘: 200, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
2.6 copy 操作:重新复制一个字典
In [81]: d
Out[81]: {‘a‘: 200, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
In [82]: d2 = d.copy()
In [83]: d2
Out[83]: {‘a‘: 200, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
In [84]: d2[‘a‘] = 300
In [85]: d2
Out[85]: {‘a‘: 300, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
In [86]: d
Out[86]: {‘a‘: 200, ‘b‘: 2, ‘c‘: 1, ‘xx‘: 200}
In [87]: id(d)
Out[87]: 19662176
In [88]: id(d2)
Out[88]: 19501072
In [89]: id(d1)
Out[89]: 19662176
3.列表解析
[expression for item in iterator] 一个最基本的列表解析,返回一个列表
在expression 可以使用item 变量
返回一个迭代器
(expression for item in terator)
In [90]: li = [1,2,3]
In [91]: l = (x+1 for x in li)
In [92]: l
Out[92]: <generator object <genexpr> at 0x12fa730>
In [93]: l.next()
Out[93]: 2In [94]: l.next()
Out[94]: 3
迭代器是惰性求值,只有用到了才会计算该值,否则不会。列表是先求出所有值的。所以当数据大的时候迭代器有较好的性能。
带条件的列表解析
[expression for item in iterator if condition] ,当满足条件的时候才会append到列表中,并返回。当变为小括号的时候,就会返回一个迭代器。
In [95]: li
Out[95]: [1, 2, 3]
In [96]: [x for x in li if x % 2 ==0]
Out[96]: [2]
带多个条件 [expression for item in iterator if conditionX if conditionY]
带多个迭代器(笛卡尔积与列表解析):[expr for x in IterX for y in IterY] ,类似于两个嵌套的for循环操作
In [99]: [(x,y) for x in [1,2,3] for y in [1,3]]
Out[99]: [(1, 1), (1, 3), (2, 1), (2, 3), (3, 1), (3, 3)]
列表解析的性能远高于循环语句。