二十三、元组内置方法

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

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

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

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

3. 使用方法

   1. 索引取值

      print(tuo[0]

   2. 索引切片

      print(tup[0:3])

   3. for循环

      for i in tup:
          print(i)

   4. 成员运算

      print(0 in tup)

   5. len长度

      print(len(tup))

   6. index

      print(tup.index(1))

   7. count

      print(tup.count(2))

4. 有序or无序

   有序

5. 可变or不可变

   没有可变不可变一说

二十四、字典数据类型

1. 作用：存储多个数据、对每个数据都有描述

2. 定义方式：{}内用括号隔开多个键key（具有描述意义，不能为可变类型）值value（任意数据类型）对

   dic = {'name' = 1}

3. 使用方法

   1. 优先掌握

      1. 按key取值/按key修改值

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

      2. 添加值（没有就添加，有就修改）

         dic['d'] = 4

      3. for循环

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

      4. 成员运算

         print('a' in dic) 

      5. len

         print(len(dic))

      6. keys/values/items

         print(dic.keys())  # 看成列表
         print(dic.values())  # 获取所有值
         
         for i, j in dic.items:
             print(i, j)

   2. 需要掌握

      1. get

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

      2. update

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

      3. fromkeys

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

      4. setdefault

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

4. 有序or无序

   无序

5. 可变or不可变

   可变

二十五 集合内置方法

1. 作用

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

2. 定义方式

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

   s = {}  # 空字典
   s = set()  # 空集合
   
   # 字符串比较，先比较第一位数字，在比较第二位

3. 使用方法

   1. 并集（|）

      两个集合合并

   2. 交集（&）

      两个集合共有

   3. 差集（-）

      集合中去掉另一个集合*有的

   4. 补集（^）

      去掉的两个集合共有元素的合并集合

   5. add

      pythoners.add('oscar')

   6. remove和discard

      pythoners.remove('oscar1')  # 没有报错
      pythoners.discard('oscar1')  # 没有不报错
      print(pythoners)

   7. pop

      pythoners.pop()  # 随机删除一个

4. 有序or无序：无序

5. 可变or不可变：可变

二十五、数据类型总结

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

二十六、深浅拷贝

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

1. 拷贝

   lt1 = [1, 2, 3, [4, 5, 6]]
   lt2 = lt1

   lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变

2. 浅拷贝

   lt1 = [1, 2, 3]
   lt2 = copy.copy(lt1)

   当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化时，lt2不变；lt1内部的可变元素变化，lt2变

3. 深拷贝

   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均不会变化
• 深浅拷贝只针对可变数据类型，因为，如果是深浅拷贝对象时不可变数据，无论深浅拷贝，对应的拷贝对象均不会发生改变

补充：散列表（哈希表）

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

1. 首先对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())

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

​

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

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

3. 字典为什么是乱序的

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