学习Python Doc第四天:数据结构

首先 list 数据类型提供了很多方法，我们把这些方法列举如下：

list.remove(x) 删除 list 中第一个值为 x 的元素。在移除的过程中必须给定 x 。 使用 del 语句可以不用给定 x 只用给定索引号就删除指定位置的元素。

In [736]: a = [1,2,3,4,5,6,7]

In [758]: del a[0]

In [770]: a
Out[770]:
[2, 3, 4, 5, 6, 7]

In [771]: del a[5]

In [787]: a
Out[787]:
[2, 3, 4, 5, 6]

In [788]: del a[2]

In [792]: a
Out[792]:
[2, 3, 5, 6]

del 也可以用来删除一个变量

del a

list 和 strings 是两个 sequence 类型的数据类型。由于 Python 是一个不断演进的语言， tuple 是新加入的 sequence 成员。一个 tuple 的成员用逗号隔开，看例子：

In [793]: t = 12345, 54321, 'hello!'

In [821]: t[0]
Out[828]:
12345

In [829]: t[2]
Out[832]:
'hello!'

In [833]: t
Out[837]:
(12345, 54321, 'hello!')

In [838]: u = t,(1,3,4)

In [854]: u
Out[854]:
((12345, 54321, 'hello!'), (1, 3, 4))

In [855]: t[0]
Out[863]:
12345

In [864]: t[0] = 8888
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-871-7f2f230bad03> in <module>()
----> 1 t[0] = 8888

TypeError: 'tuple' object does not support item assignment

In [872]: v = ([1,2,3],[4,5,6])

In [887]: v
Out[887]:
([1, 2, 3], [4, 5, 6])

从上面例子可以看出， tuple 的输出总是有括号包括。不可以给 tuple 中单个元素赋值。

尽管 tuple 和 list 有很多相似之处，但是他们经常在不同的场合使用。 tuple 是不可修改的。通常 tuple 包含不同种类的成员。 list 的成员则通常是相同类型的并可以通过迭代读写。

在创建另个或者一个元素的 tuple 时，有一些简单的技巧。

In [888]: empty = ()

In [903]: singleton = 'hello', # note the trailing comma

In [920]: len(empty)
Out[920]:
0

In [921]: len(singleton)
Out[933]:
1

In [934]: singleton
Out[942]:
('hello',)

Python 还有一个数据类型 set . 一个 set 是一组无重复元素的集合。 set 支持数学概念上的 并 交 差 对称差 . 通常用花括号和 set() 来创建 set

In [943]: basket = {'apple','orange','apple','pear','orange','banana'}

In [989]: print(basket)
{'banana', 'orange', 'pear', 'apple'}

可以看出 set 自动删除集合中的重复元素。

In [997]: 'orange' in basket #fast membership testing
Out[1027]:
True

In [1028]: 'crabgrass' in basket
Out[1052]:
False

可以快速的进行成员验证。

In [1053]: a = set('abracadabra')

In [1066]: b = set('alacazam')

In [1078]: a
Out[1078]:
{'a', 'b', 'c', 'd', 'r'}

In [1079]: b
Out[1083]:
{'a', 'c', 'l', 'm', 'z'}

In [1084]: a-b # letters in a but not in b
Out[1091]:
{'b', 'd', 'r'}

In [1092]: a | b #letters in either a or b
Out[1099]:
{'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'}

In [1100]: a + b #do not support +
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-1100-f96fb8f649b6> in <module>()
----> 1 a + b

TypeError: unsupported operand type(s) for +: 'set' and 'set'

In [1101]: a & b #letter in both a and b
Out[1108]:
{'a', 'c'}

In [1109]: a ^ b #letters in a or b nut not both
Out[1120]:
{'b', 'd', 'l', 'm', 'r', 'z'}

Python 除了支持列表推导式外，也支持集合推导式。

In [1121]: a = {x for x in 'abracadabra' if x not in 'abc'}

In [1146]: a
Out[1146]:
{'d', 'r'}

