Collections--ChainMap

　　一个 ChainMap 类是为了将多个映射快速的连接到一块儿，这样它们就能够做为一个单元处理。它一般比建立一个新字典和屡次调用 update() 要快不少。

class collections.ChainMap(*maps)

支持全部经常使用字典方法。另外还有一个 maps 属性(attribute)，一个建立子上下文的方法(method)， 一个存取它们首个映射的属性(property):

maps

　　一个能够更新的映射列表。这个列表是按照第一次搜索到最后一次搜索的顺序组织的。它是仅有的存储状态，能够被修改。列表最少包含一个映射。

 

new_child(m=None)

　　返回一个新的 ChainMap 类，包含了一个新映射(map)，后面跟随当前实例的所有映射(map)。若是 m 被指定，它就成为不一样新的实例，就是在全部映射前加上 m，若是没有指定，就加上一个空字典，这样的话一个 d.new_child() 调用等价于 ChainMap({}, *d.maps) 。这个方法用于建立子上下文，不改变任何父映射的值。

在 3.4 版更改: 添加了 m 可选参数。

 

parents

属性返回一个新的 ChainMap 包含全部的当前实例的映射，除了第一个。这样能够在搜索的时候跳过第一个映射。

 

 

如今假设你必须在两个字典中执行查找操做 (好比先从 a 中找，若是找不到再在 b中找)。一个很是简单扼解决方案就是使用 collections 模块中的 ChainMap 类。好比：

In [46]: a = {'x': 1, 'z': 3 }                                                                                                       

In [47]: b = {'y': 2, 'z': 4 }                                                                                                       

In [48]: from collections import ChainMap                                                                                            

In [49]: c=ChainMap(a,b)                                                                                                             

In [50]: c.get('x')                                                                                                                  
Out[50]: 1

In [51]: c.get('z')                                                                                                                  
Out[51]: 3

In [52]: c.get('y')                                                                                                                  
Out[52]: 2

  若是出现重复键，那么第一次出现的映射值会被返回。所以，例子程序中的c['z']老是会返回字典a中对应的值，而不是b中对应的值。

 

对于字典的更新或删除操做老是影响的是列表中第一个字典。好比：

In [65]: c                                                                                                                           
Out[65]: ChainMap({'x': 1, 'z': 10}, {'y': 2, 'z': 4})

In [66]: c['x']=10                                                                                                                   

In [67]: c['z']=10                                                                                                                   

In [68]: c                                                                                                                           
Out[68]: ChainMap({'x': 10, 'z': 10}, {'y': 2, 'z': 4})

del c['y']

KeyError: "Key not found in the first mapping: 'y'"

　　

一个 ChainMap 经过引用合并底层映射。 因此，若是一个底层映射更新了，这些更改会反映到 ChainMap 。

In [71]: a['x']=100                                                                                                                  

In [72]: c                                                                                                                           
Out[72]: ChainMap({'x': 100, 'z': 10}, {'y': 2, 'z': 4})

　　

new_child()方法和parents属性

d=c.new_child()                                                                                                             

In [81]: d                                                                                                                           
Out[81]: ChainMap({}, {'x': 100, 'z': 10}, {'y': 2, 'z': 4})

In [82]: d['x']=1                                                                                                                    

In [83]: d                                                                                                                           
Out[83]: ChainMap({'x': 1}, {'x': 100, 'z': 10}, {'y': 2, 'z': 4})

In [84]: d=d.new_child()                                                                                                             

In [85]: d['x']=2                                                                                                                    

In [86]: d                                                                                                                           
Out[86]: ChainMap({'x': 2}, {'x': 1}, {'x': 100, 'z': 10}, {'y': 2, 'z': 4})

In [89]: d=d.parents                                                                                                                 

In [90]: d['x']                                                                                                                      
Out[90]: 1

In [91]: d                                                                                                                           
Out[91]: ChainMap({'x': 1}, {'x': 100, 'z': 10}, {'y': 2, 'z': 4})

In [92]: d=d.parents                                                                                                                 

In [93]: d['x']                                                                                                                      
Out[93]: 100

　　

 

典型用例

让用户指定的命令行参数优先于环境变量，优先于默认值的例子

import os, argparse

defaults = {'color': 'red', 'user': 'guest'}

parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = {k:v for k, v in vars(namespace).items() if v}

combined = ChainMap(command_line_args, os.environ, defaults)
print(combined['color'])
print(combined['user'])