05 python深入python的set和dict

dict的abc继承关系

dict属于mapping类型，下面通过查看源码来分析它的继承关系

from collections.abc import Mapping, MutableMapping

查看MutableMapping源码

class MutableMapping(Mapping):

    __slots__ = ()

    """A MutableMapping is a generic container for associating
    key/value pairs.

    This class provides concrete generic implementations of all
    methods except for __getitem__, __setitem__, __delitem__,
    __iter__, and __len__.

    """

    @abstractmethod
    def __setitem__(self, key, value):
        raise KeyError

    @abstractmethod
    def __delitem__(self, key):
        raise KeyError

    __marker = object()

    def pop(self, key, default=__marker):
        '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
          If key is not found, d is returned if given, otherwise KeyError is raised.
        '''
        try:
            value = self[key]
        except KeyError:
            if default is self.__marker:
                raise
            return default
        else:
            del self[key]
            return value

    def popitem(self):
        '''D.popitem() -> (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        '''
        try:
            key = next(iter(self))
        except StopIteration:
            raise KeyError
        value = self[key]
        del self[key]
        return key, value

    def clear(self):
        'D.clear() -> None.  Remove all items from D.'
        try:
            while True:
                self.popitem()
        except KeyError:
            pass

    def update(*args, **kwds):
        ''' D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
            In either case, this is followed by: for k, v in F.items(): D[k] = v
        '''
        if not args:
            raise TypeError("descriptor 'update' of 'MutableMapping' object "
                            "needs an argument")
        self, *args = args
        if len(args) > 1:
            raise TypeError('update expected at most 1 arguments, got %d' %
                            len(args))
        if args:
            other = args[0]
            if isinstance(other, Mapping):
                for key in other:
                    self[key] = other[key]
            elif hasattr(other, "keys"):
                for key in other.keys():
                    self[key] = other[key]
            else:
                for key, value in other:
                    self[key] = value
        for key, value in kwds.items():
            self[key] = value

    def setdefault(self, key, default=None):
        'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'
        try:
            return self[key]
        except KeyError:
            self[key] = default
        return default

MutableMapping.register(dict)

　　

可以看到MutableMapping继承的是Mapping（不可变） ，最后把dict注册到MutableMapping.中   MutableMapping.register(dict)

可以通过 isinstance 查看一个字典的类型

from collections.abc import Mapping, MutableMapping
#dict属于mapping类型

a = {}
print (isinstance(a, MutableMapping))

测试结果如下

dict的常用方法

 

 copy(这里是浅拷贝)

a = {"biao1":{"company":"imooc"},
     "biao2": {"company": "imooc2"}
     }
#copy, 返回浅拷贝
new_dict = a.copy()
new_dict["bobby1"]["company"] = "imooc3"

调试结果如下　

 

fromkeys把可迭代的对象转变为dict

 

new_list = ["bobby1", "bobby2"]

new_dict = dict.fromkeys(new_list, {"company":"imooc"})

调试结果如下

get取值，可以设置一个默认值避免字典中keyerror异常

a = {"name1": "jack", "name2": "jane"}
value = a.get("name3", "not exist")

调试结果如下

 setdefault()，和get()相似，不同的是如果没有某个键名，会把此键名和默认值加入到字典中

a = {"name1": "jack", "name2": "jane"}

 
# 没有指定键名时
a.setdefault("name3", "not exist")

调试结果如下

update(), 可用于添加字典元素

 

a = {"name1": "jack", "name2": "jane"}

# 直接添加字典方式
a.update({"name3": "hong"})
# 使用参数名方式
a.update(name4="lilei", name5="mei")

调试结果如下

dict的子类

 如果我们想要继承dict重写我们的逻辑 ，不建议继承list和dict 因为他们是c语言写的，我们重写的函数有可能不会生效

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

my_dict = Mydict(one=1)  # 在这个时候没生效
print (my_dict)

my_dict["one"] = 1  # 在这个时候生效
print(my_dict)

打印结果

 

 应该使用python为我们提供的UserDict

from collections import UserDict

class Mydict(UserDict):
    def __setitem__(self, key, value):
        super().__setitem__(key, value*2)

my_dict = Mydict(one=1)
pass

调试结果如下

 

dict 的子类defaultdict

 当我们取值一个不存在的值的时候，它会返回一个 {}

from collections import defaultdict

my_dict = defaultdict(dict)
my_value = my_dict["bobby"]

　　

 调试结果如下

内部源码分析

 

set和frozenset

初始化一个set

# 使用set关键字
s1 = set('abc')
# 使用{}
s2 = {'a', 'b'}

print(type(s1), type(s2))

　

向set中添加元素

s1 = set('abc')
s1.add('d')
print(s1)  

　　

使用update()函数更新set

s1 = set('abc')
s2 = set('xy')
s1.update(s2)
print(s1)

　　

difference()函数来求两个集合的差集

s1 = set('abc')
s2 = set('cd')

# 相当于s1 - s2
re_set = s1.difference(s2)
print(re_set)

　

set的数学运算

s1 = set('abc')
s2 = set('cd')

# 差集
print(s1-s2)
# 交集
print(s1 & s2)
# 并集
print(s1 | s2)

 issubset()判断集合A是否为集合B的子集

s1 = set('abc')
s2 = set('c')

print(s2.issubset(s1))

　　

dict和set的实现原理

list和dict的性能比较

　　1 dict的查找性能远大于list

　　2 在list中随着list数据量的增大，查找相同数据量的时间也会增大

　　3 在dict中随着dict数据量的增大，查找相同数据量的时间不怎么受影响

 dict原理小结

dict找一个值之所以快，是因为他会根据这个键，进行哈希获得偏移量，直接取值，时间复杂度为0（1）

　　1）dict的key或者set的值都必须是可hash的，他们的实现原理相同。不可变对象都是可hash的，比如string， tuple， fronzenset

　　2）dict的内存花销大，但是查询速度快；自定义的类中，只要加上魔法函数__hash__, 那么这个类就是可hash的

　　3）dict的存储顺序和元素添加顺序有关，因hash值冲突的原因

　　4）添加数据的时候有可能会改变已有数据的顺序：存储dict的时候，python会预先申请一段大于dict数据需求的连续内存空间，以减少hash冲突的概率，当添加数据量使得大于分配内存空间的1/3的时候，python就会另申请一个较大的内存空间，把原先的数据进行迁移，重新进行hash值的计算