多个sigma符号python

Question

给定此公式在python中实现它

因此对于n = 3

x = []
y = []
for i in range(1, 4):
    x.append(i)

for j in range(1, 4):
    y.append(j**2)



total = 0
for i in range(len(x)):
    for j in range(len(y)):

        total = total + x[i] *  y[j] 
print(total)

这很有效。 但是说我想要第三个sigma符号，例如

通过添加另一个循环k，与上面完全相同。

我的问题是，如果有一种方法可以在给定n的函数中对此进行推广，即内部的值（即j ^ 2 * i）。 我很难理解更多循环

def manysums(n, L : i.e. [[1, 2,3], [1,4,9], [1, 8, 27]]):
    pass

如上所述，列表中的值总计为总和值

L = [[1,2,3]，[1,4,9]，[1,8,27]，[1,2,3]]

将是4西格玛符号，这将是4四个循环。 我想知道这样的东西是否可以在函数中推广

Answer 1

请参阅itertools.product 。 如果您对它的实现方式感兴趣，那么链接中就会有一个模拟实现

输入迭代的笛卡儿乘积。

大致相当于生成器表达式中的嵌套for循环。 例如， product(A, B)与product(A, B) ((x,y) for x in A for y in B)相同((x,y) for x in A for y in B)返回相同的值((x,y) for x in A for y in B) 。

嵌套循环像里程表一样循环，最右边的元素在每次迭代时前进。 此模式创建了一个词典排序，以便在输入的可迭代内容进行排序时，产品元组按排序顺序发出。

from itertools import product
for i,j,k in product([1,2,3],[1,4,9],[1,8,27]):
  print(j**2 * i * k**3)

Answer 2

利用numpy解决方案：

import numpy as np

from functools import reduce

def multiple_sigma(n, exponents):
    arrays = [np.arange(1, n + 1) ** exponent for exponent in exponents]
    return reduce(np.multiply.outer, arrays).sum()

# j ** 2, i ** 1, k ** 3 for n in [1, 3]
multiple_sigma(n=3, exponents=[2, 1, 3]) 

输出：

3024

Answer 3

我的建议是：

from itertools import product
from operator import mul
from functools import reduce

n = 3
powers = zip(*((i, i**2, i**3) for i in range(1, n+1)))
s = sum(reduce(mul, p) for p in product(*powers))

你甚至可以将powers推广到一个函数：

def powers(n, exponents):
    return [[i**e for i in range(1, n+1)] for e in exponents]

powers(n=3, exponents=[2, 1, 3]))
# [[1, 4, 9], [1, 2, 3], [1, 8, 27]]

---

说明：

使用带有repeat选项的product ，总和可以写成：

from itertools import product 

n = 3
s = sum(j**2 * i * k**3 for i, j, k in product(range(1, n+1), repeat=3)))
print(s)

这可以很容易地推广到更多变量。

如果效率是一个问题，你可以预先计算权力，然后总结：

powers = list(zip(*((i, i**2, i**3) for i in range(1, n+1))))
# [(1, 2, 3), (1, 4, 9), (1, 8, 27)]

s = sum(p0 * p1 * p2 for p0, p1, p2 in product(*powers))

或者，如果你有更多的变量，为了保持符号简短你可以使用functools.reduce ：

from operator import mul
from functools import reduce

s = sum(reduce(mul, p) for p in product(*powers))

Answer 4

这是一个没有任何额外导入的解决方案，使用递归来使内部循环的数量动态化。 它将内部公式作为函数，其中参数的数量用于确定所需的递归深度。

def manysums(f, n):
    depth = f.__code__.co_argcount   # number of nested loops        
    def inner_loop(vals):        
        if len(vals) == depth - 1:     # last (most-inner) loop?
            return sum(f(*(vals + (i,))) for i in range(1,n+1))  
        else:
            return sum(inner_loop(vals + (i,)) for i in range(1,n+1))                    
    return inner_loop(())

使用这样：

f = lambda i, j, k : j**2 * i * k**3
manysums(f, 3)
# --> 3024

f = lambda i, j, k, l : j**2 * i * k**3 * l
manysums(f, 3)
# --> 18144