Python 如何对具有任意嵌套的两个形状相同的列表执行元素级算术运算（例如，加法、减法、乘法）

我想对包含数字的两个Python列表或可能再次包含数字或列表的多个嵌套列表执行元素级数学运算（例如sum、multiply…）

执行该操作时，两个列表的形状相等。此外，结果应与两个输入列表的形状相同

形状可能在以下方面有所不同：

长度

宽度（即嵌套数量）

顺序（例如，列表以数字开头，后跟嵌套列表，但也可能是以嵌套列表开头，后跟数字）

每次我想要执行数学运算时，形状都会任意改变

如何对任意形状的列表执行数学运算

在过去，我已经为每个不同的形状实现了一段定制的代码，类似于，，，，但我想知道是否已经有了一个更通用的解决方案，即库或参考代码

示例1（总和）：

a=[1,2,3,4,5,6,7,8]]
b=[10,20,30,40，[50,60,70,80]]
c=元素WiseSum（a，b）
C

会导致

[11,22,33,44,55,66,77,88]]

示例2（总和）：

d=[1,2,3,4,5,6,7]，[8,9,10]]
e=[10,20,30,40,50,60,70]，[80]，[90100]]
f=元素WiseSum（d，e）
F

会导致

[11,22,33,44,55,66,77]，[88]，[99110]]

示例3（乘法）：

g=[[4,2]，1,1]
h=[[8,3]，1,9]
i=元素WiseMul（g，h）
我

会导致

[[32,6]，1,9]

---

elementwiseSUM（）

和

elementwiseMUL（）

是我正在寻找的库函数的占位符。

它并没有完全利用内置python模块（除了

操作符

），但是类似的东西怎么样

def element_wise(list_a, list_b, operator):
    result = []
    assert len(list_a) == len(list_b)
    for a, b in zip(list_a, list_b):
        is_lists = isinstance(a, list) and isinstance(b, list)
        is_ints = isinstance(a, int) and isinstance(b, int)

        if is_lists:
            result.append(element_wise(a, b, operator))
        elif is_ints:
            result.append(operator(a, b))
        else:
            raise ValueError
    return result


def main():

    from operator import add, mul

    list_sum_a = [ 1,  2,  3,  4, [ 5,  6,  7,  8]]
    list_sum_b = [10, 20, 30, 40, [50, 60, 70, 80]]

    list_mul_a = [[4, 2], 1, 1]
    list_mul_b = [[8, 3], 1, 9]

    result_sum = element_wise(list_sum_a, list_sum_b, add)
    result_mul = element_wise(list_mul_a, list_mul_b, mul)

    print(result_sum)
    print(result_mul)

    return 0


if __name__ == "__main__":
    import sys
    sys.exit(main())

输出：

[11, 22, 33, 44, [55, 66, 77, 88]]
[[32, 6], 1, 9]

---

这是我想出的解决办法

a = [ 1,  2,  3,  4, [ 5,  6,  7,  8]]
b = [10, 20, 30, 40, [50, 60, 70, 80]]

def element_wise(a, b, f):
    return [element_wise(i, j, f) if type(i) == list and type(j) == list else f(i, j) for i, j in zip(a, b)]

c = element_wise(a, b, lambda x, y: x + y) # [11, 22, 33, 44, [55, 66, 77, 88]]

因此，

a

和

b

是您的列表，

f

是您想要应用的函数，正如您所看到的，我编写了一个简单的函数来添加int

---

您可以编写自己的lambda，也可以只使用

操作符
模块。
不确定是否有任何具有内置方法的库，但使用一个不会比自己创建一个更快

示例不是任何类型的生产代码，但展示了一种简单的方法：

import operator
ops = {
    "+": operator.add,
    "-": operator.sub,
    "*": operator.mul,
    "/": operator.div
}

a = [ 1,[ 2, 3],  4, [ 5, 6, 7], [[ 8], [ 9, 10]]]
b = [10,[20,30], 40, [50,60,70], [[80], [90,100]]]


def foo(x, y, op):
    if type(x) == list:
        return [foo(a, b, op) for a, b in zip(x, y)]
    else:
        return ops[op](x, y)

#Run
print foo(a, b, '+')

我给出了解决方案代码，例如1和3，但这个解决方案完全取决于您的列表，即列表中有多少列表，因为我使用for循环，这取决于您的列表

示例1（求和解决方案）

示例2（乘法解）

当形状不相同时，你如何处理这种情况？在执行算术运算时，两个列表的形状总是相等的。我能想到的唯一一种情况是“一般”中的算术运算如果两个列表中的一个是/包含一个标量，那么这样做是有意义的。我喜欢这个列表，因为它可以更干净地调用函数+更通用的lambda。虽然“and”似乎不需要，（只勾选一个），因为无论列表的格式是否正确，它都会中断。你完全正确，我只是添加了
和
以确保完整性：）
a = [ 1, 2, 3, 4,[ 5, 6, 7, 8]]
b = [10,20,30,40,[50,60,70,80]]   
def elementwiseSUM(a, b):
    pl = []
    cl = []
    for i, j in zip(a, b):
        if type(i) and type(j) != list:
            pl.append(i+j)
        if type(i) and type(j) == list:
            for k, l in zip(i, j):
                cl.append(k+l)
    pl.append(cl)
    return pl
print(elementwiseSUM(a, b))

g = [[4,2],1,1]
h = [[8,3],1,9]
def elementwiseMUL(g, h):
    pl = []
    cl = []
    for i, j in zip(g, h):
        if type(i) and type(j) != list:
            cl.append(i*j)
        if type(i) and type(j) == list:
            for k, l in zip(i, j):
                pl.append(k*l)
    pl.append(cl)
    return pl
print(elementwiseMUL(g, h))