1. collections.abc模塊介紹

# encoding:utf-8
__author__ = 'Fioman'
__time__ = '2019/3/17 10:57'

from collections.abc import Mapping,MutableMapping
# dict是屬于Mapping類型的
a = {}
print(type(a)) # dict
print(isinstance(a,MutableMapping)) # 是屬于MutableMapping類型的
# 但是它不是通過繼承的方式,而是實現(xiàn)了這個類中的一些方法,通過MutableMapping.register(dict)的方法

2.字典的常見操作

# encoding:utf-8
__author__ = 'Fioman'
__time__ = '2019/3/17 11:04'
a = {'bob1': {'company': 'imooc'},
     'bob2': {'company': 'imooc2'}}
# clear 清空
# print(a)

# copy,淺拷貝,只拷貝了最外層的對象的引用,如果淺拷貝的
# 時候有可變對象的應(yīng)用,則如果修改了原來的值,則可變對象的值也就跟著改變.
# 比如上面的a字典,key的拷貝不會出現(xiàn)問題.但是value的值本身也是一個引用類型,
# 它是可變的,拷貝的時候只是拷貝了這個內(nèi)部字典的應(yīng)用.所以如果它修改了,則原來的那個
# 對象也會跟著修改.
new_dict = a.copy()
new_dict['bob1']['company'] = 'imooc3'
print(a)
print(new_dict)
# {'bob1': {'company': 'imooc3'}, 'bob2': {'company': 'imooc2'}}
# {'bob1': {'company': 'imooc3'}, 'bob2': {'company': 'imooc2'}}

# fromkeys 將一個可迭代對象作為鍵,設(shè)定一個默認(rèn)值,生成一個新字典
lst_keys = [1, 2, 3, 4]
new_dict = dict.fromkeys(lst_keys, 'a')
print(new_dict)

# get 根據(jù)鍵獲取值.類似dict[key] 的用法.
# 但是dict[key]用法有一個缺點,如果元素不在字典中會創(chuàng)建一個新的鍵

value = new_dict.get(1, '')  # 如果key為1的不存在或者沒有這個key,就會返回空
print(new_dict)
# value = new_dict[5] # 這里會報錯
new_dict[5] = 6  # 這里會重新創(chuàng)建一個鍵,只有這個鍵存在的時候才是修改對應(yīng)的值
print(new_dict, new_dict[5])

# items()key,value的元組的列表
print(new_dict.items(), new_dict.keys(), new_dict.values())
# items()返回的是一個元組列表, keys()返回的是鍵的列表,values()返回的值列表

for key, value in new_dict.items():
    print(key, value)

# setdefault('7','d')  創(chuàng)建一個鍵,并且設(shè)置默認(rèn)值
default_value = new_dict.setdefault(7, 'd')
print(new_dict)

# update() 可以將一個字典或者一個賦值表達(dá)式,或者一個元組列表合并到字典中
new_dict.update({8: 'a'})
new_dict.update(boby=3, boby2=4)
new_dict.update([(9, 'f'), (10, 'g')]) # 放一個元組列表
print(new_dict)

3.和字典相關(guān)的類

1. 當(dāng)我們要自定義一個字典的時候,不要使用直接繼承自dict,因為有些操作會不生效

# encoding:utf-8
__author__ = 'Fioman'
__time__ = '2019/3/17 13:42'


class MyDict(dict):
    def __setitem__(self, key, value):
        super().__setitem__(key, value * 2)

my_dict = MyDict()
my_dict['a'] = 3  # 這個時候調(diào)用的是__setitem__方法
print(my_dict) # {'a': 6}

# 直接在構(gòu)造函數(shù)中初始化字典,這個時候調(diào)用的應(yīng)該是__call__方法
my_dict = MyDict(b=5)
print(my_dict) # {'b': 5}

# 所以最好不要繼承dict的方式,可以用繼承collections模塊的UserDict的方式

2. 使用繼承UserDict的方式來實現(xiàn)自定義的字典.

# encoding:utf-8
__author__ = 'Fioman'
__time__ = '2019/3/17 13:47'
from collections import UserDict


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

mydict = MyDict(a=4)
print(mydict)

mydict['b'] = 5
print(mydict)

3. 創(chuàng)建帶有默認(rèn)值的字典. collections中的defaultdict
字典之所以可以實現(xiàn)帶有默認(rèn)值,其實是它內(nèi)部實現(xiàn)了__missing__方法,在UserDict類里面的__getitem__方法中會調(diào)用__missing__方法

    def __getitem__(self, key):
        if key in self.data:
            return self.data[key]
        if hasattr(self.__class__, "__missing__"):
            return self.__class__.__missing__(self, key)
        raise KeyError(key)

defaultdict之所以可以設(shè)置默認(rèn)值就是因為實現(xiàn)了__missing__方法

4. set和frozenset

# encoding:utf-8
__author__ = 'Fioman'
__time__ = '2019/3/17 13:58'
# set 集合 frozenset(不可變集合),無序,不重復(fù)
s = set('abcdef')
print(s)
s1 = set(['a', 'b', 'c', 'd'])
print(s1)
# 通過大括號的方式直接賦值
s2 = {'a', 'b', 'c', 'd'}
print(s2)

# 1.集合可以添加元素
s2.add('f')
print(s2)

s = frozenset('abcde')  # frozenset 是不可變的集合,可以作為字典的key
# s.add() 錯誤,不可變集合不能添加數(shù)據(jù)

# 2.clear() 清空集合
# 3.copy() 淺拷貝集合
# 4.pop() 彈出最后一個元素
# 5.remove() 刪除一個集合元素
# 6.update()像set中添加一個集合
another_set = set('123')
s2.update(another_set)
print(s2)
# 7.difference(找不同)
ret_set = s2.difference(another_set)  # s - s2
print(ret_set)
# 8.求交集 &
ret_set = s2 & another_set
print(ret_set)
# 9.求并集
ret_set = s2 | another_set
print(ret_set)
# 10 in 對應(yīng)的魔法方法__contains__
if 'a' in ret_set:
    pass
# 11. 判斷是否是子集
if s2.issubset(another_set)

5. dict和set的實現(xiàn)原理

dict和list的性能對比:
1. dict的性能遠(yuǎn)遠(yuǎn)大于list
2. list的查找時間,hi隨著list的數(shù)據(jù)的增多成正比例增加
3. 而dict的查找時間,不會隨著字典的增大而增大.

字典的內(nèi)部是通過hash表來映射的,什么是hash表,通過字典的key算出一個hash值,這個hash值對應(yīng)一個位置,這個位置存放著字典的key和value.而因為hash表的存放是連續(xù)的,類似于數(shù)組,它查找和存取是根據(jù)偏移量來進(jìn)行的,所以不需要遍歷,就會速度很快.

注意:
set的值和字典的鍵的實現(xiàn)原理是一樣的,都是可以hash的.
不可變對象,都是可hash的.str,forzenset,tuple,自己實現(xiàn)的類實現(xiàn)了__hash__都是可hash的對象.都可以作為字典的鍵

dict的內(nèi)存花銷大,但是查詢速度快,自定義對象,或者python的自定義對象,都是用字典的方式來存儲的.

dict的存儲順序和元素的添加順序有關(guān)
dict中添加元素的時候,有可能會改變原來的位置.當(dāng)插入的數(shù)據(jù)過多,重新分配內(nèi)存的時候,dict就有可能將原來的順序打亂.
所以一般使用dict的時候,不要期望它會一直維持某種順序.