Python 多西格玛符号

给定这个公式，用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)

这很有效。但是假设我想要一个三西格玛符号，比如

这将与上面的完全相同，只需添加另一个循环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个四循环。我想知道这样的东西是否可以在函数中推广

参见。如果您对它的实现方式感兴趣，那么在链接中有一个模拟实现

输入变量的笛卡尔积

大致相当于生成器表达式中的嵌套for循环。例如，

产品（A，B）

返回的值与

相同（A中x的（x，y）表示B中y的值）

嵌套循环像里程表一样循环，最右边的元素在每次迭代中前进。该模式创建了一个字典顺序，这样，如果输入的iterables被排序，那么产品元组将按排序顺序发出

我的建议是：

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))

您甚至可以将

幂

概括为一个函数：

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

选项一起使用，总和可以写为：

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))

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

---

利用

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

---

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

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

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