目录

元组列表字典集合

Python的数据结构和序列

本篇写的是Python的内置功能，从最基本的数据结构开始：元组，列表，字典和集合。

元组

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

In [1]: tup = 4, 5, 6In [2]: tupOut[2]: (4, 5, 6)

或者把值放入括号里面：

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

用tuple可以将任意序列或迭代器转换成元组：

In [5]: tuple([4, 0, 2])Out[5]: (4, 0, 2)In [6]: tuple('string')Out[6]: ('s', 't', 'r', 'i', 'n', 'g')

可以用方括号访问元组中的元素，序列从0开始：

In [7]: tup = tuple('string')In [8]: tup[0]Out[8]: 's'

可以用加号运算符将元组合并：

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

元组乘以一个整数会将几个元组复制串联起来：

In [10]: ('foo', 'bar') * 4Out[10]: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')

我们可以将元组赋给类似元组的变量

In [11]: tup = (4, 5, 6)In [12]: a, b, c = tupIn [13]: cOut[13]: 6

Python还有更高级的元组拆分功能，使用*rest(rest是任意名字)可以抓取剩下的元素：

In [14]: values = 1, 2, 3, 4, 5In [15]: a, b, *rest = valuesIn [16]: a, bOut[16]: (1, 2)In [17]: restOut[17]: [3, 4, 5]

如果rest部分不想要，许多程序员的惯用写法是用下划线代替不需要的变量名：

a, b, *_ = values

元组的大小和内容不能修改，所以元组的方法较少。但我们可以用count统计某个值出现的次数：

In [18]: a = (1, 2, 2, 2, 3, 4, 2)In [19]: a.count(2)Out[19]: 4

列表

与元组对比，列表的长度可变，内容可以被修改。可以用方括号或list函数定义：

a_list = [2, 3, 7, None]tup = ('foo', 'bar', 'baz')b_list = list(tup)

1.添加或删除元素

可以用append在列表末尾添加元素:

In [20]: b_list = ['apple', 'banana', 'orange']In [21]: b_list.append('grape')In [22]: b_listOut[22]: ['apple', 'banana', 'orange', 'grape']

可以用insert在特定的位置插入元素：

In [23]: b_list.insert(1, 'peach')In [24]: b_listOut[24]: ['apple', 'peach', 'banana', 'orange', 'grape']

pop是insert的逆运算，它移除并返回指定位置的元素：

In [25]: b_list.pop(2)Out[25]: 'banana'

remove可以去除某个值，remove会先寻找第一个值并除去：

In [26]: b_list.append('apple')In [27]: b_listOut[27]: ['apple', 'peach', 'orange', 'grape', 'apple']In [28]: b_list.remove('apple')In [29]: b_listOut[29]: ['peach', 'orange', 'grape', 'apple']

in可以检查列表是否包含某个值：

In [30]: 'orange' in b_listOut[30]: TrueIn [31]: 'orange' not in b_listOut[31]: False

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

2.串联和组合列表

与元组类似，可以用加号将两个列表合并。

已经定义一个列表后，用extend方法可以追加多个元素：

In [32]: x = ['a', 'b', 'c']In [33]: x.extend(['d', 'e', 'f'])In [34]: xOut[34]: ['a', 'b', 'c', 'd', 'e', 'f']

通过加法将列表组合的计算量较大，因为要新建列表，再复制对象

3.排序

sort函数可以将一个列表原地排序

In [35]: a = [7, 2, 5, 1, 3]In [36]: a.sort()In [37]: aOut[37]: [1, 2, 3, 5, 7]

sort函数括号中可以加排序关键字key，例如按长度对字符串进行排序：

In [38]: b = ['apple', 'orange', 'pie', 'lemon']In [39]: b.sort(key=len)In [40]: bOut[40]: ['pie', 'apple', 'lemon', 'orange']

sorted函数则可以产生一个排好序的副本

4.二分搜索

bisect模块支持二分查找和向已排序的列表插入值，bisect.bisect可以找到插入值后仍保持顺序的位置，bisect.insort会向这个位置插入值：

In [41]: import bisectIn [42]: c = [1, 2, 2, 2, 3, 4, 7]In [43]: bisect.bisect(c, 2)Out[43]: 4In [44]: bisect.bisect(c, 5)Out[44]: 6In [45]: bisect.insort(c, 6)In [46]: cOut[46]: [1, 2, 2, 2, 3, 4, 6, 7]

5.切片

切片可以选取序列的一部分，基本形式是：

sequence[start:end]

In [47]: seq = [7, 2, 3, 7, 5, 6, 0, 1]In [48]: seq[1:5]Out[48]: [2, 3, 7, 5]

切片可以被序列赋值：

In [49]: seq[3:4] = [6, 3]In [50]: seqOut[50]: [7, 2, 3, 6, 3, 5, 6, 0, 1]

切片的开始和结束可以省略：

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

负数的话可以从后往前开始：

In [53]: seq[-4:]Out[53]: [5, 6, 0, 1]In [54]: seq[-6:-2]Out[54]: [6, 3, 5, 6]

通过第二个冒号可以选择步伐：

In [55]: seq[::2]Out[55]: [7, 3, 3, 6, 1]

6.列表推导式

列表推导式允许用户从一个集合方便的过滤元素或者修改元素：

In [56]: strings = {'a', 'as', 'bat', 'car', 'dove'}In [57]: [x.upper() for x in strings if len(x) > 2]Out[57]: ['DOVE', 'BAT', 'CAR']

这个列表推导式等同于

strings = ['a', 'as', 'bat', 'car', 'dove']a = []for x in strings: if len(x) > 2:          a.append(x.upper())

字典

字典是键值对的可变集合，创建字典的方法之一是使用花括号，用冒号分隔键和值：

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

添加新的键值对：

In [58]: d1 = {'a':'some value', 'b':[1, 2, 3, 4]}In [59]: d1[7] = 'an integer'In [60]: d1Out[60]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

del和pop方法可以删除键值对：

In [63]: d1['dummy'] = 'another value'In [64]: d1Out[64]:{'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer', 5: 'some value', 'dummy': 'another value'}In [65]: del d1[5]In [66]: d1Out[66]:{'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer', 'dummy': 'another value'}In [67]: ret = d1.pop('dummy')In [68]: retOut[68]: 'another value'In [69]: d1Out[69]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

查看字典的键：

In [70]: list(d1.keys())Out[70]: ['a', 'b', 7]

查看字典的值：

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

update方法可以将两个字典融合：

In [72]: d1.update({'b':'foo', 'c':12})In [73]: d1Out[73]: {'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}

字典的键通常是不可变的标量类型(整数，浮点型，字符串)或元组，字典的值可以是任意类型

集合

集合是无序的不可重复的元素的集合。可以用set函数或花括号创建。

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

用union方法或|运算符对两个集合求并集：

In [76]: a = {1, 2, 3, 4, 5}In [77]: b = {3, 4, 5, 6, 7, 8}In [78]: a.union(b)Out[78]: {1, 2, 3, 4, 5, 6, 7, 8}In [79]: a | bOut[79]: {1, 2, 3, 4, 5, 6, 7, 8}

用intersection或&运算符对两个集合求交集：

In [80]: a.intersection(b)Out[80]: {3, 4, 5}In [81]: a & bOut[81]: {3, 4, 5}

下面这张表列出了常用的集合方法