容器(列表 & 元组 & 字典 & 集合)
序列
序列:
每个元素可以是任何类型(也可以是序列)，每个元素被分配一个序号(从0开始)（序号，也叫索引，表示元素的位置）Python中的序列： 元组，列表，字符串，Unicode字符串，buffer对象，range对象
- 元组和列表的本质区别是：列表是可以修改的而元组则不能。
序列的基本操作：
索引(类似于数学中集合的元素)：返回序列中的元素
使用方法：\[序列[编号]\]
示例：
a=[1,2,3,4]
a[0]1a[-2]3切片(类似数学中集合的子集)：返回子序列
使用方法：\[序列[开始编号:结束编号后一个:步长(默认为1)]\]
示例：
a=[1,2,3,4,5]
a[1:3][2, 3]a[1:-1][2, 3, 4]a[1:][2, 3, 4, 5]a[:-1][1, 2, 3, 4]a[:][1, 2, 3, 4, 5]序列加(同类型的序列的拼接)
类似于\[一篮苹果+一篮香蕉=两篮水果\]
使用方法：\[序列+序列\]
示例：
a=[1,2,3]
b=[2,3,4]a+b[1, 2, 3, 2, 3, 4]+ 不会改变原有的序列
a [1, 2, 3]序列乘
类似于\[一个苹果*n=n个苹果\]
使用方法：\[序列*n(n表示重复次数)\]
示例：
a=[1,2,3]
a*3[1, 2, 3, 1, 2, 3, 1, 2, 3]in(类似于某个元素是否属于某个集合的判断)
使用方法：
a in 序列A若\(a\in A\),则返回True，否则返回False。
len,max,min分别返回序列的长度，最大值，最小值
使用方法：
len(序列)
max(序列)
min(序列)列表
列表的修改
示例：
a=[1,2,3,4]a[0]=2
a[2, 2, 3, 4]a[1:3]=[5,6]
a[2, 5, 6, 4]a[1:3]=''
a[2, 4]a[0:0]=[99,88]
a[99, 88, 2, 4]a[1:3]=list('hello')
a[99, 'h', 'e', 'l', 'l', 'o', 4]del a[0]a['h', 'e', 'l', 'l', 'o', 4]del a[0:3]
a['l', 'o', 4]列表方法
调用对象的方法：\(对象.方法(参数)\)
append方法
可以在列表的末尾追加新的元素：
a=[1,2,3]
a.append(4)
a[1, 2, 3, 4]a.append([1,5,'fr'])
a[1, 2, 3, 4, [1, 5, 'fr']]count方法
查看某个元素在列表中出现的次数：
a=[1,2,3,4,1,2]
a.count(1)2extend方法
使用其他列表拓展原有列表，其他列表的元素被添加到原有列表的末尾：
a=[1,2,3]
a.extend([4,5,6])
a[1, 2, 3, 4, 5, 6]index方法
返回某个元素的索引，如若此元素不存在，则会引发异常。
a=[1,2,3,45,5,45,7,84]
a.index(45)3insert方法
在序列的某个位置插入一个元素：
a=[1,2,3,4]
a.insert(2,'hello')
a[1, 2, 'hello', 3, 4]a.insert(20,'world') #20号位置不存在，直接插到列表末尾
a[1, 2, 'hello', 3, 4, 'world']pop方法
移除列表某个位置的元素并返回该元素，如若没有指定要移除元素的位置，则默认移除末项。
a=[1,2,3,4]
a.pop()4a.pop(0)1remove方法
移除序列中第一个与参数匹配的元素：
a=[1,2,88,3,4,88,2]
a.remove(88)
a[1, 2, 3, 4, 88, 2]reverse方法
将列表改为倒序：
a=[1,2,3,4,2,5,3]
a.reverse()
a[3, 5, 2, 4, 3, 2, 1]sort方法
- 默认为升序：
a=[4,6,2,1,7,9,6]
a.sort()
a[1, 2, 4, 6, 6, 7, 9]-
参数:
key用来为每个元素提取比较值(默认值为None)； reverse为True时是反序(默认值为False)。
names=['Judy','Perter','Perkins']
names.sort(key=len)
names['Judy', 'Perter', 'Perkins']元组
"元组的不可修改"是指元组的每个元素指向永远不变：
b=('python','20150101',['a','b'])
b('python', '20150101', ['a', 'b'])b[2][0]='c'
b('python', '20150101', ['c', 'b'])b[2].append('d')
b('python', '20150101', ['c', 'b', 'd'])字典（dict/map）
形式：
{key:value,...}字典的创建
以例子说明：
d={'wang':'111','U':'123'}
d{'U': '123', 'wang': '111'}d1=dict([('A',1),('B',2)])
d1{'A': 1, 'B': 2}d2=dict(A=1,B=2)
d2{'A': 1, 'B': 2}d3=dict(d2)
d3{'A': 1, 'B': 2}字典的操作
（通过键）查找,修改
示例：
d={'wang':'111','U':'123'}
d['U']'123'd['wang']=111
d{'U': '123', 'wang': 111}删除：del语句
del 字典[键]len(字典)返回字典的项数
in（类似于序列的用法）
字典的方法
clear()
清除字典中所有的项
d={'wang':'111','U':'123'}
d.clear()
d{}复制copy()
浅复制，得到一个键的指向完全相同原字典的副本。
d={'wang':'111','U':[1,2,3,4]}
d1=d.copy()
d1{'U': [1, 2, 3, 4], 'wang': '111'}原地修改原字典d,相应的d1也会被修改,反之亦然。
d1['U'].append('lr')
d1{'U': [1, 2, 3, 4, 'lr'], 'wang': '111'}d{'U': [1, 2, 3, 4, 'lr'], 'wang': '111'}如果使用deepcopy()函数则可以避免上述情况发生。
d={'wang':'111','U':[1,2,3,4]}
from copy import deepcopy
d1=deepcopy(d)
d1{'U': [1, 2, 3, 4], 'wang': '111'}d1['U'].append('lr')
d1{'U': [1, 2, 3, 4, 'lr'], 'wang': '111'}d{'U': [1, 2, 3, 4], 'wang': '111'}get方法，查找元素
如若元素不存在，可以自定义返回的内容（默认为None）:
d={}
d.get('name')d['name']='Tom'
d{'name': 'Tom'}d.get('name')'Tom'd.get('phone','Unknown')'Unknown'setdefault方法，查找元素
与get方法不同的是，当键不存在时，自定义的值和该键会组成一个新项被加入字典。
d{'name': 'Tom'}d.setdefault('phone','119')'119'd{'name': 'Tom', 'phone': '119'}items(),keys(),values()均以列表的形式返回 a set-like object，其中的元素分别为"项"，"键"，"值"。
d={'wang':'111','U':[1,2,3,4]}d.items()dict_items([('wang', '111'), ('U', [1, 2, 3, 4])])d.keys()dict_keys(['wang', 'U'])d.values()dict_values(['111', [1, 2, 3, 4]])pop(键)返回键对应的值，并删除字典中这个键对应的项
d={'wang':'111','U':[1,2,3,4]}
d.pop('U')[1, 2, 3, 4]d{'wang': '111'}popitem()随机返回字典中的项，并从字典中m删除
d={'wang':'111','U':[1,2,3,4]}
d.popitem()('U', [1, 2, 3, 4])d{'wang': '111'}update 使用新字典更新旧字典
新字典中有而旧字典中没有的项会被加入到旧字典中；
新字典中有而旧字典中也有的值会被新字典的值所代替。
d1={'n':'xx','p':'110'}
d2={'p':'120','a':'A'}
d1.update(d2)d1{'a': 'A', 'n': 'xx', 'p': '120'}d2{'a': 'A', 'p': '120'}集合（类似于数学中集合的概念）
- set() 可变集合
- frozen() 不可变集合
集合的元素必须是不可变对象（如字符串，元组等）,且元素间有互异性。
set('Hello'){'H', 'e', 'l', 'o'}集合的基本操作
与序列一样拥有len(),min(),max()函数
add方法，添加元素
s=set(['Python','is','a','magic','language'])
print(s){'a', 'magic', 'Python', 'language', 'is'}s.add('!')
s{'!', 'Python', 'a', 'is', 'language', 'magic'}也支持更新（update）
a=set([1,2,3,4])
b=set([3,4,5,6])
a.update(b)
a{1, 2, 3, 4, 5, 6}- remove方法删除集合中元素
s=set('hello')
s{'e', 'h', 'l', 'o'}s.remove('h')s{'e', 'l', 'o'}使用remove方法，若元素不存在，则会引发错误，而discard则不会。
s.discard('om')集合的特殊操作
等价(==) & 不等价(!=)
set('Python') == set('python')Falseset('Python') != set('python')True子集 & 超集
<,<=,>,>= 用来判断前面一个集合是否是后面一个集合的严格子集，子集，严格超集，超集set('Hello') < set('HelloWorld')Trueset('Hello') <= set('Hello')Trueset('Hello') < set('Hello')False并(\(\bigcup\)) ：使用 |
set('Hello') | set('world'){'H', 'd', 'e', 'l', 'o', 'r', 'w'}交(\(\bigcap\))：使用 &
set('Hello') & set('world'){'l', 'o'}差(-) ：使用 -
set('Hello') - set('world'){'H', 'e'}对称差： 使用 ^
set([1,2,3,4])^set([3,4,5,6]){1, 2, 5, 6}Notes:
如是可变集合(set)与不可变集合(frozenset) 进行运算，得到的新集合的类型与左操作数相同。
对于可变集合(set)可以进行就地修改：操作符为：
|=,&=,-=,^=
a=set('Hello')
a |= set('Python')
a{'H', 'P', 'e', 'h', 'l', 'n', 'o', 't', 'y'}a=set('Hello')
a &= set('Python')
a{'o'}a=set('Hello')
a -= set('Python')
a{'H', 'e', 'l'}a=set('Hello')
a ^= set('Python')
a{'H', 'P', 'e', 'h', 'l', 'n', 't', 'y'}b=set('Hello')|frozenset('Python')
b{'H', 'P', 'e', 'h', 'l', 'n', 'o', 't', 'y'}c=frozenset('Python')|set('Hello')
cfrozenset({'H', 'P', 'e', 'h', 'l', 'n', 'o', 't', 'y'})
