二十三、元组内置方法

什么是元组：只可取,不可更改的列表

作用：元组一创建就被写死了

定义方式：（）内用逗号隔开多个元素（可以为任意数据类型）

tup = tuple((1, 2, 3))
# 如果元组只有一个元素,必须要加逗号
tup = (1,)

使用方法

索引取值
```
print(tuo[0]
```
索引切片
```
print(tup[0:3])
```
for循环
```
for i in tup:
    print(i)
```
成员运算
```
print(0 in tup)
```
len长度
```
print(len(tup))
```
index
```
print(tup.index(1))
```
count
```
print(tup.count(2))
```

有序or无序
有序
可变or不可变
没有可变不可变一说

二十四、字典数据类型

作用：存储多个数据、对每个数据都有描述
定义方式：{}内用括号隔开多个键key（具有描述意义，不能为可变类型）值value（任意数据类型）对
```
dic = {'name' = 1}
```

使用方法

优先掌握

按key取值/按key修改值

dic = {'a' = 1, 'b' = 2, 'c' = 3}
print(dic['a'])

添加值（没有就添加，有就修改）
```
dic['d'] = 4
```

for循环

for i in dic:
    print(i) # 打印的为key

成员运算
```
print('a' in dic) 
```
len
```
print(len(dic))
```

keys/values/items

print(dic.keys())  # 看成列表
print(dic.values())  # 获取所有值

for i, j in dic.items:
    print(i, j)

需要掌握

get

print(dic.get('b', 1))  # 字典中没有返回None，可以给定一个默认值

update

dic1 = {'a':1, 'b':2}
dic2 = {'c':3, 'd':4}
dic1.update(dic2)
print(dic1)

fromkeys

print(dict.fromkeys(2))  # 默认给None

setdefault

dic.setdefault('j', 2)
#字典有这个key，就不修改，没有则增加

有序or无序
无序
可变or不可变
可变

二十五集合内置方法

作用
1. 并集/交集/差集/补集
2. 去重
3. 乱序

定义方式

{}内隔开多个元素（不能为可变数据类型）

s = {}  # 空字典
s = set()  # 空集合

# 字符串比较，先比较第一位数字，在比较第二位

使用方法
1. 并集（|）
  两个集合合并
2. 交集（&）
  两个集合共有
3. 差集（-）
  集合中去掉另一个集合中共有的
4. 补集（^）
  去掉的两个集合共有元素的合并集合
5. add
```
pythoners.add('oscar')
```
6. remove和discard
```
pythoners.remove('oscar1')  # 没有报错
pythoners.discard('oscar1')  # 没有不报错
print(pythoners)
```
7. pop
```
pythoners.pop()  # 随机删除一个
```
有序or无序：无序
可变or不可变：可变

二十五、数据类型总结

存值个数
- 存一个值：整形/浮点型/字符串
- 存多个值：列表/元组/字典/集合
有序or无序
- 有序：字符串/列表/元组
- 无序：字典/集合
可变or不可变
- 可变：列表/字典/集合
- 不可变：整形/浮点型/字符串/元组

二十六、深浅拷贝

可变/不可变
- 可变：值变id不变
- 不可变：值变id变化

拷贝
```
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = lt1
```
lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变
浅拷贝
```
lt1 = [1, 2, 3]
lt2 = copy.copy(lt1)
```
当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化时，lt2不变；lt1内部的可变元素变化，lt2变
深拷贝
```
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = copy.deepcopy(lt1)
```
当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变

总结
- 当lt2为lt1的拷贝对象时，无论lt1内部元素是可变还是不可变，只要发生变化，lt2也会发生变化
- 当lt2为lt1的浅拷贝对象时，只有lt1内部的可变元素变化时lt2才会变
- 当lt2为lt1的深拷贝对象时，无论lt1内部元素是可变还是不可变元素，发生变化，lt2均不会变化
深浅拷贝只针对可变数据类型，因为，如果是深浅拷贝对象时不可变数据，无论深浅拷贝，对应的拷贝对象均不会发生改变

补充：散列表（哈希表）

散列表/哈希表存储数据（比列表插入/删除数据更快）

首先对key做了哈希处理（所有数据均可）

梅森旋转算法（生成伪随机数）--》通过哈希处理对于每个key都可以生成一个序列（永不重复，且唯一）

import hashlib

m = hashlib.md5()
# m.update(b'a')  # 0cc175b9c0f1b6a831c399e269772661
# m.update(b'b')  # 92eb5ffee6ae2fec3ad71c777531578f
# m.update(b'c')  # 4a8a08f09d37b73795649038408b5f33
# m.update(b'd')  # 8277e0910d750195b448797616e091ad
m.update(b'a')  # 0cc175b9c0f1b6a831c399e269772661
print(m.hexdigest())

使用哈希函数对刚刚生成的序列（纯数字），除9取余

1. 为什么key是不可变数据类型
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

 2. 为什么key不能重名dic = {'a':1, 'a':2}  # key不能重名
 因为会被覆盖

3. 字典为什么是乱序的

4. 散列表（哈希表）解决了什么问题

lt1