容器，顾名思义是用来存放数据，并对容器内数据进行各种操作。

一、列表list

顺序表可以同时存放任意类型的数据,元素可改变:
默认list1 = [1, 2, 3, 4, 5, 6] 进行操作

(1)列表创建[]
list1 = [1, 2, 3, 4, 5, 6]
tuple1 = (1, 2, 3, 4, 5, 6)
list2 = list(tuple1)// 通过元组创建list

(2)访问list里的元素
list1[1] #访问列表里面的第一个元素 2
list1[1 : ] #返回[2, 3, 4, 5, 6]
list1[1 : 4] #返回[2, 3, 4]
list1[:] #返回元素的全部数据[1, 2, 3, 4, 5, 6]
list1[3 : -1] #[4, 5]

(3)增加元素
list1.append('7') #[1, 2, 3, 4, 5, 6, 7]
list1 + list1 # [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
list1 * 2 # [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

(4)删除元素
del list1[0] # [2, 3, 4, 5, 6] 操作原数组 无返回
list1.pop[] #默认删除最后一个元素，并返回删除的元素
list1.pop[1] #删除指定位置的元素，并返回删除的元素
list1.remove[1] # [2, 3, 4, 5, 6] 操作原数组 无返回

(5)更改元素
list1[0] = 'a' # [a, 2, 3, 4, 5, 6]

(6)查找元素
list1.index[1] #返回该元素的下标 0

(7)列表的其他操作
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始
list.insert(index, obj) 将对象插入列表
list.pop(index) 移除列表中的一个元素(默认最后一个元素)，并且返回该索引对应的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素，倒转
list.sort(cmp=None, key=None, reverse=False)
sort函数是序列的内部函数，原地排序，也就是使用后并不是返回一个有序的序列副本，而是把当前序列变得有序;
sorted函数是python的内建函数，他接受一个序列，返回有序的副本，与sort的唯一区别就是会返回副本。
cmp(list1, list2) 比较两个列表元素。
len(list1) 计算列表元素个数。
max(list1) 返回列表中元素最大值。
min(list1) 返回列表中元素最小值。
list(tuple) 将元组转换为列表。

二、元组Tpule

元组Tpule 和list类似, 只是元素不能改变
默认tuple1 = (1, 2, 3, 4, 5, 6) 进行操作

(1)列表创建[]
tuple1 = (1, 2, 3, 4, 5, 6) #(1, 2, 3, 4, 5, 6)

(2)访问tuple里的元素
tuple1[1] #访问列表里面的第一个元素 2
tuple1[1 : ] #返回(2, 3, 4, 5, 6)
tuple1[1 : 4] #返回(2, 3, 4)
tuple1[:] #返回元素的全部数据(1, 2, 3, 4, 5, 6)
tuple1[3 : -1] #(4, 5)

(3)查找元素
list1.index[1] #返回该元素的下标 0

(4)其他操作
tuple.count(obj) 统计某个元素在列表中出现的次数
tuple.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(list) 将列表转换为元组。
sorted函数是python的内建函数，他接受一个序列，返回有序的副本，与sort的唯一区别就是会返回副本。

三、set集合

没有顺序，就像是舍弃了值的字典。具有数学意义上的所有集合运算。

(1)如何创建集合？
a = set() #创建空集合
a = {1, 2, 3, 4} #创建非空集合
a = {} #创建空字典

(2)如何将其他结构转化为集合？
set("liu")
{'l', 'i', 'u'}
set([1, 2, 3])
{1, 2, 3}
set((1, 2, 3))
{1, 2, 3}
set({1:2, 3:4, 5:6})
{1, 3, 5}

(3)集合有哪些运算？
交集
a = {1, 2}
b = {2, 3}
a & b
{2}
a.intersection(b)
{2}
并集
a | b
{1, 2, 3}
a.union(b)
{1, 2, 3}
差集
a - b
{1}
a.difference(b)
{1}
异或集
a^b
{1, 3}
a.symmetric_difference(b)
{1, 3}
子集
a <= b
False
a.issubset(b)
False
超集
a >= b
False
a.issuperset(b)
False
真超集

四、字典

字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典由键和对应的值组成。字典也被称作关联数组或哈希表。

1、初始化字典
dict={'name' : 'didi', 'age' : 21}//method1
d = dict((('name','didi'),('age',21)))//method2:利用元组进行初始化
每个键与值必须用冒号隔开，每对用逗号分割，整体放在{}中。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。

2、访问字典里的值

print(dict['name'])
didi
print(dict['age'])
23

3、修改字典
dict["name"] = 'di di' #修改已有键的值
dict["age"] = 20 #增加新的键/值对
print(dict['name'])
'di di'
print dict['age']
20

4、清除字典数据
del dict['name']# 删除键是'di di'的条目
dict.clear()# 清空词典所有条目
del dict # 删除词典

5、字典内置函数&方法
(1) .cmp(dict1, dict2) 比较两个字典元素。
(2) .len(dict) 计算字典元素个数，即键的总数。
(3) .str(dict) 输出字典可打印的字符串表示。
(4) .type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
(5) .dict.clear() 删除字典内所有元素
(6) .dict.copy() 返回一个字典的浅复制
(7) .copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
(8) .copy.deepcopy 深拷贝 拷贝对象及其子对象
(9) .dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键,val为字典所有键对应的初始值
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("New Dictionary : %s" % str(dict))
New Dictionary : {'age': None, 'name': None, 'sex': None}
dict = dict.fromkeys(seq, 10)
print ("New Dictionary : %s" % str(dict))
New Dictionary : {'age': 10, 'name': 10, 'sex': 10}
(10) .dict.items() 以列表返回可遍历的(键, 值) 元组数组
(11) .dict.keys() 以列表返回一个字典所有的键
(12) .dict.values() 以列表返回字典中的所有值
(13) .dict.has_key(key) 如果键在字典dict里返回true，否则返回false
(14) .dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
(15) .dict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
(16) .dict.update(dict2) 把字典dict2的键/值对更新到dict里