python---collections模块记录(defaultdict, namedtuple, ChainMap)

collections   ---  defaultdict

对于一个字典或键值，取不存在的键时返回函数提前设置好的默认值。避免取键错误。

import collections


def default_factory():
    return 'default value'
# ss = {'foo':'bar'}
# d = collections.defaultdict(default_factory,ss)
d = collections.defaultdict(default_factory, foo='bar')

print('d:', d)
print('foo =>', d['foo'])
print('bar =>', d['bar'])


"""
d: defaultdict(<function default_factory at 0x00000227672D18C8>, {'foo': 'Foo'})
foo => Foo
bar => default value
"""

collections   ---  namedtuple

标准tuple使用数字索引可以访问到tuple元素，相较于标准tuple，namedtuple不仅是兼具tuple的特点，还可以通过键值对访问元素。

每种namedtuple都由自己的类表示，该类是使用namedtuple()工厂函数创建的。参数是新类的名称和包含元素名称的字符串（或列表或元组）。

每个namedtuple可以通过  _属性(_方法) 来实现一些功能，如 _replace 替换元素生成新的tuple，_fields 遍历初始化 namedtuple 时的元素名称。（_asdict()）

注意：元素名称应尽量避免关键字冲突或重复，否则初始化时会ValueError异常，可以添加rename=True来解决，关键字参数或重复名称会被数字下标代替。

#普通元组
bob = ('Bob', 30, 'male')
print('Representation:', bob)

jane = ('Jane', 29, 'female')
print('\nField by index:', jane[0])

print('\nFields by index:')
for p in [bob, jane]:
    print('{} is a {} year old {}'.format(*p))

"""
Representation: ('Bob', 30, 'male')

Field by index: Jane

Fields by index:
Bob is a 30 year old male
Jane is a 29 year old female
"""



#namedtuple

import collections

Person = collections.namedtuple('Person','name age gender age',rename=True)
sam =Person('sam','28','man','24')
tom = sam._replace(name='tom')
print(*tom)
print(*sam)
print(sam.name)
print(sam._fields)

"""
tom 28 man 24
sam 28 man 24
sam
('name', 'age', 'gender', '_3')
"""

collections   ---  ChainMap

通过ChainMap将生成一个新的对象，该对象具有字典的常规操作方法，可以同时遍历两个字典。随着原始字典的改变而动态改变。

子映射按照它们传递给构造函数的顺序进行搜索，因此为键报告的值 'c' 来自 a字典

import collections

a = {'a': 'A', 'c': 'C'}
b = {'b': 'B', 'c': 'D'}

m = collections.ChainMap(a, b)

print('Individual Values')
print('a = {}'.format(m['a']))
print('b = {}'.format(m['b']))
print('c = {}'.format(m['c']))
print()

print('Keys = {}'.format(list(m.keys())))
print('Values = {}'.format(list(m.values())))
print()

print('Items:')
for k, v in m.items():
    print('{} = {}'.format(k, v))
print()

print('"d" in m: {}'.format(('d' in m)))


"""
Individual Values
a = A
b = B
c = C

Keys = ['b', 'c', 'a']
Values = ['B', 'C', 'A']

Items:
b = B
c = C
a = A

"d" in m: False
"""

重新排序

通过实例对象的maps属性可以将映射关系转换为 list ，从而直接添加新映射或更改元素的顺序以控制查找和更新行为。

import collections

a = {'a': 'A', 'c': 'C'}
b = {'b': 'B', 'c': 'D'}

m = collections.ChainMap(a, b)

print(m.maps)
print('c = {}\n'.format(m['c']))

# reverse the list
m.maps = list(reversed(m.maps))

print(m.maps)
print('c = {}'.format(m['c']))


#键c的value的改变
"""
[{'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'}]
c = C

[{'b': 'B', 'c': 'D'}, {'a': 'A', 'c': 'C'}]
c = D
"""

更新映射关系

更改父级映射关系子映射会改变，同时通过ChainMap对象的子映射也可以改动父级映射。

import collections

a = {'a': 'A', 'c': 'C'}
b = {'b': 'B', 'c': 'D'}

m = collections.ChainMap(a, b)

print('Before: {}'.format(m['c']))
a['c'] = 'E'
print('After : {}'.format(m['c']))

print('Before: {}'.format(m['a']))
m['a'] = 'AA'
print('After : {}'.format(m['a']))

print('a {}'.format(a))



"""
Before: C
After : E
Before: A
After : AA
a {'a': 'AA', 'c': 'E'}
"""

创建新实例

在maps列表的前面有一个额外的映射，以便轻松避免修改现有的底层数据结构。

这种堆叠行为使得将ChainMap 实例用作模板或应用程序上下文变得很方便。

具体来说，很容易在一次迭代中添加或更新值，然后在下一次迭代中丢弃更改。

import collections

a = {'a': 'A', 'c': 'C'}
b = {'b': 'B', 'c': 'D'}

m1 = collections.ChainMap(a, b)
m2 = m1.new_child()

print('m1 before:', m1)
print('m2 before:', m2)

m2['c'] = 'E'

print('m1 after:', m1)
print('m2 after:', m2)


#m2的maps列表多了一个新的空映射集
"""
m1 before: ChainMap({'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
m2 before: ChainMap({}, {'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
m1 after: ChainMap({'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
m2 after: ChainMap({'c': 'E'}, {'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
"""

对于新上下文已知或预先构建的情况，也可以将映射传递给new_child()

import collections


a = {'a': 'A', 'c': 'C'}
b = {'b': 'B', 'c': 'D'}
c = {'c': 'E'}

m1 = collections.ChainMap(a, b)

# m2 = collections.ChainMap(c, *m1.maps)  #同样的效果
m2 = m1.new_child(c)

print(m1)
print(m2)

print('m1["c"] = {}'.format(m1['c']))
print('m2["c"] = {}'.format(m2['c']))



"""
ChainMap({'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
ChainMap({'c': 'E'}, {'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
m1["c"] = C
m2["c"] = E
"""

滴水穿石，好记性不如烂笔头，主要是忘性大 0.0