Python 的数据结构

1，元组

元组是一个固定长度，不可改变的Python序列对象。
创建元组的最简单方式，是用逗号分隔一列值：

In [1]: tup = 4, 5, 6

In [2]: tup
Out[2]: (4, 5, 6)

当用复杂的表达式定义元组时，最好，比如这样

In [3]: nested_tup = (4, 5, 6), (7, 8)

In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))

用tuple可以将任意序列或迭代器转化为元组

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)

In [6]: tup = tuple('string')

In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

可以用方括号访问元组中的内容，序列以0开头

In [8]: tup[0]
Out[8]: 's'

元组中的对象不能进行改变否则将报错

In [9]: tup = tuple(['foo', [1, 2], True])

In [10]: tup[2] = False
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-c7308343b841> in <module>()
----> 1 tup[2] = False
TypeError: 'tuple' object does not support item assignment

但是如果元组中某个对象是可变对象，比如列表，可以对这个对象在原位进行修改

In [11]: tup[1].append(3)

In [12]: tup
Out[12]: ('foo', [1, 2, 3], True)

元组可以用“+”号进行组合

In [13]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[13]: (4, None, 'foo', 6, 0, 'bar')

元组可以乘以数值，会把元组中的对象进行复制就像列表一样

1.2、拆分元组

相对于其他语言，python可以智能的把元组赋值给类似元组的变量（注意元组中有多少个对象，原则上就需要有多少个变量）

In [15]: tup = (4, 5, 6)

In [16]: a, b, c = tup

In [17]: b
Out[17]: 5

即使含有元组的元组也会被拆分：

In [18]: tup = 4, 5, (6, 7)

In [19]: a, b, (c, d) = tup

In [20]: d
Out[20]: 7

变量也可以是一个元组，例如这样也行

In [18]: tup = 4, 5, (6, 7)

In [19]: a, b, c = tup

In [20]: c
Out[20]: (6,7)

使用这个功能，你可以很容易地替换变量的名字，其它语言可能是这样：

tmp = a
a = b
b = tmp

但是在 Python 中，替换可以这样做：

In [21]: a, b = 1, 2

In [22]: a
Out[22]: 1

In [23]: b
Out[23]: 2

In [24]: b, a = a, b

In [25]: a
Out[25]: 2

In [26]: b
Out[26]: 1

也可以只把元组开头的几个对象赋值给变量，其他的都不要例如这样

In [29]: values = 1, 2, 3, 4, 5
#只要元组的前两个对象，剩余的对象打包给rest，注意符号"*"
#rest的部分是想要舍弃的部分，rest的名字不重要。作为惯用写法，许多 Python 程序员会将不需要的变量使用下划线：
In [33]: a, 
In [30]: a, b, *rest = values

In [31]: a, b
Out[31]: (1, 2)

In [32]: rest
Out[32]: [3, 4, 5]

因为元组的大小和内容不能修改，所以针对元组的实例方法很少，其中一个很有用的就是count（也适用于列表），它可以统计某个值得出现频率：

In [34]: a = (1, 2, 2, 2, 3, 4, 2)

In [35]: a.count(2)
Out[35]: 4

2,列表

与元组相比列表格式，长度及内容均可以进行修改，可以用方括号定义，或者用list函数

#使用方括号定义列表
In [36]: a_list = [2, 3, 7, None]

In [37]: tup = ('foo', 'bar', 'baz')
#使用list函数把元组转化为列表
In [38]: b_list = list(tup)

In [39]: b_list
Out[39]: ['foo', 'bar', 'baz']
#列表中的元素可以直接进行修改
In [40]: b_list[1] = 'peekaboo'

In [41]: b_list
Out[41]: ['foo', 'peekaboo', 'baz']

list函数还可以用来实体化迭代器或生成器

In [42]: gen = range(10)

In [43]: gen
Out[43]: range(0, 10)

In [44]: list(gen)
Out[44]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2.2 列表添加和删除元素

可以使用append在末尾添加元素

