七、深入python的set和dict

‍

一、dict的abc继承关系

dict的abc继承关系是指一组用于创建和操作映射对象的通用接口。这些接口包括MutableMapping、Mapping、Sized、Iterable、Container和Generic。其中，MutableMapping继承自Mapping，Mapping继承自Sized、Iterable和Container。这样，我们可以通过这些接口来定义和操作字典对象，而无需关心具体的实现细节。

另外，Generic是一个基类，它继承自TypeVar，用于指定类型变量的范围。因此，了解dict的abc继承关系对于深入理解Python中的字典类型以及相关操作非常重要。

from _collections_abc import MutableMapping,Mapping
a={}
print(isinstance(a,Mapping))

二、dict的常用方法

clear(): 删除字典内所有元素
copy(): 复制字典，浅拷贝
fromkeys(seq, value=None): 以给定的序列为键，创建新的字典，值都设置为 value
get(key, default=None): 返回指定键的值，如果值不在字典中返回默认值
items(): 返回一个包含所有字典项的列表
keys(): 返回字典中所有键的列表
pop(key, default=None): 删除字典给定键 key 所对应的值，返回被删除的值。如果 key 不存在，返回默认值 default
popitem(): 随机返回并删除字典中的一对键和值
setdefault(key, default=None): 和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值
update(dict2): 把字典dict2的键/值对更新到dict里
values(): 返回字典中所有值的列表

a = {
    "bobby1": {"company": "imooc"},
    "bobby2": {"company": "imooc2"}
}

#clear
# a.clear()
# print(a)

#copy浅copy
# new_a = a.copy()
# new_a['bobby1']['company'] = '123'
# print(a)
# print(new_a)
# {'bobby1': {'company': '123'}, 'bobby2': {'company': 'imooc2'}}
# {'bobby1': {'company': '123'}, 'bobby2': {'company': 'imooc2'}}

#深copy
# import copy
# new_a = copy.deepcopy(a)
# new_a['bobby1']['company'] = '123'
# print(a)
# print(new_a)
# 返回
# {'bobby1': {'company': 'imooc'}, 'bobby2': {'company': 'imooc2'}}
# {'bobby1': {'company': '123'}, 'bobby2': {'company': 'imooc2'}}

#from_keys
# new_list = ['a','b','c']
# new_dict = dict.fromkeys(new_list, 12)
# print(new_dict)
#{'a': 12, 'b': 12, 'c': 12}

# print(a.get("bobby1"))

# for key,value in a.items():
#     print("key:{},value:{}".format(key,value['company']))
# key:bobby1,value:imooc
# key:bobby2,value:imooc2

# new_dict = a.setdefault("aa","bbb")
# print(new_dict)

b = {
    "bobby1": 123,
    "bobby2": 456
}
a.update(b)
print(a)  #会改变原对象
#{'bobby1': 123, 'bobby2': 456}

三、dict的子类

前置

#不建议继承list和dict
class MyDict(dict):
    def __setitem__(self, key, value):
        super().__setitem__(key,value*2)

my_dict = MyDict({"one":1})
print(my_dict)  #{'one': 1}  并没有乘2,他调用的是C的函数

my_dict['one'] = 1
print(my_dict)  #{'one': 2}  #这个是正常的

from collections import UserDict
class MyDict2(UserDict):
    def __setitem__(self, key, value):
        super().__setitem__(key,value*2)

my_dict = MyDict2({"one":1})
print(my_dict)  #{'one': 2}  #继承UserDict 这个是正常的

my_dict['one'] = 1
print(my_dict)  #{'one': 2}  #这个是正常的

defaultdict是collections模块中的一个类，它是字典（dict）的一个子类，提供了一个默认值的功能。当对一个不存在的键进行访问时，defaultdict会自动为该键设置一个默认值，而不会抛出KeyError异常。
使用defaultdict时，需要传入一个默认值的工厂函数作为参数，当访问不存在的键时，会自动调用该工厂函数生成默认值。例如，如果传入int作为工厂函数，则默认值为0；如果传入list作为工厂函数，则默认值为一个空列表。

from collections import defaultdict

a = defaultdict(int)
print(a['a'])   #0  默认值为0 
b = defaultdict(list)
print(b)   #defaultdict(<class 'list'>, {})  #默认值为list

四、set 和 fronzenset(不可变集合) 无序 不重复

my_set = {"1"}
print(type(my_set))  #<class 'set'>

my_set = set("abc")
print(my_set)  #{'c', 'b', 'a'}
my_set = set(["aa","bb","cc"])
print(my_set) #{'bb', 'aa', 'cc'}

my_set = set(("aaaa","bbbb","cccc"))
print(my_set)  #{'bbbb', 'aaaa', 'cccc'}

another_set = set("def")
my_set.update(another_set)
print(my_set)  #{'aaaa', 'cccc', 'bbbb', 'e', 'd', 'f'}

#不可变集合
aa = frozenset("aabb")
print(aa)  #frozenset({'b', 'a'})

五、dict和set的实现原理

‍

dict和set都是基于哈希表（hash table）实现的数据结构。
在Python中，dict是一种键值对的数据结构，通过哈希表实现。当我们向dict中添加一个键值对时，Python会根据键的哈希值来确定该键值对在哈希表中的位置，然后将键值对存储在该位置上。当我们需要查找某个键对应的值时，Python会根据键的哈希值找到该键值对所在的位置，然后返回对应的值。
set是一种只包含键的集合数据结构，也是通过哈希表实现的。当我们向set中添加一个元素时，Python会将该元素作为键值对中的键，然后将其存储在哈希表中。当我们需要判断某个元素是否在set中时，Python会根据元素的哈希值找到对应的位置，然后判断该位置上是否存在该元素。
哈希表的优点是可以实现快速的查找、插入和删除操作，时间复杂度为O(1)。然而，哈希表也存在一些缺点，例如可能会出现哈希冲突（即不同的键具有相同的哈希值），导致性能下降。为了解决哈希冲突问题，Python中采用了开放寻址法和链地址法等方法。