容器(列表 & 元组 & 字典 & 集合)
序列
序列:
每个元素可以是任何类型(也可以是序列)，每个元素被分配一个序号(从0开始)（序号，也叫索引，表示元素的位置）
Python中的序列： 元组，列表，字符串，Unicode字符串，buffer对象，range对象
- 元组和列表的本质区别是：列表是可以修改的而元组则不能。
序列的基本操作：
索引(类似于数学中集合的元素)：返回序列中的元素
使用方法：$$序列[编号]$$
示例：
a=[1,2,3,4]
a[0]
1
a[-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)
2
extend方法
使用其他列表拓展原有列表，其他列表的元素被添加到原有列表的末尾：
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)
3
insert方法
在序列的某个位置插入一个元素：
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()
4
a.pop(0)
1
remove方法
移除序列中第一个与参数匹配的元素：
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')
False
set('Python') != set('python')
True
子集 & 超集
<,<=,>,>= 用来判断前面一个集合是否是后面一个集合的严格子集，子集，严格超集，超集
set('Hello') < set('HelloWorld')
True
set('Hello') <= set('Hello')
True
set('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')
c
frozenset({'H', 'P', 'e', 'h', 'l', 'n', 'o', 't', 'y'})