元组/字典/集合内置方法+简单哈希表(day07整理)

时间：2024-01-02 13:43:50

二十三、元组内置方法

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

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

补充：散列表（哈希表）

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

元组/字典/集合内置方法+简单哈希表(day07整理)

  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取余

​ 元组/字典/集合内置方法+简单哈希表(day07整理)

元组/字典/集合内置方法+简单哈希表(day07整理)

1. 为什么key是不可变数据类型
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
 2. 为什么key不能重名dic = {'a':1, 'a':2}  # key不能重名
 因为会被覆盖
3. 字典为什么是乱序的
4. 散列表（哈希表）解决了什么问题

相关文章