Python内置容器——字典，迭代器，列表解析

Posted 2020-08-09

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)]

    列表解析的性能远高于循环语句。

本文出自 “技术人生，简单不简单” 博客，请务必保留此出处http://willis.blog.51cto.com/11907152/1855129