Data Structures and Sequences

从python中基础的数据结构开始：元组(tuple)、列表(list)、字典(dict)和集合(set)

Tuple

元组的长度固定，序列不可更多。可以将任何序列或是迭代器转换成元组。

即便元组存储的是可变对象，一旦元组被创建，可变对象也将变得不可修改。例如：

1 2	tup = tuple(['foo', [1, 2], True]) tup[2] = False

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-2-11b694945ab9> in <module>
      1 tup = tuple(['foo', [1, 2], True])
----> 2 tup[2] = False


TypeError: 'tuple' object does not support item assignment

但是如果tuple中的某个元素是可变对象，那么可以修改这个对象中的内容。例如：

1 2	tup[1].append(3) tup

('foo', [1, 2, 3], True)

Unpacking tuples

元组可以解包，即使是嵌套的元组：

1
2
3

tup=4,5,(6,7)
a,b,(c,d)=tup
d

python允许从元组的开头抓取几个元素，剩余舍去的元素存在rest中，例如：

1
2
3

values=1,2,3,4,5
a,b,*rest=values
rest

[3, 4, 5]

a,b

(1, 2)

可以看出，舍去的元素存储在列表中，抓取的元素存储在元组中

Tuple methods

鉴于元组的内容不可修改，一个特别有用的方法是count,用来计算某个value出现的次数。

1	a=(1,2,2,2,3,4,2)

1	a.count(2)

List

Adding and removing elements

插入方法有两种：append和insert，其中append在尾部插入而insert可以指定位置插入。

insert方法比起append需要花费更多的计算开销，因为任意位置插入需要移动后续的元素。

insert的逆运算是pop，它移除并返回指定位置的元素。还可以用remove来去除，它会去除寻找到的第一个值。

1	b_list=['foo','red','baz','dwarf']

1 2	b_list.append('foo') b_list

['foo', 'red', 'baz', 'dwarf', 'foo']

1 2	b_list.remove('foo') b_list

['red', 'baz', 'dwarf', 'foo']

Concatenating and combining lists

可以用+和extend的方法串联列表，+的计算开销较大，因为需要先创建一个新列表，再将需要串联的两个列表中的元素复制进去。而extend则是在后面追加。

Binary search and maintaining a sorted list

内置的bisect模块可以找到插入值的位置，这个值在该位置插入后不会影响排序

import bisect
c = [1, 2, 2, 2, 3, 4, 7]
bisect.bisect(c, 2)
bisect.bisect(c, 5)
bisect.insort(c, 6)
c

[1, 2, 2, 2, 3, 4, 6, 7]

需要注意的是，bisec不会去检测列表是否已经有序，因此如果对无序列表进行该操作会引发逻辑错误。

Slicing

切分后元素的个数可以用stop-start得到。

Bulid-in Sequence Functions

enumerate

enumerate枚举可以返回一个字典，其中的key-value对应列表中的元素位置和元素值。

1	some_list=['foo','bar','baz']

1	mapping={}

1 2	for i,v in enumerate(some_list): mapping[v]=i

mapping

{'foo': 0, 'bar': 1, 'baz': 2}

sorted

sorted函数排序任意序列的元素值并返回一个新的排序序列

1 2	test=[7,1,2,6,0,3,2] sorted(test)

[0, 1, 2, 2, 3, 6, 7]

1	print(test)

[7, 1, 2, 6, 0, 3, 2]

zip

zip可以将多个列表、元组或其它序列成对组合成一个元组列表：

seq1 = ['foo', 'bar', 'baz']
seq2 = ['one', 'two', 'three']
zipped = zip(seq1, seq2)
list(zipped)

[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

reversed

reversed 是一个生成器，只有实体化（即列表或for循环）之后才能创建翻转的序列。

dict

字典也叫哈希表，有key-value形式存储数据。

可以使用update方法将两个字典混合

1	d1={'a':'some value'}

1 2	d1.update({'b':'foo','c':12}) d1

{'a': 'some value', 'b': 'foo', 'c': 12}

Valid dict key types

字典的key通常是不可修改的对象，行话来说，就是“可哈希性”。你可以通过hash函数来检测是否对象可以被哈希（是否可以被用作key）

1	hash('string')

7186817693226238043

1	hash([1,2])# list是可修改的值，因此失败。

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-45-9ce67481a686> in <module>
----> 1 hash([1,2])


TypeError: unhashable type: 'list'

set

set是无序的不可重复的元素的集合。可以看成是只有key没有value的字典。通用可以有{}创建。

1	{2,2,1,2,3}

{1, 2, 3}

当且仅当集合内容相等是，集合相等

1	{1,2,3}=={3,2,1}

True

List,Set and Dict Comprehensions

列表、集合、字典推导式允许用户方便的从一个集合过滤元素，形成列表，在传递参数的过程中还可以修改元素。

1	[expr for val in collection if condition]

等同于for循环

result = []
for val in collection:
    if condition:
        result.append(expr)