Python 定义累积？（高阶函数）

我想使用

accumulate（op，init，seq）

定义一个函数

accumulate（op，init，seq）

：

函数

accumulate\n（op，init，sequences）

与

accumulate（op，init，seq）

类似，只是它的第三个参数是长度相等的序列序列。它应用累加函数

op

组合序列的所有第一个元素、序列的所有第二个元素，依此类推，并返回结果序列。例如，如果s是一个包含四个序列的序列，

[[1,2,3]，[4,5,6]，[7,8,9]，[10,11,12]

，那么

累加n（λx，y:x+y，0，s）

的值应该是序列

[22,26,30]

def accumulate(op, init, seq):
    if not seq:
        return init
    else:
        return op(seq[0], accumulate(op, init, seq[1:]))

def accumulate_n(op, init, sequences):
    if (not sequences) or (not sequences[0]):
        return type(sequences)()
    else:
        return ( [accumulate(op, init, ??)]
               + accumulate_n(op, init, ??) )

但是我被困在

？

部分，因为我不知道该包含哪些内容。我想我可以使用

map

内置函数，但仍然不确定该做什么

下面是函数应该执行的示例：

accumulate_n(lambda x,y: x+y, 0, [[1,2],[3,4],[5,6]])   
# [9, 12]
accumulate_n(lambda x,y: x+y, 0, [[1,4],[5,7],[9,10]])  
# [15, 21]
accumulate_n(lambda x,y: x+y, 0, [[9,8],[7,6],[5,4]])   
# [21, 18]

---

如果有人能帮忙，我会非常感激的！谢谢大家!

内置的

zip

功能，结合使用

*

解包 参数列表，便于从参数列表中选择第n个值 序列的顺序：

def accumulate_n(op, init, sequences):
    if (not sequences) or (not sequences[0]):
        return type(sequences)()
    else:
        return [accumulate(op, init, i) for i in zip(*sequences)]

---

看起来你想得到：

• 每个序列的第一个元素的列表，可以是序列中的s的

  [s[0]

  ，以及
• 每个序列的剩余元素的列表，对于序列中的s可以是

  [s[1:]

总共：

def accumulate(op, init, seq):
    if not seq:
        return init
    else:
        return op(seq[0], accumulate(op, init, seq[1:]))

def accumulate_n(op, init, sequences):
    if (not sequences) or (not sequences[0]):
        return type(sequences)()
    else:
        heads = [s[0] for s in sequences]
        tails = [s[1:] for s in sequences]

        return ([accumulate(op, init, heads)]
               + accumulate_n(op, init, tails))

但无论如何，我会按行而不是按列执行此操作，并要求

init

本身就是一个序列：

def accumulate_n_(op, init, sequences):
    try:
        head = next(sequences)
    except StopIteration:
        return init

    return accumulate_n_(
        op,
        [op(x, y) for x, y in zip(init, head)],
        sequences,
    )

def accumulate_n(op, init, sequences):
    return accumulate_n_(op, init, iter(sequences))

清洁势在必行：

def accumulate_n(op, init, sequences):
    for s in sequences:
        init = [op(x, y) for x, y in zip(init, s)]

    return init

最后，使用

functools.reduce

：

def zipper(op):
    return lambda xs, ys: [op(x, y) for x, y in zip(xs, ys)]

def accumulate_n(op, init, sequences):
    return reduce(zipper(op), sequences, init)

---

在我看来，您可以使用

reduce

进行

累积

。。。仍然要注意，确定

累计\u n

应该做什么…。@juanpa.arrivillaga抱歉这个不清楚的问题！刚刚编辑了我的问题，解释了

accumulate\n

应该做什么