about dict

the method __missing__

>>>from collections import defaultdict
>>>d = defaultdict(list)
>>>d['a'].append(1)
>>>d['b'].append(2)

>>>d

defaultdict(<class 'list'>, {'b': [2], 'a': [1]})

>>>d.get('c',None)

>>>d['c']

[]

在defaultdict内部究竟发生了什么?

这要从字典内部的__missing__方法说起。

__missing__只由__getitem__方法调用。

一旦__getitem__找不到了key，这时候__missing__便被调用。

可想而知，在difaultdict_factory中的__missing__方法里，调用了list(),并把结果赋值给了d[key]。

search dict.keys()

A search like k in my_dict.keys() is efficient in Python 3 even

for very large mappings because dict.keys() returns a view,

which is similar to a set, and containment checks in sets are as

fast as in dictionaries. Details are documented in the “Dictionary”

view objects section of the documentation. In Python 2,

dict.keys() returns a list, so our solution also works there, but

it is not efficient for large dictionaries, because k in my_list

must scan the list.

不同的dict

collections.OrderedDict

有序字典，字典可以记住插入的顺序,在迭代的时候先访问先插入的，最后访问最后插入的。

The popitem method of an OrderedDict pops the first item by default, but if called as my_odict.popitem(last=True), it pops the last item added.

collections.ChainMap

当你输入一个key，chainmap逐次搜索各个map中的值，直到存在并返回。

当你修改一个key-value时，只修改第一个map中的key-value对。

>>>import collections
>>>cmap =  collections.ChainMap() # 创建chainMap():空的{}

>>>a = {'a':1}
>>>b = {'b':2}
>>>cmap.new_child(a) # 增加新的map， 并创建新的ChainMap

ChainMap({'a': 1}, {})

>>>cmap   #原来的cmap未变

ChainMap({})

>>>cmap.update(a)

>>>cmap

ChainMap({'a': 1})

>>>cmap.update(b)

>>>cmap

ChainMap({'b': 2, 'a': 1})

>>>cmap.parents

ChainMap({})

>>>cmap1 = collections.ChainMap(a,b)

>>>cmap1

ChainMap({'a': 1}, {'b': 2})

>>>cmap1['b'] = 3    # 只修改a中的
>>>cmap1

ChainMap({'b': 3, 'a': 1}, {'b': 2})

>>>'c' in cmap1

False

>>>cmap1['b'] # 第一个出现的 'b'

3

collections.Counter

Counter统计可迭代对象中每个元素的出现次数，但是每个元素都必须是hashable的。

>>>counter = collections.Counter('abracadabra')
>>>counter

Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

>>>counter.update('aaaaazzz')
>>>counter

Counter({'a': 10, 'z': 3, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

>>>counter.most_common(2)

[('a', 10), ('z', 3)]

collections.UserDict

A pure Python implementation of a mapping that works like a standard dict.

这个专门是用来作为父类，被继承使用的。

其与dict的一大不同是，UserDict将自己的数据暴露出来，直接用self.data便能直接访问, self.data是字典。

比如，一组数据中有int，str(int)类型作为key都要进行查询访问，我们可以利用UserDict创建当前环境下适合的字典结构。

class StrDict(collections.UserDict):
def __missing__(self, key):
if isinstance(key, str):
raise KeyError(key)
return self[str(key)]

def __contains__(self, key):
return str(key) in self.data

def __setitem__(self, key, value): # watch out forever recursion by self[str[key]] = value
self.data[str(key)] = value

>>>sdict = StrDict()
>>>sdict['4'] = 'four'
>>>sdict[5] = 'five'
>>>sdict[1] = 'one'

>>>print(sdict[4])
four
>>>print(sdict['5'])
five
>>>print(sdict['1'])
one

>>>4 in sdict

True

>>>'5' in sdict

True

>>>6 in sdict

False

我们看一看继承关系StrDict->UserDict->MutableMapping->Mapping

>>>sdict.update(((2,'two'),(10,'ten')))  # inherited from MutableMapping.update

>>>sdict

{'10': 'ten', '4': 'four', '2': 'two', '5': 'five', '1': 'one'}

>>>sdict.get('5',None)  # inherited from Mapping.get

'five'

>>>print(sdict.get('9',None))

None

MutableMapping.update

This powerful method can be called directly but is also used by __init__ to load

the instance from other mappings, from iterables of (key, value) pairs, and keyword

arguments. Because it uses self[key] = value to add items, it ends up calling

our implementation of __setitem__.

Mapping.get

In StrKeyDict, we had to code our own get to obtain results consistent

with __getitem__, but in Example 3-8 we inherited Mapping.get, which is

implemented exactly like StrKeyDict0.get.

Immutable Mappings

The mapping types provided by the standard library are all mutable, but you may need

to guarantee that a user cannot change a mapping by mistake.

Since Python 3.3, the types module provides a wrapper class called MappingProxyType, which, given a mapping, returns a mappingproxy instance that is a read-only but

dynamic view of the original mapping. This means that updates to the original mapping can be seen in the mappingproxy, but changes cannot be made through it.

>>>import types
>>>d = {'a':1}
>>>d_proxy = types.MappingProxyType(d)

>>>d_proxy

mappingproxy({'a': 1})

>>>d_proxy['a'] = 2

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-43-00aea5d4359e> in <module>()
----> 1 d_proxy['a'] = 2

TypeError: 'mappingproxy' object does not support item assignment

>>>d['b'] = 2

>>>d_proxy  # dynamic linked

mappingproxy({'b': 2, 'a': 1})

>>>sdict.__dict__

{'data': {'1': 'one', '10': 'ten', '2': 'two', '4': 'four', '5': 'five'}}

>>>sdict.__dict__['m'] = 7

>>>sdict

{'10': 'ten', '4': 'four', '2': 'two', '5': 'five', '1': 'one'}

>>>sdict.__dict__

{'data': {'1': 'one', '10': 'ten', '2': 'two', '4': 'four', '5': 'five'},
'm': 7}

>>>sdict.m

7