In [45]: b_list.append('dwarf')

In [46]: b_list
Out[46]: ['foo', 'peekaboo', 'baz', 'dwarf']

insert可以在任意位置插入元素
insert函数有两个参数，第一个是要插入的位置，第二个是要插入的内容
在指定位置插入元素，指定位置原来的元素及之后的元素往后顺移
插入的序号必须在 0 和列表长度之间。

警告：与append相比，insert耗费的计算量大，因为对后续元素的引用必须在内部迁移，以便为新元素提供空间。如果要在序列的头部和尾部插入元素，你可能需要使用collections.deque，一个双尾部队列。

In [46]: b_list
Out[46]: ['foo', 'peekaboo', 'baz', 'dwarf']
#insert函数有两个参数，第一个是要插入的位置，第二个是要插入的内容
#在指定位置插入元素，指定位置原来的元素及之后的元素往后顺移
In [47]: b_list.insert(1, 'red')
In [48]: b_list
Out[48]: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']

insert函数的逆运算函数是pop函数，它可以移除指定位置的元素，并返回此元素
pop函数只有一个参数就是要移除的参数的位置

In [48]: b_list
Out[48]: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']

In [49]: b_list.pop(2)
Out[49]: 'peekaboo'

In [50]: b_list
Out[50]: ['foo', 'red', 'baz', 'dwarf']

可以使用remove函数，去除列表中某个值，remove函数会去除找到的第一个此值

In [51]: b_list.append('foo')

In [52]: b_list
Out[52]: ['foo', 'red', 'baz', 'dwarf', 'foo']

In [53]: b_list.remove('foo')

In [54]: b_list
Out[54]: ['red', 'baz', 'dwarf', 'foo']

用in可以判断列表是否包含某个值，用not in可以判断列表是否不包含某个值

In [55]: 'dwarf' in b_list
Out[55]: True

In [56]: 'dwarf' not in b_list
Out[56]: False

在列表中检查是否存在某个值远比字典和集合速度慢，因为 Python 是线性搜索列表中的值，但在字典和集合中，在同样的时间内还可以检查其它项（基于哈希表）。

2.3 串联和组合列表

与元组类似，可以用"+"把两个列表组合其他

In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]

可以使用extend函数追加多个元素

In [58]: x = [4, None, 'foo']

In [59]: x.extend([7, 8, (2, 3)])

In [60]: x
Out[60]: [4, None, 'foo', 7, 8, (2, 3)]

通过加法将列表串联的计算量较大，因为要新建一个列表，并且要复制对象。用extend追加元素，尤其是到一个大列表中，更为可取。因此：

2.4 排序

可以使用sort函数对列表进行排序（sort函数是直接对原有列表进行排序，使用这个函数后原有列表将被改变，函数sorted()是产生一个排序列表的副本不改变原有的列表）

In [61]: a = [7, 2, 5, 1, 3]

In [62]: a.sort()

In [63]: a
Out[63]: [1, 2, 3, 5, 7]

sort函数有两个可选的参数
参与1：参数key是用来指定按照什么进行排序的，默认是——数字、字符串按照ASCII，中文按照unicode从小到大排序

In [64]: b = ['saw', 'small', 'He', 'foxes', 'six']

In [65]: b.sort(key=len)

In [66]: b
Out[66]: ['He', 'saw', 'six', 'small', 'foxes']

参数2：参数reverse是用来确定排序是降序还是升序的，默认是升序，当reverse = True时，为降序排序

In [64]: print(d_list) 
Out[66]: [1, 1, 2, 3, 5]
In [66]: d_list.sort(reverse = True)
In [66]: d_list
Out[66]: [5, 3, 2, 1, 1]

2.5 切片

切片可以截取列表的一部分，切片的基本形式是在方括号中使用start:stop：

In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]

In [74]: seq[1:5]
Out[74]: [2, 3, 7, 5]

切片也可以进行赋值

In [75]: seq[3:4] = [6, 3]

