嵌套可迭代映射/过滤

Question

我想映射和过滤 Python 中匹配特定条件的嵌套可迭代对象的元素，如下所示：

items = [func(item) if map_condition(item) else item for item in items if filter_condition(item)]

但推广到嵌套可迭代对象，因此例如输入如下：

items = [[1, 2], [[3, 4, 4.0, 5], 5], 6.0, 'ciao', 7, 8, {1, 2, 3}]

应用函数nested_map_filter(items, func, map_condition, filter_condition)如下所示：

new_items = nested_filter_map(items, str, lambda x: isinstance(x, int), lambda x: not isinstance(x, str))
new_items = nested_filter_map(items, str, None, None)
new_items = nested_filter_map(items, str, None, lambda x: not isinstance(x, float))
new_items = nested_filter_map(items, str, lambda x: isinstance(x, int), None)
new_items = nested_filter_map(items, str, lambda x: isinstance(x, int), lambda x: not isinstance(x, float))

将分别导致：

# [['1', '2'], [['3', '4', 4.0, '5'], '5'], 6.0, '7', '8', {'2', '1', '3'}]
# [['1', '2'], [['3', '4', '4.0', '5'], '5'], '6.0', 'ciao', '7', '8', {'2', '1', '3'}]
# [['1', '2'], [['3', '4', '5'], '5'], 'ciao', '7', '8', {'2', '1', '3'}]
# [['1', '2'], [['3', '4', 4.0, '5'], '5'], 6.0, 'ciao', '7', '8', {'2', '1', '3'}]
# [['1', '2'], [['3', '4', '5'], '5'], 'ciao', '7', '8', {'2', '1', '3'}]

标准库中是否有标准结构或其他东西来执行此操作？

编辑：我改进了术语，使map/filter与内置的含义相匹配，并添加了更多测试用例。

---

编辑

我写了这样的东西，可以完成这项工作。

(编辑2(我的问题更多：我是否在重新发明轮子？是否可以/方便地将其编写为生成器？

def deep_filter_map(
items,
func=None,
map_condition=None,
filter_condition=None,
avoid=(str, bytes),
max_depth=-1):
if func is None:
def func(x): return x
if map_condition is None:
def map_condition(_): return True
if filter_condition is None:
def filter_condition(_): return True
container = type(items)
new_items = []
for item in items:
try:
no_expand = avoid and isinstance(item, avoid)
if no_expand or max_depth == 0 or item == next(iter(item)):
raise TypeError
except TypeError:
if filter_condition(item):
new_items.append(func(item) if map_condition(item) else item)
else:
new_items.append(
deep_filter_map(
item, func, map_condition, filter_condition, avoid, max_depth - 1))
return container(new_items)

Answer 1

据我所知，标准库中没有这样的函数，但是您可以通过将其拆分为可以独立使用的较小部分来提高自己解决方案的可重用性(以及可维护性和可测试性(。首先，一个包装函数用于有条件地应用某个函数，然后是两个函数，用于将任何函数应用于嵌套可迭代对象的元素或有条件地过滤这些函数。

def cond_apply(cond, func):
return lambda x: func(x) if cond(x) else x
def deep_map(func, lst, types=(list, tuple, set)):
if isinstance(lst, types):
return type(lst)(deep_map(func, x) for x in lst)
else:
return func(lst)
def deep_filter(cond, lst, types=(list, tuple, set)):
if isinstance(lst, types):
return type(lst)(deep_filter(cond, x) for x in lst if isinstance(x, types) or cond(x))
else:
return lst
items = [[1, 2], [[3, 4, 4.0, 5], 5], 6.0, 'ciao', 7, 8, {1, 2, 3}]
print(deep_map(cond_apply(lambda x: isinstance(x, int), str),
deep_filter(lambda x: not isinstance(x, str), items)))
# [['1', '2'], [['3', '4', 4.0, '5'], '5'], 6.0, '7', '8', {'1', '3', '2'}]

这样，该功能可以单独使用，您还可以例如反转map和filter步骤。当然，您仍然可以将这三个函数包装到另一个函数中，提供所有参数以便于使用。