Python的集合框架

Python内置了四种集合框架（list、tuple、dict、set）

list：list是一种有序的集合

list里面的元素的数据类型也可以不同，list元素也可以是另一个list

In [28]: array = ['a',1,None,[2,3,4]]

In [29]: array
Out[29]: ['a', 1, None, [2, 3, 4]]

　In [31]: array[1]
 Out[31]: 1

In [32]: array[5]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-32-b10cbda823aa> in <module>()
----> 1 array[5]

IndexError: list index out of range

In [43]: array[3][1]
Out[43]: 3

添加、删除

list是一个可变的有序表，所以，可以往list中追加元素到末尾

In [35]: array.append('xiaohong')

In [36]: array
Out[36]: ['a', 1, None, [2, 3, 4], 'xiaohong']

也可以把元素插入到指定的位置，比如索引号为2的位置

In [37]: array.insert(2,456)

In [38]: array
Out[38]: ['a', 1, 456, None, [2, 3, 4], 'xiaohong']

要删除list末尾的元素，用pop()方法

In [39]: array.pop()
Out[39]: 'xiaohong'

In [40]: array
Out[40]: ['a', 1, 456, None, [2, 3, 4]]

要删除指定位置的元素，用pop(i)方法，其中i是索引位置

In [41]: array.pop(2)
Out[41]: 456

In [42]: array
Out[42]: ['a', 1, None, [2, 3, 4]]

获取list的长度

In [44]: len(array)
Out[44]: 4

取前三个元素：

In [1]: a = [1,2,3,4,5]
In [3]: a[0:3]
Out[3]: [1, 2, 3]

迭代索引和元素

In [10]: b = [1,2,'ffg']
In [12]: for i,value in enumerate(b):
   ....:     print i,value
   ....:
0 1
1 2
2 ffg

同时引用两个变量迭代

In [13]: b = [(1,2),(3,4),(5,6)]
In [15]: for x,y in b:
   ....:     print x,y
   ....:
1 2
3 4
5 6

快速生成一个1-10的列表

In [17]: range(1,11)
Out[17]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

tuple（元组）：tuple一旦初始化就不能修改，因为tuple不可变，所以代码更安全

tuple中的元素只能获取，不能增删改

In [46]: tup
Out[46]: (1, 2, 3)

In [48]: tup[1]
Out[48]: 2

如果只有一个元素，义时必须加一个逗号‘,’，来消除歧义：

In [49]: t = (1,)

In [50]: t
Out[50]: (1,)

tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

dict：dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

定义：

In [51]: a = {"xiaohong":56,"xiaobai":78,"xiaohei":69}
或：
In [54]: a["xiaolv"] = 88

输出value

In [53]: a["xiaobai"]
Out[53]: 78
或

In [55]: a.get("xiaohong")
Out[55]: 56

删除key：

In [56]: a.pop("xiaobai")
Out[56]: 78

In [57]: a
Out[57]: {'xiaohei': 69, 'xiaohong': 56, 'xiaolv': 88}

遍历

1、只遍历key

In [4]: a = {"xiaohong":23,"xiaoming":45,"xiaodong":48}
In [6]: for key in a:
   ...:     print key
   ...:
xiaoming
xiaohong
xiaodong

2、只遍历value

In [8]: for value in a.itervalues():
   ...:     print value
   ...:
45
23
48

3、同时迭代key和value

In [9]: for k,v in a.iteritems():
   ...:     print k,v
   ...:
xiaoming 45
xiaohong 23
xiaodong 48

dict和list比较

1. dict查找和插入的速度极快，不会随着key的增加而增加；list查找和插入的时间随着元素的增加而增加；
2. dict需要占用大量的内存，内存浪费多。list占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

set：一组无重复key的集合，类似于dict，但只存key

要创建一个set，需要提供一个list作为输入集合，为了与tuple区分开

有两种方法：
1、
In [60]: s = set([1,2,3,4,4])

In [61]: s
Out[61]: {1, 2, 3, 4}

2、
In [62]: b = {2,3,4,5,6}

In [63]: b
Out[63]: {2, 3, 4, 5, 6}

添加元素：

In [64]: s.add(9)

In [65]: s
Out[65]: {1, 2, 3, 4, 9}

删除元素：

In [66]: s.remove(1)

In [67]: s
Out[67]: {2, 3, 4, 9}

交并集运算：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
set([2, 3])
>>> s1 | s2
set([1, 2, 3, 4])

set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。