Python中的list/tuple/dict/set数据类型详解

Python内部内置了一些数据类型与结构，可以方便在编程时候的使用。

list

List存储一系列的有序集合，并且元素内容可变（可更改、删除、添加）。

>>> fruits=['apple','orange','pear','banana']
>>> fruits[0]
'apple'
>>> fruits[-1]
'banana'

由上可知可以使用下标进行list元素的索引，正数下标为正向索引，负数下标为反向索引，fruits[-1]就是倒数第一个元素。并且可以使用+操作符进行list列表的串接。

>>> otherFruits=['kiwi','strawberry']
>>> fruits+otherFruits
['apple', 'orange', 'pear', 'banana', 'kiwi', 'strawberry']

由于list是一个可变的有序列表，所以可以向其中添加、删除、更改元素。

>>> fruits.pop()        //删除末尾的元素
'banana'
>>> fruits                //banana已经被删除
['apple', 'orange', 'pear']
>>> fruits.append('grapefruit')    //向列表末尾增添元素
>>> fruits
['apple', 'orange', 'pear', 'grapefruit']
>>> fruits[-1]='pineapple'           //更改列表中的某一个值
>>> fruits
['apple', 'orange', 'pear', 'pineapple']
>>> fruits.insert(2,'watermelon')   //向列表中第二个元素位置插入一个元素
>>> fruits
['apple', 'orange', 'watermelon', 'pear', 'pineapple']
>>> fruits.pop(2)         //删除指定位置的元素，用pop(i)
'watermelon'
>>> fruits
['apple', 'orange', 'pear', 'pineapple']

也可以利用切片操作符列出相邻的元素，fruits[start:stop]或者fruits[:stop]或者fruits[start:]这三种形式。
欲获得更多有关list的信息，可以使用帮助文件。

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> help(list.reverse)
Help on method_descriptor:reverse(...)L.reverse() -- reverse *IN PLACE*

tuple

另一个与list很像的数据类型是tuple，除了它一旦被创建就是不可更改的。注意tuple在创建时使用圆括号，而list在创建时使用的是方括号。
一旦tuple被创建，我们可以使用fruits[0]，fruits[-1]去正常的索引元素，但是不能更改元素。不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

>>> fruits=('apple','pear','grape')
>>> fruits[0]
'apple'
>>> fruits[-1]
'grape'
>>> fruits[0]='pineapple'
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> a,b,c=fruits
>>> a
'apple'
>>> b
'pear'
>>> c
'grape'

注意：只有1个元素的tuple定义时必须加一个逗号，来消除歧义。因为()不仅用来表示tuple数据结构，还可以用来数学中的公式。这就产生了歧义，因此，Python规定，在t(1)这种情况下，按小括号进行计算，计算结果自然是1。

>>> t=(1,)
>>> t
(1,)

最后看一个“可变的”tuple：

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

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。

dict

Dictionary存储了从一种对象（key）到另一种对象（value）的映射关系，key必须是不可变的对象（字符串、数字或者tuple），而value对象则是可变的任意数据类型。Dict的创建采用花括号。
注意：dict中的key的顺序不是固定的，即没有确定的元素顺序，编程的时候也不应该依赖于dict中的元素顺序。

>>> studentsIds={'kuth':90,'turing':99,'nash':80}
>>> studentsIds['turing']
99
>>> studentsIds['nash']=60   //更改元素的value值
>>> studentsIds
{'turing': 99, 'nash': 60, 'kuth': 90}
>>> del studentsIds['turing']   //删除某个指定元素
>>> studentsIds
{'nash': 60, 'kuth': 90}
>>> studentsIds['bug']=['time',90,(1,2)]   //添加某个元素，注意元素的value可以为任意数据类型
>>> studentsIds
{'nash': 60, 'kuth': 90, 'bug': ['time', 90, (1, 2)]}
>>> studentsIds.keys()     //列出dict的键值
['nash', 'kuth', 'bug']
>>> studentsIds.values()  //列出dict的元素的值
[60, 90, ['time', 90, (1, 2)]]
>>> studentsIds.items()   //列出dict的所有条目
[('nash', 60), ('kuth', 90), ('bug', ['time', 90, (1, 2)])]
>>> len(studentsIds)        //显示dict的长度，都可以使用len函数来确定
3

在进行dict操作的时候，为避免key不存在而造成的错误，可以使用以下两个方法：
- 通过in来判断key是否存在：

>>> 'nash' in studentsIds
True
>>> 'tom' in studentsIds
False

通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

>>> studentsIds.get('nash')     //存在，则返回key对应的value
60
>>> studentsIds.get('nash',-1)
60
>>> studentsIds.get('tom',-1)  //不存在，则返回自定义的-1或者none（什么也不返回）
-1
>>> studentsIds.get('tom')

和list比较，dict有以下几个特点：
- 查找和插入的速度极快，不会随着key的增加而增加；
- 需要占用大量的内存，内存浪费多。

而list相反：
- 查找和插入的时间随着元素的增加而增加；
- 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。
可以使用dir(dict)和help(dict.xxx)来显示更详细的帮助信息。

set

set是另一种包含无序不重复元素的数据结构，就如同dict中的key一样，只不过其相对于dict只有key，而没有与key相对应的value。
因此set中的元素和dict中的key一样，只能是string，number和tuple等不可变的元素，而不能是list。
在创建set的时候，需要提供一个list作为输入。

>>> shapes=['circle','triangle','rectangle','circle']
>>> setOfShapes=set(shapes)      //以list作为输入创建一个set
>>> setOfShapes
set(['circle', 'triangle', 'rectangle'])   //发现list中重复的元素已经被去除
>>> setOfShapes.add('polygon')   //添加元素
>>> setOfShapes
set(['circle', 'triangle', 'polygon', 'rectangle'])
>>> 'circle' in setOfShapes          //判断元素是否在set中
True
>>> 'rhombus' in setOfShapes
False
>>> favoriteShapes=['circle','triangle','hexagon']
>>> setOfFavoriteShapes=set(favoriteShapes)
>>> setOfShapes-setOfFavoriteShapes     //set由于是可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作
set(['polygon', 'rectangle'])
>>> setOfShapes&setOfFavoriteShapes
set(['circle', 'triangle'])
>>> setOfShapes|setOfFavoriteShapes
set(['triangle', 'polygon', 'circle', 'hexagon', 'rectangle'])

再议不可变对象

str是不变对象，而list是可变对象。对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作呢：

>>> a='abc'
>>> a.replace('a','A')
'Abc'
>>> a
'abc'
>>> b=a.replace('a','A')
>>> b
'Abc'

当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象’abc’上的，而这个方法虽然名字叫replace，但却没有改变字符串’abc’的内容。相反，replace方法创建了一个新字符串’Abc’并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串’abc’，但变量b却指向新字符串’Abc’了。所以，对于不变变量，调用对象的任何自身的方法，都不会更改该对象自身的内容，但这些方法会创建新的对象并返回，这就保证了不可变对象本身永远是不可变的。

祝枫
2016年10月4日于哈尔滨