• 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'])
    

      

  • 相关阅读:
    又是一个递归的题
    全文检索引擎记录
    处理“System.Web.HttpException: 超过了最大请求长度”
    完整国内城市js级联选择
    多服务器共享session的解决方案之一
    递归求n的阶乘
    面试遇到了 <计算从1到N中1的出现次数>结果悲剧了.
    DropDownList绑定Xml数据的实现
    简单图片上传示例
    C#默认访问修饰符
  • 原文地址:https://www.cnblogs.com/zydev/p/11760037.html
Copyright © 2020-2023  润新知