dictionary 是 Python 支持的又一数据类型，这个数据类型不是序列类型，而是映射类型(mapping types)。 序列类型（ list tuple set ）通过数字来索引元素， 映射类型的数据通过 关键字 (key)来索引元素。字符创和数字可以当做 key 来使用。如果 tuple 的成员都是 字符创，数字或者 tuple ，那么 tuple 也可以用来当做 key . 不能用 list 来当做 key ，因为 list 能够被修改。

通常，我们可以想象字典是一系列没有排序的 key:value 对，其中 key 在一个字典中是唯一的。 {} 创建空的字典。在字典中我们经常用的操作是按照某个 key 保存一个 value 或者，根据某个 key 读取 value 。同样，我们可以使用 del 来删除 key:value 。如果新存入的 key 和原来重复，那么原来的 key 对应的 value 就会被覆盖。如果试图从字典中读取某个不存在的 key 对应的 value 那么报错。

对一个字典执行 list(d.keys()) 操作，返回这个字典使用的所有 key ,返回的 list 是无序的，如果你需要返回结果有序，那么使用 sorted(d.keys()) . 使用 in 进行成员关系测试。看代码：

In [1147]: tel = {'jack':4098, 'sape':4139}

In [1186]: tel['guido'] = 4127

In [1198]: tel
Out[1198]:
{'guido': 4127, 'jack': 4098, 'sape': 4139}

In [1199]: tel['jack']
Out[1211]:
4098

In [1212]: del tel['sape']

In [1224]: tel['irv'] = 4127

In [1251]: tel
Out[1255]:
{'guido': 4127, 'irv': 4127, 'jack': 4098}

In [1256]: list(tel.keys())
Out[1276]:
['jack', 'irv', 'guido']

In [1277]: sorted(tel.keys())
Out[1284]:
['guido', 'irv', 'jack']

In [1285]: 'guido' in tel
Out[1293]:
True

In [1294]: 'jack' not in tel
Out[1300]:
False

可以使用 dict() 函数创建字典，看代码：

In [1301]: dict([('sape',4139),('guido',4127),('jack',4098)])
Out[1354]:
{'guido': 4127, 'jack': 4098, 'sape': 4139}

当然，字典也支持字典推导式，看代码：

In [1355]: {x:x**2 for x in (2,4,6)}
Out[1377]:
{2: 4, 4: 16, 6: 36}

当 key 是简单的字符创时，使用 dict() 来构建字典更容易，看代码：

In [1378]: dict(sape=4139,guido=4127,jack=4098)
Out[1433]:
{'guido': 4127, 'jack': 4098, 'sape': 4139}

当在字典中使用循环的时候，可以使用 item() 来获取 key:value 。

knights = {'gallahad':'the pure','robin':'the brave'}
for k,v in knights.items():
    print(k,v)

在我的环境中输出是：

In [1435]: robin the brave
gallahad the pure

不知道为什么先输出了第二个 key:value ，难道输出是乱序的么？

当循环对象是序列类型的数据类型时，可以使用 enumerate() 来生成索引和该索引对应的值：

for i,v in enumerate(['tic','tac','toe']):
    print(i,v)

输出为：

In [1436]: 0 tic
1 tac
2 toe

在两个或者多个序列（ sequence ） 中执行循环，可以使用 zip() 实现。

questions = ['name','quest','favorite color']
answers = ['lancelot','the holy grail','blue']
for q,a in zip(questions,answers):
    print('what is your {0} It is {1}.'.format(q,a))

输出为：

In [1437]: what is your name It is lancelot.
what is your quest It is the holy grail.
what is your favorite color It is blue.

其中 list(zip(questions,answers)) 的结果是：

In [1438]: list(zip(questions,answers))
Out[1456]:
[('name', 'lancelot'), ('quest', 'the holy grail'), ('favorite color', 'blue')]

如果要对一个 sequence 类型的数据进行逆向循环时，使用 reversed() 函数。

for i in reversed(range(1,10,2)):
    print(i)

输出是：

In [1457]: 9
7
5
3
1