今日内容总结：
列表的内置方法（包括count,clear,reverse,sort,队列及堆栈）
元祖及内置方法
字典及内置方法
集合及内置方法
字符编码
一. 元祖（tuple）
1. 用途：与列表类似，可以存多个值，但是元祖本身不能被修改。
# 当多个值没有修改的必要时，用元祖更合适
2. 定义方式：在()内用逗号分隔开多个任意类型的值，如：
t = (1,'a',('a','b'),[1,2]) print(type(t)) # <class 'tuple'>元祖类型
# 在定义容器类型时候，哪怕内部只有一个元素，也要用逗号隔开区分一下（重点）
3. 常用操作及内置方法：
①按索引取值（正向+反向）：只能取
print(t[1]) # a 正向取值 print(t[-1]) # [1, 2] 反向取值 print(t[-1][1]) # 2 先反向取值[1, 2]，后从中取出2 del t[0] # TypeError: 'tuple' object doesn't support item deletion 不支持删除，不可变。 # 因为元祖能存多个值，且能根据索引取值，还不支持删除、不可变，因此是不可变类型
②切片：（顾头不顾尾，步长）
t = (1,'a',('a','b'),[1,2]) print(t[::2]) # (1, ('a', 'b'))得到一个小元祖 # 从前到后索引取值，并以2位步长
③长度：(len)
t = (1,'a',('a','b'),[1,2]) print(len(t)) # 4 表明有四个元素在里面
④成员运算in和not in ：
t = (1,'a',('a','b'),[1,2])
print(1 in t) # True
⑤循环：基于for循环，如：
t = (1,'a',('a','b'),[1,2]) for i in t : print(i) # 结果为1/a/('a','b')/[1,2] # /代表下一行
二. 字典及内置方法
1. 用途：记录多个值，每个值有都对应的key来描述value的作用
2. 定义方式：在{}内用逗号隔开键值对（其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型）
ps：强调！！！在字典中，字典的key是不能重复的，只能标识唯一的一条数据；如果重复了，只会按照最后一组重复的键值对存储，如：
f = {'a':1,'a':2,'a':3}
print(f) # {'a': 3}可以看到只有最后一组被存储打印出来
3. 常用操作及内置方法：
①按key取值，且可存可取;
f = {'name':'张三','age':18}
print(id(f)) # 1948424105272 第一次地址
print(f['name']) # 张三 第一个键值对的值
f['name'] = '李四'
print(f['name']) # 李四 重新赋值后只存储赋值后的value
print(id(f)) # 2351757028664 value改变，对应的地址也改变了
f['hobby'] = 'read'
print(f['hobby']) # read 新增加一个赋值关系，会自动新增一个键值对
print(id(f)) # 1741138980152 新增键值对以后地址改变了
# 有上述操作可知，字典类型是可存可取id可变的
# 由于字典不能通过索引取值，所以是无序可变型的。
②长度：（len）：统计的是字典中键值对的个数
③成员运算：in 和not in ：对于字典来说只能判断key值，如：
f = {'name':'张三','age':18}
print('name' in f) # True
print('张三' in f) # False
# 表明in和not in只能判断key值是否在字典中，也印证了value不会暴露给用户的原则
④删除：
del（适用于任何形式）
f = {'name':'张三','age':18}
del f['name']
print(f) # {'age': 18} 同时删除key和value
f = {'name':'张三','age':18}
print(f.pop('name')) # 张三 返回的是弹出的value
print(f.pop('hobby')) #KeyError: 'hobby' 当key不存在时直接报错
print(f.popitem()) # ('age', 18) 从后弹，返回的是弹出的键值对
⑤keys() , values() , items()
f = {'name':'张三','age':18}
print(f.keys()) # dict_keys(['name', 'age']) # 取出所有的key，但是不全部给你展示出来，你需求多少就给你多少
print(f.values()) # dict_values(['张三', 18]) # 取出所有的value，但是不全部给你展示出来，你需求多少就给你多少
print(f.items()) 3 dict_items([('name', '张三'), ('age', 18)]) # 取出所有的键值对....................
ps：在python2中，keys() , values() , items()命令后取出的全部给你展示出来，占用内存，而在python3中优化了，需要多少就给你展示多少。
get()*****************：根据key获取value：
f = {'name':'张三','age':18}
print(f.get('name')) # 张三 字典中key存在时，获取value
print(f.get('hobby')) # None 字典中key不存在时，并不会报错，返回None
print(f.get('hobby','read')) # read # 当字典中key不存在时，返回的是你写好的参数
# get可以传第二个参数；key不存在时，第二个参数不写的话，返回None，写了返回写的内容
⑥fromkeys()：快速创建一个字典：
f = ['name','张三','age',18] r = {} # 需要先定义类型为字典类型 print(r.fromkeys(f)) # {'name': None, '张三': None, 'age': None, 18: None} 将列表个个元素当做key快速生成字典，默认value为None print(r.fromkeys(f,12)) # {'name': 12, '张三': 12, 'age': 12, 18: 12} 将列表个个元素当做key，并将括号内的内容当做value
ps：快速生成一个字典的方式还有以下两种：
1）
f= dict(a=1,b=2,c=3) # 先转化为字典类型，且括号内具有绑定关系 print(f) # {'a': 1, 'b': 2, 'c': 3} 直接生成一一对应的字典类型
2）
f = [['a',1],['b',2]] n = dict(f) # 先把列表转化为字典类型 print(n) # {'a': 1, 'b': 2} # 生成一一对应的键值对，字典
⑦popitem()：尾部以元元祖的形式弹出键值对：
f = {'name':'张三','age':18}
print(f.popitem()) # ('age', 18) 从后往前弹出，返回的是键值对
⑧setdefault()：
f = {'name':'张三','age':18}
print(f.setdefault('name')) # 张三 正常取值
print(f.setdefault('name','你谁啊？')) # 当key存在时，不修改值，返回的是原value
print(f.setdefault('hobby','read')) # 当key不存在时，新增一个键值对，并返回自己定义的value
⑨update()：原来有一个字典，然后再进行update操作：
f = {'name':'张三','age':18}
n = {'hobby':'read'}
f.update(n) # 先进行update操作
print(f) # {'name': '张三', 'age': 18, 'hobby': 'read'} 字典与字典合在一起
f.update(gender = 'male') # 先进行update操作
print(f) # {'name': '张三', 'age': 18, 'hobby': 'read', 'gender': 'male'} 字典与变量合在一起
⑩循环：也是基于for循环：得到的是key
三. 集合及内置方法：群体之间作比较，不涉及单个元素
一般情况下不适用集合，只有一下两种情况采用到：1）关系运算；2）去重 （同时也是集合的作用）
1. 定义:包含多个元素，元素与元素之间用逗号隔开
2. 格式：
f = {1,2,3,4,5} # 实质上相当于f = set()
print(type(f)) # <class 'set'>
注意：在定义空集合的时候只能用关键字set，如：s = set()
如果仅仅写了一个{}，则默认为字典类型，如：
d = {} print(type(d)) # <class 'dict'>
ps：集合的元素遵循三个原则：
1）每个元素都是不可变类型。假如集合的元素中有列表、字典等可变类型，那么在print时候会报错。
2）没有重复的元素。假如集合里面有重复的元素，在print的时候会自动将重复的元素去除。
3）无序。不能根据索引取值，所以是无序的。
因此集合也是不可变类型；到目前为止，所学到的全部数据类型可分为可变及不可变两大类型：
可变类型：list（列表），dict（字典），set（集合）；
不可变类型：int（整型），float（浮点型），str（字符串），tuple（元祖）以及bool（布尔值）
3. 内置方法：
①长度(len)
②成员运算in和not in
③合集（|表示）：
x = {1,2,3,4,5,6,7,8}
y = {6,7,8,9,10,11,12}
print(x | y) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
④交集（&表示）：
x = {1,2,3,4,5,6,7,8}
y = {6,7,8,9,10,11,12}
print（x & y ) # {8, 6, 7}
⑤差集（-）：
x = {1,2,3,4,5,6,7,8}
y = {6,7,8,9,10,11,12}
print(x - y) # {1, 2, 3, 4, 5}
⑥对称差集（^）：
x = {1,2,3,4,5,6,7,8}
y = {6,7,8,9,10,11,12}
print(x ^ y) # {1, 2, 3, 4, 5, 9, 10, 11, 12}
⑦ = ：能证明集合是无序的：
x = {1,2,3,4,5,6,7,8}
y = {2,5,6,7,8,4,1,3}
print(x == y) # True
⑧父集（>,>=）：
x = {1,2,3,4,5,6,7,8}
y = {1,2,3,4}
print(x >= y) # True 表示x包含y
⑨子集（<,<=）：
x = {1,2,3,4,5}
y = {1,2,3,4,5,6,7,8}
print(x <= y) # True 表示x在y里面
⑩add：注意：将容器类型也当成一个元素传入
需要注意的问题：一般只有当需要进行关系运算以及去重的时候才会用到集合，同时集合也有一些局限性，如无法保证原数据类型的顺序，且只有当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重