In [76]: seq
Out[76]: [7, 2, 3, 6, 3, 5, 6, 0, 1]

切片的起始元素是包括的，不包含结束元素。因此，结果中包含的元素个数是stop - start。
start或stop都可以被省略，省略之后，分别默认序列的开头和结尾：

In [77]: seq[:5]
Out[77]: [7, 2, 3, 6, 3]

In [78]: seq[3:]
Out[78]: [6, 3, 5, 6, 0, 1]

切片也可以使用负数，负数表明从后向前切片：

In [79]: seq[-4:]
Out[79]: [5, 6, 0, 1]
In [80]: seq[-6:-2]
Out[80]: [6, 3, 5, 6]

两个冒号之后可以间隔取数，例如seq[::2]就是从头到尾进行切片且间隔一个进行取数

#注意seq[::-1]可以倒序进行切片，且只能从头到尾倒序切片，不能切一部分再倒序（这种返回的结果为空）
In [79]: seq,seq[1:5],seq[1:5:2],seq[::-1]
Out[80]: ([1, 3, 2, 4, 5, 6, 7], [3, 2, 4, 5], [3, 4], [7, 6, 5, 4, 2, 3, 1])

2.6 序列函数

enumerate函数
enumerate函数用于遍历序列中的元素以及它们的下标,多用于在for循环中得到计数,enumerate参数为可遍历的变量，如 字符串，列表等
enumerate英文含义为列举，枚举

In [79]: for index,text in enumerate(x):
In [79]:     print('index',index),print('text',text)
Out[80]: 
text s
index 1
text t
index 2
text r
index 3
text i
index 4
text n
index 5
text g

sorted函数
sorted函数可以从任意序列中返回一个排列好的列表

In [87]: sorted([7, 1, 2, 6, 0, 3, 2])
Out[87]: [0, 1, 2, 2, 3, 6, 7]

In [88]: sorted('horse race')
Out[88]: [' ', 'a', 'c', 'e', 'e', 'h', 'o', 'r', 'r', 's']


sorted函数有两个可选参数，和sort函数是一样的，分别是key参数及reverse参数。

**zip函数**
zip函数，可以将多个列表，元组或其他序列，组成一个元组列表

