关于python：在嵌套dict中按键路径映射函数，包括切片，通配符和不规则层次结构

Map a function by key path in nested dict including slices, wildcards and ragged hierarchies

这个问题是基于这里和这里的扩展。

在嵌套dict中将函数映射到指定键路径的好方法是什么，包括以下路径规范：

给定路径位置的键列表

关键切片(假设排序)

通配符(即路径位置上的所有键)

通过忽略不在给定级别上出现的键来处理不规则的层次结构

如果这样做比较简单，可以假设只有dict是嵌套的，没有dict列表，因为前者可以通过dict(enumerate(...))获得。

但是，层次结构可能是不规则的，例如：

1
2
3
4

data = {0: {'a': 1, 'b': 2},
1: {'a': 10, 'c': 13},
2: {'a': 20, 'b': {'d': 100, 'e': 101}, 'c': 23},
3: {'a': 30, 'b': 31, 'c': {'d': 300}}}

希望能够这样指定密钥路径：

1	map_at(f, ['*',['b','c'],'d'])

1
2
3
4

{0: {'a': 1, 'b': 2},
1: {'a': 10, 'c': 13},
2: {'a': 20, 'b': {'d': f(100), 'e': 101}, 'c': 23},
3: {'a': 30, 'b': 31, 'c': {'d': f(300)}}}

这里，f映射到关键路径[2,b,d]和[3,c,d]。

切片将被指定为，例如[0:3,b]。

