List#

>>> L = [1,3,4,5]
>>> L = [1,'string',6.5,[1,2],True] # List中也可以类型不同

List 集合操作

List method that modify the list：

list.append(object)
list.extend(list2)
list.pop()
list.remove(object)
list.reverse()
list.sort()
list.insert(int,object)

l = [1,2,3]
l = l + [4,5]
>>> [1,2,3,4,5]

List method that do not modify the list:：

list.count(object)
list.index(object)

Stack(使用List)

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

Queue

使用from collections import deque

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

嵌套列表解析###

一个矩阵3*4的矩阵

>>> matrix = [
 [1, 2, 3, 4],
 [5, 6, 7, 8],
 [9, 10, 11, 12],
 ]

转置行列：

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

等价于：

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

最好的选择：

>>> zip(*matrix)
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

del操作###

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

---

tuple#

有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改。例如：

classmates = ('Michael', 'Bob', 'Tracy')

现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple陷阱 你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来。
但是，要定义一个只有1个元素的tuple，如果你这么定义:

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

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

t=(1,)
t
(1,)

可以这样对tuple赋值：

t = 12345, 54321, 'hello!'

>>> empty = () #空tuple
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

对于tuple里面的值可以进行获取如下：

>>> t = 12345, 54321, 'hello!'
>>> x,y,z=t # x=12345, y=54321,z='hello'

---

dic 和 set#

dict##

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list。给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

注意是花括号{key1:value1,key2:value2....}

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael']
95

key不存在就会报错，先判断key是否在dic中：

1. key in dic
2. d.get(key) 判断是否为None
3. d.has_key(key) 判断 True or False

dic中添加一个key-value：

dic.setdefault('Norman'，100)

或者

dic['Norman'] = 100

dic中删除一个key

dic.pop(key) 

或者

del dic[key]

dic获取keys

dic.keys()

dict表达式初始化

>>> {X:X**2 for x in (2,4,6)}
{2:4,4:16,6:36}

dict 构造函数

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

如果keys是string可以用如下构造函数：

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

zip()
zip函数返回一个tuple的list，可以将多个list相应位置的元素形成tuple，并且可以在参数前加*，可以实现unzip list功能。例如：

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> zipped
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zipped)
>>> x == list(x2) and y == list(y2)
True

遍历dict获取K-V
使用 dict.iteritems() 例如：

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

或者使用:

>>> for key in dic.keys():
        print key, dic[key] #print key, dic.get(key)

Set##

Set中内容无重复，声明一个空的set：set()
一些测试代码：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)               # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                 # fast membership testing
True
>>> 'crabgrass' in fruit
False

>>> # Demonstrate set operations on unique letters 
>from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
set(['a', 'r', 'b', 'c', 'd'])
>>> a - b                              # letters in a but not in b 差集
set(['r', 'd', 'b'])
>>> a | b                              # letters in either a or b 并集
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                              # letters in both a and b 交集
set(['a', 'c'])
>>> a ^ b                              # letters in a or b but not both 对称差分
set(['r', 'd', 'b', 'm', 'z', 'l'])

类似列表推导，Set使用{}：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
set(['r', 'd'])

set(list1) | set(list2)union包含 list1 和 list2 所有数据的新集合

set(list1) & set(list2)intersection包含 list1 和 list2 中共同元素的新集合

set(list1) – set(list2)difference在 list1 中出现但不在 list2 中出现的元素的集合