1、容器：
- list 列表或数组
- 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
- 列表的数据项不需要具有相同的类型
- tuple 元组（只读列表）
- dict 字典
- 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。
- set 集合
- 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算。
2、list列表：
（1）类型：
li = [1, 2, 3, '456', [1, 2, 3], {1: 'one', 2: 'two'}]
print(type(list)) #<class 'type'>
print(type(li)) #<class 'list'>
（2）负数索引：
# 元素访问 print(li[0]) print(li[-1]) # 相当于li[len(li) - 1],倒数第1个，也就是最后一个元素 print(li[-2]) # li[len(li) - 2]
（3）查找元素位置：
# 查找元素位置
print(li.index('456')) #查找456的位置，返回一个数值
print(li.index([1, 2, 3]))
print(li.index(-1)) #找不到，会抛出错误，如果不确定是否有这个元素，要用try/catch来捕获异常
（4）添加元素：
# 添加元素 l_a = [1, 2, 3] l_a.append(4) #添加元素 l_a.append(5) l_b = [6, 7, 8] l_a.extend(l_b) # 添加列表 print(l_a) #显示1,2,3,4,5,6,7,8
（5）删除元素：
del(li[-1]) # del(list[index])，删除最后一个元素 del(li[1]) #删除第一个元素 del(li[-2]) #删除倒数第二个元素，这里的删除是在上面的基础删 print(li)
（6）判断容器是否为空
#判断容器是否为空
l_a = []
if not l_a:
print('Empty') # not XX（分配了空间，但是里面没有元素 ）和 is None（什么都没有）不是一回事
if len(l_a) == 0: #根据长度也可以判断是否为空
print('Empty')
（7）遍历列表：
for i in li: #第一种方法
print(i)
for i in range(len(li)): #第二种方法
print(li[i])
（8）创建矩阵：
#第一种方法，2行3列矩阵
matrix = [None]*2 #显示结果为[none,none]表示没有指定，这里2表示行数，不能用0，否则下面就没法定义了
for i in range(len(matrix)):
print(i) #i的变化是0,1；这个是没有必要写的
matrix[i] = [0]*3 #每次循环都会将一个none取代为[0,0,0]
print(matrix) #显示结果为[[0,0,0],[0,0,0]]
#第二种方法，利用list comprehension方法，但是会产生浅拷贝问题
n = 2 m = 3 matrix = [[0]*m for i in range(n)] #这种方法更简单，一行命令创建n行m列矩阵 print(matrix) #显示结果 matrix[0][0] = 1 #索引从0开始 print(matrix)
#矩阵赋值问题：
for i in range(n): #对应列表中第几个元素，而这个元素是一个list
for j in range(m): #对应第n个元素中的第m个值
matrix[i][j] = [1] * k #看起来挺简单
print(matrix)
3、tuple元组（只读，不能更改里面的属性）
t = (1, 2, 3, '456') #元组是小括号，列表时中括号
print(type(t)) #显示类型：<class "tuple">
# t[0] = 'a' #因为不能更改值，所以这个会报错
# t.append('x') #因为不能更改值，所以这个会报错
（1）元组与列表转换没有函数，只能通过赋值，一个个的进行复值转换
（2）return 1,2 这个语句返回的结果是一个元组：[ 1, 2 ]
4、dict字典（dictionary）
（1）
#key-value格式，无序，只能根据key来查找，不能用索引
d = {'a': 1, 'b': 2, 1: 'one', 2: 'two', 3: [1, 2, 3]}
print(type(dict)) #<class 'type'>
print(type(d)) #<class 'dict'>
print(d) #
- 对key做了索引，通过key查找，时间复杂度为O(1)
- 一个key可以对应多个值，可以用数组表示
- key可以是不同的类型，比如上面有的是数字，有的是字符串
- 内部是一个哈希表，没有顺序
（2）访问元素：
# 访问元素 print(d['a']) #根据键值来访问 print(d[1]) #根据键值来访问 print(d[3]) #这里的3是键值，不是索引
（3）
# 判断key是否存在，而不能判断values是否存在
print('two' in d)
print(3 in d)
（4）删除
del
(d[
3
])
# del(dict[key])
（5）长度
print
(
len
(d))
d[
3
] = [
1
,
2
,
3
,
4
]
d[
3
] =
'1234'
（6）遍历（两种方法）
# 遍历
for key in d: #第一种方法，根据key来遍历
print(d[key])
print('...')
for k, v in d.items(): #根据key-value遍历
print(k, v)
print('...')
（7）得到key值
keys = d.keys() #得到字典的key值 print(type(keys)) print(keys) #输出所有的key值
5、set集合：
（1）类型
s_a = set([1, 2, 2, 3, 4, 5, 6]) #set初始化 s_b = set([4, 5, 6, 7, 8, 9]) print(s_a) #set是无序且无重复的，而且会自动删除重复元素 print(s_b)
（2）判断元素是否存在
# 判断元素是否存在 print(5 in s_a) print(10 in s_b)
（3）求并集
# 并集 print(s_a | s_b) #第一种方法 print(s_a.union(s_b)) #第二种方法
（4）交集
# 交集 print(s_a & s_b) print(s_a.intersection(s_b))
（5）差集
# 差集 A - (A & B) print(s_a - s_b) print(s_a.difference(s_b))
（6）对称差
# 对称差 (A | B) - (A & B) print(s_a ^ s_b) print(s_a.symmetric_difference(s_b))
（7）修改元素
# 修改元素
s_a.add('x') #添加元素
s_a.update([4, 5, 60, 70]) #进行添加
print(s_a)
s_a.remove(70) #删除元素，没有索引，没有key，只能根据值删除
print(s_a)
# s_a.remove(100) #如果没有，则会报错
print(len(s_a))
for i in s_a:
print(i)