You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
277 lines
7.0 KiB
277 lines
7.0 KiB
import operator
|
|
from .compatibility import (map, zip, iteritems, iterkeys, itervalues,
|
|
reduce)
|
|
|
|
__all__ = ('merge', 'merge_with', 'valmap', 'keymap', 'itemmap',
|
|
'valfilter', 'keyfilter', 'itemfilter',
|
|
'assoc', 'dissoc', 'update_in', 'get_in')
|
|
|
|
|
|
def merge(*dicts):
|
|
""" Merge a collection of dictionaries
|
|
|
|
>>> merge({1: 'one'}, {2: 'two'})
|
|
{1: 'one', 2: 'two'}
|
|
|
|
Later dictionaries have precedence
|
|
|
|
>>> merge({1: 2, 3: 4}, {3: 3, 4: 4})
|
|
{1: 2, 3: 3, 4: 4}
|
|
|
|
See Also:
|
|
merge_with
|
|
"""
|
|
if len(dicts) == 1 and not isinstance(dicts[0], dict):
|
|
dicts = dicts[0]
|
|
|
|
rv = {}
|
|
for d in dicts:
|
|
rv.update(d)
|
|
return rv
|
|
|
|
|
|
def merge_with(func, *dicts):
|
|
""" Merge dictionaries and apply function to combined values
|
|
|
|
A key may occur in more than one dict, and all values mapped from the key
|
|
will be passed to the function as a list, such as func([val1, val2, ...]).
|
|
|
|
>>> merge_with(sum, {1: 1, 2: 2}, {1: 10, 2: 20})
|
|
{1: 11, 2: 22}
|
|
|
|
>>> merge_with(first, {1: 1, 2: 2}, {2: 20, 3: 30}) # doctest: +SKIP
|
|
{1: 1, 2: 2, 3: 30}
|
|
|
|
See Also:
|
|
merge
|
|
"""
|
|
if len(dicts) == 1 and not isinstance(dicts[0], dict):
|
|
dicts = dicts[0]
|
|
|
|
result = {}
|
|
for d in dicts:
|
|
for k, v in iteritems(d):
|
|
if k not in result:
|
|
result[k] = [v]
|
|
else:
|
|
result[k].append(v)
|
|
return dict((k, func(v)) for k, v in iteritems(result))
|
|
|
|
|
|
def valmap(func, d):
|
|
""" Apply function to values of dictionary
|
|
|
|
>>> bills = {"Alice": [20, 15, 30], "Bob": [10, 35]}
|
|
>>> valmap(sum, bills) # doctest: +SKIP
|
|
{'Alice': 65, 'Bob': 45}
|
|
|
|
See Also:
|
|
keymap
|
|
itemmap
|
|
"""
|
|
return dict(zip(iterkeys(d), map(func, itervalues(d))))
|
|
|
|
|
|
def keymap(func, d):
|
|
""" Apply function to keys of dictionary
|
|
|
|
>>> bills = {"Alice": [20, 15, 30], "Bob": [10, 35]}
|
|
>>> keymap(str.lower, bills) # doctest: +SKIP
|
|
{'alice': [20, 15, 30], 'bob': [10, 35]}
|
|
|
|
See Also:
|
|
valmap
|
|
itemmap
|
|
"""
|
|
return dict(zip(map(func, iterkeys(d)), itervalues(d)))
|
|
|
|
|
|
def itemmap(func, d):
|
|
""" Apply function to items of dictionary
|
|
|
|
>>> accountids = {"Alice": 10, "Bob": 20}
|
|
>>> itemmap(reversed, accountids) # doctest: +SKIP
|
|
{10: "Alice", 20: "Bob"}
|
|
|
|
See Also:
|
|
keymap
|
|
valmap
|
|
"""
|
|
return dict(map(func, iteritems(d)))
|
|
|
|
|
|
def valfilter(predicate, d):
|
|
""" Filter items in dictionary by value
|
|
|
|
>>> iseven = lambda x: x % 2 == 0
|
|
>>> d = {1: 2, 2: 3, 3: 4, 4: 5}
|
|
>>> valfilter(iseven, d)
|
|
{1: 2, 3: 4}
|
|
|
|
See Also:
|
|
keyfilter
|
|
itemfilter
|
|
valmap
|
|
"""
|
|
rv = {}
|
|
for k, v in iteritems(d):
|
|
if predicate(v):
|
|
rv[k] = v
|
|
return rv
|
|
|
|
|
|
def keyfilter(predicate, d):
|
|
""" Filter items in dictionary by key
|
|
|
|
>>> iseven = lambda x: x % 2 == 0
|
|
>>> d = {1: 2, 2: 3, 3: 4, 4: 5}
|
|
>>> keyfilter(iseven, d)
|
|
{2: 3, 4: 5}
|
|
|
|
See Also:
|
|
valfilter
|
|
itemfilter
|
|
keymap
|
|
"""
|
|
rv = {}
|
|
for k, v in iteritems(d):
|
|
if predicate(k):
|
|
rv[k] = v
|
|
return rv
|
|
|
|
|
|
def itemfilter(predicate, d):
|
|
""" Filter items in dictionary by item
|
|
|
|
>>> def isvalid(item):
|
|
... k, v = item
|
|
... return k % 2 == 0 and v < 4
|
|
|
|
>>> d = {1: 2, 2: 3, 3: 4, 4: 5}
|
|
>>> itemfilter(isvalid, d)
|
|
{2: 3}
|
|
|
|
See Also:
|
|
keyfilter
|
|
valfilter
|
|
itemmap
|
|
"""
|
|
rv = {}
|
|
for item in iteritems(d):
|
|
if predicate(item):
|
|
k, v = item
|
|
rv[k] = v
|
|
return rv
|
|
|
|
|
|
def assoc(d, key, value):
|
|
"""
|
|
Return a new dict with new key value pair
|
|
|
|
New dict has d[key] set to value. Does not modify the initial dictionary.
|
|
|
|
>>> assoc({'x': 1}, 'x', 2)
|
|
{'x': 2}
|
|
>>> assoc({'x': 1}, 'y', 3) # doctest: +SKIP
|
|
{'x': 1, 'y': 3}
|
|
"""
|
|
return merge(d, {key: value})
|
|
|
|
|
|
def dissoc(d, key):
|
|
"""
|
|
Return a new dict with the given key removed.
|
|
|
|
New dict has d[key] deleted.
|
|
Does not modify the initial dictionary.
|
|
|
|
>>> dissoc({'x': 1, 'y': 2}, 'y')
|
|
{'x': 1}
|
|
"""
|
|
d2 = d.copy()
|
|
del d2[key]
|
|
return d2
|
|
|
|
|
|
def update_in(d, keys, func, default=None):
|
|
""" Update value in a (potentially) nested dictionary
|
|
|
|
inputs:
|
|
d - dictionary on which to operate
|
|
keys - list or tuple giving the location of the value to be changed in d
|
|
func - function to operate on that value
|
|
|
|
If keys == [k0,..,kX] and d[k0]..[kX] == v, update_in returns a copy of the
|
|
original dictionary with v replaced by func(v), but does not mutate the
|
|
original dictionary.
|
|
|
|
If k0 is not a key in d, update_in creates nested dictionaries to the depth
|
|
specified by the keys, with the innermost value set to func(default).
|
|
|
|
>>> inc = lambda x: x + 1
|
|
>>> update_in({'a': 0}, ['a'], inc)
|
|
{'a': 1}
|
|
|
|
>>> transaction = {'name': 'Alice',
|
|
... 'purchase': {'items': ['Apple', 'Orange'],
|
|
... 'costs': [0.50, 1.25]},
|
|
... 'credit card': '5555-1234-1234-1234'}
|
|
>>> update_in(transaction, ['purchase', 'costs'], sum) # doctest: +SKIP
|
|
{'credit card': '5555-1234-1234-1234',
|
|
'name': 'Alice',
|
|
'purchase': {'costs': 1.75, 'items': ['Apple', 'Orange']}}
|
|
|
|
>>> # updating a value when k0 is not in d
|
|
>>> update_in({}, [1, 2, 3], str, default="bar")
|
|
{1: {2: {3: 'bar'}}}
|
|
>>> update_in({1: 'foo'}, [2, 3, 4], inc, 0)
|
|
{1: 'foo', 2: {3: {4: 1}}}
|
|
"""
|
|
assert len(keys) > 0
|
|
k, ks = keys[0], keys[1:]
|
|
if ks:
|
|
return assoc(d, k, update_in(d.get(k, {}), ks, func, default))
|
|
else:
|
|
innermost = func(d.get(k)) if (k in d) else func(default)
|
|
return assoc(d, k, innermost)
|
|
|
|
|
|
def get_in(keys, coll, default=None, no_default=False):
|
|
"""
|
|
Returns coll[i0][i1]...[iX] where [i0, i1, ..., iX]==keys.
|
|
|
|
If coll[i0][i1]...[iX] cannot be found, returns ``default``, unless
|
|
``no_default`` is specified, then it raises KeyError or IndexError.
|
|
|
|
``get_in`` is a generalization of ``operator.getitem`` for nested data
|
|
structures such as dictionaries and lists.
|
|
|
|
>>> transaction = {'name': 'Alice',
|
|
... 'purchase': {'items': ['Apple', 'Orange'],
|
|
... 'costs': [0.50, 1.25]},
|
|
... 'credit card': '5555-1234-1234-1234'}
|
|
>>> get_in(['purchase', 'items', 0], transaction)
|
|
'Apple'
|
|
>>> get_in(['name'], transaction)
|
|
'Alice'
|
|
>>> get_in(['purchase', 'total'], transaction)
|
|
>>> get_in(['purchase', 'items', 'apple'], transaction)
|
|
>>> get_in(['purchase', 'items', 10], transaction)
|
|
>>> get_in(['purchase', 'total'], transaction, 0)
|
|
0
|
|
>>> get_in(['y'], {}, no_default=True)
|
|
Traceback (most recent call last):
|
|
...
|
|
KeyError: 'y'
|
|
|
|
See Also:
|
|
itertoolz.get
|
|
operator.getitem
|
|
"""
|
|
try:
|
|
return reduce(operator.getitem, keys, coll)
|
|
except (KeyError, IndexError, TypeError):
|
|
if no_default:
|
|
raise
|
|
return default
|