```python
In [89]: seq1 = ['foo', 'bar', 'baz']

In [90]: seq2 = ['one', 'two', 'three']

In [91]: zipped = zip(seq1, seq2)
#zip函数返回的结果需要用list函数列表化
In [92]: list(zipped)
Out[92]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zip函数可以组合多个任意长度的序列，返回列表的长度取决于最短的序列

In [93]: seq3 = [False, True]

In [94]: list(zip(seq1, seq2, seq3))
Out[94]: [('foo', 'one', False), ('bar', 'two', True)]

zip函数,可以把多个序列组合在一起形成一个元素为元组的列表，也可以使用zip函数把一个元素为元组的列表拆成多个元组

In [96]: pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),
   ....:             ('Schilling', 'Curt')]

In [97]: first_names, last_names = zip(*pitchers)

In [98]: first_names
Out[98]: ('Nolan', 'Roger', 'Schilling')

In [99]: last_names
Out[99]: ('Ryan', 'Clemens', 'Curt')

reversed函数
reversed可以从后向前迭代一个序列：

In [100]: list(reversed(range(10)))
Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

3，字典

字典可能是 Python 最为重要的数据结构。它更为常见的名字是哈希映射或关联数组。它是键值对的大小可变集合，键和值都是 Python 对象。创建字典的方法之一是使用尖括号，用冒号分隔键和值：
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

In [101]: empty_dict = {}

In [102]: d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]}

In [103]: d1
Out[103]: {'a': 'some value', 'b': [1, 2, 3, 4]}

字典可以像列表一样，访问，插入或设定字典的元素

In [104]: d1[7] = 'an integer'

In [105]: d1
Out[105]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

In [106]: d1['b']
Out[106]: [1, 2, 3, 4]

可以像检查列表或元组那样，检查字典是否包含某个键（注意这里说的是键不是元素）

In [107]: 'b' in d1
Out[107]: True

可以使用del关键字，或者pop方法删除字典中的某个值（返回值的同时删除键）

In [108]: d1[5] = 'some value'

In [109]: d1
Out[109]: 
{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 5: 'some value'}

In [110]: d1['dummy'] = 'another value'

In [111]: d1
Out[111]: 
{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 5: 'some value',
 'dummy': 'another value'}

In [112]: del d1[5]

In [113]: d1
Out[113]: 
{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 'dummy': 'another value'}

In [114]: ret = d1.pop('dummy')

In [115]: ret
Out[115]: 'another value'

In [116]: d1
Out[116]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

删除与清除字典
能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典
 
print "tinydict['Age']: ", tinydict['Age'] 
print "tinydict['School']: ", tinydict['School']

keys 和values 是字典的键和值的迭代器的方法，虽然字段没有顺序，但是这两个方法可以用相同的顺序输出键和值：

#用keys方法，返回的是一个迭代器，需要用list函数转化为字典才能显示出结果
In [117]: list(d1.keys())
Out[117]: ['a', 'b', 7]

In [118]: list(d1.values())
Out[118]: ['some value', [1, 2, 3, 4], 'an integer']

用update方法可以融合另一个字典

#update方法是原地改变字典，因此任何传递给update的键的旧的值都会被舍弃。
In [119]: d1.update({'b' : 'foo', 'c' : 12})

In [120]: d1
Out[120]: {'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}

3.2 用序列创建字典

可以用for循环的方法，把两个序列合并为字典（一个序列为键，一个序列为值）

In [120]: 	l1 = list(range(5))
			l2 = list(reversed(range(5)))
			d2 = {}
			#使用zip函数把两个列表合并为一个元组
			for key,value in zip(l1,l2):
	    		d2[key] = value
			d2
Out[120]: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

因为字典本质上说2元元组的集合，因此2元元组可以直接转化为字典

In [121]: mapping = dict(zip(range(5), reversed(range(5))))

In [122]: mapping
Out[122]: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

3.3 字典常用函数

1 cmp(dict1, dict2)
比较两个字典元素。
2 len(dict)
计算字典元素个数，即键的总数。
3 str(dict)
输出字典可打印的字符串表示。
4 type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。

1 dict.clear()
删除字典内所有元素
2 dict.copy()
返回一个字典的浅复制
3 dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4 dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5 dict.has_key(key)
如果键在字典dict里返回true，否则返回false
6 dict.items()
以列表返回可遍历的(键, 值) 元组数组
7 dict.keys()
以列表返回一个字典所有的键
8 dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2)
把字典dict2的键/值对更新到dict里
10 dict.values()
以列表返回字典中的所有值
11 pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12 popitem()
返回并删除字典中的最后一对键和值。

4，集合

集合是无序的不可重复的元素的集合，你可以把它当做字典，但是只有键没有值。可以用两种方式创建集合：通过set函数或使用尖括号set语句：

In [133]: set([2, 2, 2, 1, 3, 3])
Out[133]: {1, 2, 3}

In [134]: {2, 2, 2, 1, 3, 3}
Out[134]: {1, 2, 3}

集合支持合并、交集、差分和对称差等数学集合运算。考虑两个示例集合：

In [135]: a = {1, 2, 3, 4, 5}

In [136]: b = {3, 4, 5, 6, 7, 8}

合并是取两个集合中不重复的元素。可以用union方法，或者|运算符：

In [137]: a.union(b)
Out[137]: {1, 2, 3, 4, 5, 6, 7, 8}

In [138]: a | b
Out[138]: {1, 2, 3, 4, 5, 6, 7, 8}

交集的元素包含在两个集合中。可以用intersection或&运算符：

In [139]: a.intersection(b)
Out[139]: {3, 4, 5}

In [140]: a & b
Out[140]: {3, 4, 5}

常见的集合方法