我认为路径规范是明确的，尽管可以概括为，例如，匹配键路径前缀(在这种情况下，f也将映射到[0，b]'和其他路径)。

这可以通过理解和递归来实现，还是需要大量的提升来捕获KeyError等？

请不要建议熊猫作为替代品。

相关讨论

我不太喜欢伪代码，但是在这种情况下，你需要写一个算法。以下是我对您要求的理解：

map_at(func, path_pattern, data)：

如果path_pattern不是空的

如果data是终端，那就是失败：我们没有匹配完整的path_pattern？所以没有理由应用这个函数。只需返回data。
否则，我们必须探索数据中的每一条路径。如果可能的话，我们会消耗path_pattern的头部。也就是返回一个dict data key->map_at(func, new_path, data value)，其中new_path是path_pattern的tail，如果键与head匹配，则返回"路径"模式本身。

否则，它就成功了，因为所有的path_pattern都被消耗掉了：

如果data是终端，返回func(data)。
否则，找到叶子，用func：返回一个dict data key->map_at(func, [], data value)。

笔记：

我假设模式*-b-d与路径0-a-b-c-d-e匹配；
这是一个迫切需要的算法：路径的头部总是在可能的时候被消耗掉；
如果路径被完全占用，则应映射每个终端；
这是一个简单的DFS，因此我想用堆栈编写迭代版本是可能的。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def map_at(func, path_pattern, data):
def matches(pattern, value):
try:
return pattern == '*' or value == pattern or value in pattern
except TypeError: # EDIT: avoid"break" in the dict comprehension if pattern is not a list.
return False

if path_pattern:
head, *tail = path_pattern
try: # try to consume head for each key of data
return {k: map_at(func, tail if matches(head, k) else path_pattern, v) for k,v in data.items()}
except AttributeError: # fail: terminal data but path_pattern was not consumed
return data
else: # success: path_pattern is empty.
try: # not a leaf: map every leaf of every path
return {k: map_at(func, [], v) for k,v in data.items()}
except AttributeError: # a leaf: map it
return func(data)

注意，tail if matches(head, k) else path_pattern表示：如有可能，消费head。要在模式中使用范围，只需使用range(...)。

正如你所看到的，你永远无法摆脱第二种情况。：如果path_pattern是空的，您只需映射所有的叶子就可以了。这在这个版本中更清楚了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def map_all_leaves(func, data):
"""Apply func to all leaves"""
try:
return {k: map_all_leaves(func, v) for k,v in data.items()}
except AttributeError:
return func(data)

def map_at(func, path_pattern, data):
def matches(pattern, value):
try:
return pattern == '*' or value == pattern or value in pattern
except TypeError: # EDIT: avoid"break" in the dict comprehension if pattern is not a list.
return False

if path_pattern:
head, *tail = path_pattern
try: # try to consume head for each key of data
return {k: map_at(func, tail if matches(head, k) else path_pattern, v) for k,v in data.items()}
except AttributeError: # fail: terminal data but path_pattern is not consumed
return data
else:
map_all_leaves(func, data)

编辑

如果要处理列表，可以尝试以下操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def map_at(func, path_pattern, data):
def matches(pattern, value):
try:
return pattern == '*' or value == pattern or value in pattern
except TypeError: # EDIT: avoid"break" in the dict comprehension if pattern is not a list.
return False

def get_items(data):
try:
return data.items()
except AttributeError:
try:
return enumerate(data)
except TypeError:
raise

if path_pattern:
head, *tail = path_pattern
try: # try to consume head for each key of data
return {k: map_at(func, tail if matches(head, k) else path_pattern, v) for k,v in get_items(data)}
except TypeError: # fail: terminal data but path_pattern was not consumed
return data
else: # success: path_pattern is empty.
try: # not a leaf: map every leaf of every path
return {k: map_at(func, [], v) for k,v in get_items(data)}
except TypeError: # a leaf: map it
return func(data)

想法很简单：enumerate相当于dict.items的清单：

1
2
3
4

>>> list(enumerate(['a', 'b']))
[(0, 'a'), (1, 'b')]
>>> list({0:'a', 1:'b'}.items())
[(0, 'a'), (1, 'b')]

因此，get_items只是返回dict项、list项(index、value)或引发错误的包装器。

缺点是列表在过程中转换为dict：

1
2
3

>>> data2 = [{'a': 1, 'b': 2}, {'a': 10, 'c': 13}, {'a': 20, 'b': {'d': 100, 'e': 101}, 'c': 23}, {'a': 30, 'b': 31, 'c': {'d': 300}}]
>>> map_at(type,['*',['b','c'],'d'],data2)
{0: {'a': 1, 'b': 2}, 1: {'a': 10, 'c': 13}, 2: {'a': 20, 'b': {'d': <class 'int'>, 'e': 101}, 'c': 23}, 3: {'a': 30, 'b': 31, 'c': {'d': <class 'int'>}}}

编辑

因为您在寻找类似于xpath的json，所以可以尝试https://pypi.org/project/jsonpath/或https://pypi.org/project/jsonpath rw/。(我没有测试那些libs)。

相关讨论

我希望它能与list和dict的任何嵌套组合一起工作。给定data2 = [{'a': 1, 'b': 2}, {'a': 10, 'c': 13}, {'a': 20, 'b': {'d': 100, 'e': 101}, 'c': 23}, {'a': 30, 'b': 31, 'c': {'d': 300}}]，map_at(type,['*',['b','c'],'d'],data2)返回输入，但是顶级通配符应该映射到列表中的所有dict。还尝试使用诸如0:2和:之类的片来代替通配符，从而导致语法错误。
@alanclvitti i没有实现切片，但是您可以使用range(0,2)而不是0:2。对于列表，我假设你只有听写。如果列表仅位于顶层，则很容易修复，但是如果您有列表或列表中的dict值，则会变得更复杂，您必须检查元素的类型。
@alancalvitti您是否在JSON数据上尝试实现类似en.wikipedia.org/wiki/xpath/https://en.wikipedia.org/wiki/xs&zwnj；&8203；的功能？如果是这样的话，你最好试试现有的图书馆。查看我的编辑列表。
谢谢，是的，我真的应该发布一个关于列表、dict、tuples和任何其他容器对象的一般嵌套组合的扩展Q。是的，我知道enumerate，但它只能在内部使用——类型应该保持不变。我不确定XLST是否能像基于XML那样工作，但总体思想是一样的，比如说元组，键可能是模块化的，所以需要消除歧义。我经常使用Wolfram语言，它正好具有这种类型的功能(既有就地查询也有getter)，实际上字典键可以是任意表达式(可变)。
@alancalvitti我认为你可以在python中实现你想要的，但是你不会得到完整的代码答案，所以，这是一个复杂的问题。查看我对库的新编辑。
谢谢你来看看。但是您不能期望在py中做您在wl中可以做的事情，wl不仅是函数vs oo，而且是它的符号处理和模式匹配的b/c。Python就像汇编语言，相对来说。
虽然0是一个密钥：map_at(type,[0,['b','c'],'d'],data)，但这并不起作用，但如果它在[0,0]列表中：map_at_(type,[[0,0],['b','c'],'d'],data)，它就起作用了。你能解释一下吗？
在我之前的评论中，用2代替0-结果与我描述的相同(我使用了修改过的data)。
我可以解释：这是一只虫子！看我的编辑。如果使用列表，例如[2]，测试value in pattern返回True。如果你使用int，2，同样的测试会产生一个TypeError，如果听不到，就会破坏听写理解。现在已经修好了。
@好吧，但还是不喜欢它把list改成dict。我将尝试通过在类型上进行分支来修改。我对query和query_at功能有一个更广泛的议程，这些功能还可以包括一个功能列表(返回结果列表)和功能管道。最好单独问。
型不幸的是，来自文档的re-jsonpath rw："数组切片(请注意，到目前为止，由于缺乏需求，步骤还没有实现)"
型@alancalvitti"step is unimplemented"：您可以有切片，但元素之间的步骤始终是1(例如，no[1,3,5,7]切片)。不过，我不确定jsonpath-rw是否具备您所需要的所有功能。最好单独问一个问题，我不确定这是个好主意，因为你不是在寻找一个特定问题的解决方案，但你需要找到(或写)一个完整的库。
型使用map_at(type,['*','b'], data)时，此方法将重复使用并应用于更深的层次，例如'b': {'d': int, 'e': int}，而不是返回b: int，就像路径表达式(如['*','b','*']一样。

我想您可能会喜欢这个刷新的生成器实现-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

def select(sel = [], d = {}, res = []):

# (base case: no selector)
if not sel:
yield (res, d)

# (inductive: a selector) non-dict
elif not isinstance(d, dict):
return

# (inductive: a selector, a dict) wildcard selector
elif sel[0] == '*':
for (k, v) in d.items():
yield from select \
( sel[1:]
, v
, [*res, k]
)

# (inductive: a selector, a dict) list selector
elif isinstance(sel[0], list):
for s in sel[0]:
yield from select \
( [s, *sel[1:]]
, d
, res
)

# (inductive: a selector, a dict) single selector
elif sel[0] in d:
yield from select \
( sel[1:]
, d[sel[0]]
, [*res, sel[0]]
)

# (inductive: single selector not in dict) no match
else:
return

它是这样工作的-

1
2
3
4
5
6
7
8
9
10
11
12

data = \
{ 0: { 'a': 1, 'b': 2 }
, 1: { 'a': 10, 'c': 13 }
, 2: { 'a': 20, 'b': { 'd': 100, 'e': 101 }, 'c': 23 }
, 3: { 'a': 30, 'b': 31, 'c': { 'd': 300 } }
}

for (path, v) in select(['*',['b','c'],'d'], data):
print(path, v)

# [2, 'b', 'd'] 100
# [3, 'c', 'd'] 300

因为select返回一个iterable，所以可以在它上面使用传统的map函数。-

1
2
3
4
5
6
7
8
9

s = select(['*',['b','c'],'d'], data)

work = lambda r: f"path: {r[0]}, value: {r[1]}"

for x in map(work, s):
print(x)

# path: [2, 'b', 'd'], value: 100
# path: [3, 'c', 'd'], value: 300

相关讨论

这不是很简单，效率也不高，但它应该可以工作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def map_at(f,kp,d): return map_at0(f,kp,d,0)
def slice_contains(s,i): # no negative-index support
a=s.start or 0
return i>=a and (s.end is None or i<s.end) and\
not (i-a)%(s.step or 1)
def map_at0(f,kp,d,i):
if i==len(kp): return f(d)
if not isinstance(d,dict): return d # no such path here
ret={}
p=kp[i]
if isinstance(p,str) and p!='*': p=p,
for j,(k,v) in enumerate(sorted(d.items())):
if p=='*' or (slice_contains(p,j) if isinstance(p,slice) else k in p):
v=map_at0(f,kp,v,i+1)
ret[k]=v
return ret

请注意，这将复制它展开的每个字典(因为它与键路径匹配，即使没有进一步的键匹配，并且从不应用f)，但通过引用返回不匹配的子节。还要注意，通过将EDOCX1[1]放入列表中，可以"引用"它。

相关讨论