【2017-09-05】数据结构与算法（四）

字典合并与转换

• 合并多个字典或者映射
  问题：将多个字典或者映射合并成逻辑上的单一映射后执行某些操作，如查找等
  方案：
  • 使用 collections 模块中的 ChainMap 类
  • update（）方法
    ChainMap 类的使用
       一个 ChainMap 接受多个字典并将它们在逻辑上变为一个字典。实际不会创建一个新的字典，这些字典并不是真的合并在一起了， ChainMap 类只是在内部创建了一个容纳这些字典的列表并重新定义了一些常见的字典操作来遍历这个列表。大部分字典操作都是可以正常使用的。
       对于查找，先找第一个字典，找不到，再查找第二个字典，依次类推；对于字典的更新或删除操作总是影响的是列表中第一个字典。

>>> from collections import ChainMap
>>> a={'x':1,'z':2}
>>> b={'y':4,'z':5}
>>> c=ChainMap(a,b)
>>> print(c)
ChainMap({'z': 2, 'x': 1}, {'y': 4, 'z': 5})
>>> c['x']
1
>>> c['z']
2
>>> c['y']
4
>>> len(c)
3
>>> c.values()
ValuesView(ChainMap({'z': 2, 'x': 1}, {'y': 4, 'z': 5}))
>>> c.keys()
KeysView(ChainMap({'z': 2, 'x': 1}, {'y': 4, 'z': 5}))
>>> list(c.keys())
['y', 'z', 'x']
>>> c['y']=7
>>> c['y']
7
>>> c.values()
ValuesView(ChainMap({'y': 7, 'z': 2, 'x': 1}, {'y': 4, 'z': 5}))
>>> c.new_child() 
ChainMap({}, {'y': 7, 'z': 2, 'x': 1}, {'y': 4, 'z': 5})
>>> c['g']=12
>>> c.values()
ValuesView(ChainMap({'g': 12, 'y': 7, 'z': 2, 'x': 1}, {'y': 4, 'z': 5}))
>>>#增加新的mapping
>>> c=c.new_child()
>>> c['t']=56
>>> print(c)
ChainMap({'t': 56}, {'g': 12, 'y': 7, 'z': 2, 'x': 1}, {'y': 4, 'z': 5})

update（）方法
  创建一个完全不同的字典对象。如果原字典做了更新，这种改变不会反应到新的合并字典中去.

>>> a={'x':1,'z':2}
>>> b={'y':4,'z':5}
>>> merged=dict(a)
>>> merged.update(b)
>>> merged['x']
1
>>> merged['y']
4
>>> merged['z']
5
>>> merged['d']=5
>>> merged
{'y': 4, 'd': 5, 'z': 5, 'x': 1}
>>> merged['y']=10
>>> merged
{'y': 10, 'd': 5, 'z': 5, 'x': 1}
>>> #原字典增加关键字，合并后的新字典并不受影响
>>> a['t']=20
>>> merged
{'y': 10, 'd': 5, 'z': 5, 'x': 1}
>>> a
{'z': 2, 'x': 1, 't': 20}

而ChainMap（）合并的字典，合并的字典会受原字典的改变影响，因为它不是真正创建新字典

>>> a = {'x': 1, 'z': 3 }
>>> b = {'y': 2, 'z': 4 }
>>> merged = ChainMap(a, b)
>>> merged['x']
1
>>> merged['x']=20
>>> merged['x']
20
>>> a['x']=45
>>> merged['x']
45

• 转换并同时计算数据
  问题：你需要在数据序列上执行聚集函数 (比如 sum() , min() , max() )，但是首先你需要先转换或者过滤数据
  方案：
  使用一个生成器表达式参数

>>> nums = [1, 2, 3, 4, 5]
>>> s = sum(x * x for x in nums)
>>> s
55

• 映射名称到序列元素
  问题：你有一段需要通过下标访问列表或者元组中元素的代码，但是这样有时候会使得你的代码难以阅读，于是你想通过名称来访问元素。
  方案：
  使用collections.namedtuple() 函数。这个函数实际上是一个返回 Python 中标准元组类型子类的一个工厂方法。你需要传递一个类名和你需要的字段给它，然后它就会返回一个类，你可以初始化这个类，为你定义的字段传递值等。

>>> from collections import namedtuple
>>> Subscriber = namedtuple('Subscriber', ['addr', 'joined'])
>>> sub = Subscriber('jonesy@example.com', '2012-10-19')
>>> sub
Subscriber(addr='jonesy@example.com', joined='2012-10-19')
>>> sub.addr
'jonesy@example.com'
>>> 

   尽管 namedtuple 的实例看起来像一个普通的类实例，但是它跟元组类型是可交换的，支持所有的普通元组操作，比如索引和解压

>>> len(sub)
2

   命名元组的一个主要用途是将你的代码从下标操作中解脱出来，不再依赖记录的结构，表意更清晰

from collections import namedtuple
Stock = namedtuple('Stock', ['name', 'shares', 'price'])
def compute_cost(records):
total = 0.0
for rec in records:
s = Stock(*rec) 
total += s.shares * s.price #比使用下标表意更清楚
return total

  命名元组另一个用途就是作为字典的替代，因为字典存储需要更多的内存空间。如果你需要构建一个非常大的包含字典的数据结构，那么使用命名元组会更加高效。但是命名元组属性值不可更改，如需要更改，使用 _replace() 方法

>>> Stock=namedtuple("Stock",['name','shares','price'])
>>> s=Stock("ld",34,234)
>>> s = s._replace(shares=75)
>>> s
Stock(name='ld', shares=75, price=234)

   _replace() 方法还有一个很有用的特性就是当你的命名元组拥有可选或者缺失字段时候，它是一个非常方便的填充数据的方法。你可以先创建一个包含缺省值的原型元组，然后使用 replace() 方法创建新的值被更新过的实例。

>>> Stock = namedtuple('Stock', ['name', 'shares', 'price', 'date', 'time'])
>>> stock_prototype = Stock('', 0, 0.0, None, None)
>>> def dict_to_stock(s):
    return stock_prototype._replace(**s)

>>> a = {'name': 'ACME', 'shares': 100, 'price': 123.45}
>>> b = {'name': 'ACME', 'shares': 100, 'price': 123.45, 'date': '12/17/2012'}
>>> dict_to_stock(a)
Stock(name='ACME', shares=100, price=123.45, date=None, time=None)
>>> dict_to_stock(b)
Stock(name='ACME', shares=100, price=123.45, date='12/17/2012', time=None)
>>> stock_prototype
Stock(name='', shares=0, price=0.0, date=None, time=None)
>>>