多个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 sigma表示法，它将是4个四个循环。我想知道这样的事情是否可以在函数中推广

Answer 1

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

  

输入可迭代项的笛卡尔积。

     

大致等同于生成器表达式中的嵌套for循环。例如，product(A, 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

我的建议是：

SELECT employee_No, Employee_name AS dependent_name, 'principal' AS relationship
FROM Employees
UNION ALL
SELECT e.employee_No, d.dependent_name, d.relationship
FROM Employees e
JOIN Dependents d on d.employee_No = e.employee_No
ORDER BY employee_No DESC, relationship = 'principal' DESC

甚至可以将employee_No dependent_name relationship 1558 Bean principal 1558 Mary Daughter 1558 Kelvin Son 1557 Juliet principal 1556 Zeke principal 1556 Janet Spouse 泛化为一个函数：

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

---

说明：

将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

或者，如果您有更多的变量可以使用简写表示法，可以使用functools.reduce：

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)

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