元祖：
元组跟列表差不多，也是存一组数，只是它一旦创建，便不能再修改，所以又叫只读列表。
创建：
names = ('neo', 'mike', 'eric')
特性：
# 1.可存放多个值 # 2. 不可变。 元祖本身不可变，但，如果元祖中还包含其他可变元素，这些可变元素还可以改变。 # 3. 按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序
功能：
1. index 2. count 3. slice（切片）
改变可变元素示例：
n = ( 1,2,5,8,[ 'a', 'b'], 9) n[4][2] = 'B' # 则n就变成了 (1,2,5,8,[ 'a', 'B'], 9)
使用场景：
1. 显示的告知别人，此处数据不可修改
2. 数据连接配置信息等
Hash：
hash，被叫做“散列”或者“哈希”，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。 这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一地确定输入值。简单来说，就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
特征：
hash值的计算过程是依据这个值的一些特征计算的，这就要求被hash的值必须固定，因此被hash的值必须是不可变的
不可变类型：数字、字符串、元祖 可变类型： 列表、字典 语法： hash（'abc'）
用途：
文件签名、
md5加密（密码明文变密文，md5的特性是无法反解）
密码验证
字典：
字典是一种key - value的数据类型，通过前面的key能够找出后面的value。
创建：
｛key1:value1,key2:value2｝ 1、键与值用冒号“:”分开； 2、项与项用逗号“,”分开； 3. key的值不能重复
查询字典的某条信息：
info[key值]
修改字典某条信息：
dic = { 'neo': ['a','b','c'], 'alex': [ 'c', 'm','n']}
dic['neo'][1] = 'B'
# 则字典dic就变成了 {'neo': ['a', 'B', 'c'], 'alex': ['c', 'm', 'n']}
特性：
1. key-value结构 2. key必须可hash，必须为不可变数据类型、必须唯一 3. 可以存放任意多个值，值可以修改，可以不唯一 4. 无序 5. 查找速度快
key必须可hash和查找速度快：计算机需要先利用hash把key值转化成一个数字，然后再利用“折半查找”（二分查找，算法的一种）的方式去找key的hash值，查询次数大概是2的n次方。（字典不是利用二分法）
字典添加：
dic[ key ] = value #value可以是任意类型 info = {'student1': ' Tenglan Wu', 'student2': 'Cangjingkou', 'student3': 'Jiatengying'} info[ ' student4' ] = 'abc' # 则字典info变成： {'student1': ' Tenglan Wu', 'student2': 'Cangjingkou', 'student3': 'Jiatengying', ' student4': 'abc'}
修改：
info[student2] = '苍井空' # 字典info变成： {'student1': ' Tenglan Wu', 'student2': 'Cangjingkou', 'student3': 'Jiatengying', ' student2': '苍井空'} #添加的顺序是随机的，因为字典的无序性。
查找：
# 1. 标准用法： 'student2' in info # in是新的语法，用于判断字典info里面是否有'student2'这个key值，输出" True" 或者" False "。 # 如： if 'student2' in info: # 如果student2是info的key值 # 2. 获取用法1： info.get('student2') # 如果有该键值则获取键值对应的value， 如果没有则输出None；推荐使用这种 # 3. 获取用法2： info['student2'] # 有该键值则获取该键值，没有则会报错。 所以通常使用 info.get()
删除：
# 方式1： info.pop(键值) #删除该键值及其对应的值，并将其返回。# Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. # 方式2： info.popitem() # 随机删除字典里的某个元素 # 方式3： del info[ 键值 ]
修改：
字典多层嵌套修改：
方法： 多层嵌套就是找到一级之后，再一层一层往下找，一个key一个key往下找。
其他方法：
info.clear() # 清空字典 info.copy() # 跟列表的copy一模一样 info.keys() # 获取所有的key值,放到一个列表里面 info.values() # 获取所有的value，放到一个列表里面 info.items() #是把info所有的key和value放到一个小元祖里面。 # 例： info.items() 为 dict_items([('student1', ' Tenglan Wu'), ('student2', 'Cangjingkou'), ('student3', 'Jiatengying')]) #把这些元祖再放到一个列表里面 dic1.update(dic2) #效果类似于列表里面list1.extend(list2)。 把dic2和dic1合并起来， 如果dic2和dic1有重复的key值， 就用dic2 key值所对应的value 覆盖 dic1 key值所对应的value，也就是所谓的update（更新）。 # 注：列表里的list1.extend( list2) 的效果 类似于 list1 += list2 info.setdefault( key1, value1) # 如果key这个键值在info字典里面本来就存在，那么info没有变化； 如果key这个键值在info里面不存在， 就把键值为key1、value值为value1的元素添加到字典info里面 info.fromkeys( ['key1', 'key2', 'key3'] , value1] # 批量往info字典里面添加“键值为key1，value值为value1”、“键值为key2，value值为value1”和“键值为key3，value值为value1”的元素， 如果不输入“ ,value ” ， 则往info里面就只添加了键值分别为key1、 key2和 key3但value值为None的元素。 """ classmethod fromkeys(seq[, value]) Create a new dictionary with keys from seq and values set to value. fromkeys()is a class method that returns a new dictionary. value defaults to None. """
dict.fromkeys 的用法：https://zhuanlan.zhihu.com/p/38440589
字典的循环：
for k in info: print(k) # 注意： 打印的只是键值key。 只是键值在循环。 for k in info: print( k, info[k] ) # 这种方式能把键值、value值都打印出来
集合类型：
示例：
iphone7 = [ 'alex', 'rain', 'jack', 'old_driver' ] iphone8 = [ 'alex', 'shanshan', 'jack', 'old_boy' ] 如何找出同时买了iPhone7和8的人 ？
常规做法： 循环列表iphone7里面的人， 然后判断7里面的人是否在 iphone8里面 （交集）
iphone7 = [ 'alex', 'rain', 'jack', 'old_driver' ] iphone8 = [ 'alex', 'shanshan', 'jack', 'old_boy' ] #定义一个空列表：同时买了7和8的人 both_list = [ ] #循环7里面的人，一个个判断这些人是否也在8里面，在的话就添加到both_list for name in iphone7: if name in iphone8: #if ...in.. 语法 both_list.append(name) print(both_list)
#打印结果：
['alex', 'jack']
找出只买了iPhone7的人？ （差集）
iphone7 = [ 'alex', 'rain', 'jack', 'old_driver' ] iphone8 = [ 'alex', 'shanshan', 'jack', 'old_boy' ] only7 = [ ] for name in iphone7: if name not in iphone8: #if...not in...语法 only7.append(name) print(only7) #打印结果： ['rain', 'old_driver']
集合定义：
集合是一个无序的、不重复的数据组合，它的作用如下：
# 集合作用： 1. 去重，把一个列表变成集合，就自动去重了； 2. 关系测试，测试两组数据之间的交集、并集、差集等关系。
语法：
s = {1,2,3,4,'a','b'} #中间没有冒号（：）
# 空集合的类型是“字典”， 但按照集合的语法定义后，类型就是“集合”了 。
假如我定义了如下集合：
s = { 1, 2, 2, 2, 2, 3}
它会自动变成 s = { 1, 2, 3 }
列表（元祖也可以转）转成集合：
set( list) # 如： list1 = [ 1,2,3] # set(list1) 就成了 { 1, 2, 3 }
添加：
s.add(元素) # 如果添加的元素原集合中已存在，就添加不进去。 # 只能添加一个元素
删除：
s.pop( ) # 随机删除集合元素 s.remove( 元素 ) #删除该元素， 如果该元素不存在则会报错 s.discard(元素） #删除该元素， 如果该元素不存在也不会报错
合并：
s1.update( s2) # 表面上看是s1和s2的合并， 其实是把s2 update到s1中， 所以最后的结果是： s2不变， 但s1变成了s2和原先s1的合并。效果类似于 s1 += s2 # 也可以利用 s.update() 往集合里面添加列表， 如： s1 = { 1,2,3, 'a'} s1.update( ['A','B','C' ] ) # s1就变成了 ： {1, 2, 3, 'A', 'C', 'B', 'a'} #利用这种方式可以向集合里面批量 添加元素
清空：
s.clear( ) # 清空
判断集合关系：
交集：
# 交集1： s1.intersection( s2 ) # 并集2： s1 & s2
如上面的同时买了iPhone7和8的人：
iphone7 = [ 'alex', 'rain', 'jack', 'old_driver' ] iphone8 = [ 'alex', 'shanshan', 'jack', 'neo' ] print(set(iphone7).intersection(set(iphone8)))
# 或者 print( iphone7 & iphone8 )
#输出结果： {'jack', 'alex'}
差集：
# 差集1： s1.difference(s2) # s1对s2的差集 #s1和s2的位置不能互换 # 差集2： s1 - s2 # s1对s2的差集
如上面只买了iphone7的人：
iphone7 = {'alex', 'rain', 'jack', 'old_driver' }
iphone8 = { 'alex', 'shanshan', 'jack', 'neo' }
print(set(iphone7).difference(set(iphone8)))
# 或者 print(iphone7 - iphone8)
#输出结果： {'old_driver', 'rain'}
并集：
# 并集1： s1.union( s2 ) #会自动去重 # 并集2: s1 | s2
示例：
iphone7 = {'alex', 'rain', 'jack', 'old_driver' }
iphone8 = { 'alex', 'shanshan', 'jack', 'neo' }
print(set(iphone8).union(set(iphone7)))
#输出结果：
{'old_driver', 'neo', 'shanshan', 'jack', 'rain', 'alex'}
对称差集：
s1.symmetric_difference( s2 ) # 相当于s1和s2的并集 减去 s1和s2的交集 #s1和s2的位置互换不会影响最后结果
如： 只购买了 iphone7和iphone8中 一个型号的人 ：
iphone7 = {'alex', 'rain', 'jack', 'old_driver' }
iphone8 = { 'alex', 'shanshan', 'jack', 'neo' }
print(set(iphone7).symmetric_difference(set(iphone8)))
#输出结果为：{'neo', 'shanshan', 'rain', 'old_driver'}
子集关系：
# 子集1： s1.issubset( s2 ) #判断s1是否为s2的子集， # 子集2： s1<=s2;
超集（父集）：
# 超集1： s1.issuperset( s2 ) # 判断s1是否为s2的超集（父集） # 超集2： s1>= s2
判断关系：
s1.isdisjoint( s2) # 判断两个集合是否不相交 in,，not in： # 判断某元素是否在集合内 == ，！= ： # 判断两个集合是否相等
补充：
s1.difference_update(s2) # 把s1和s2差集的结果赋值给s1。 s1.intersection_update( s2 ) #把s1和s2交集的结果赋值给s1。