несколько сигма нотаций 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)

это работает. Но, скажем, я хотел третью сигма-нотацию, такую ​​как

Что было бы точно так же, как описано выше, просто добавив еще один цикл 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

Решение, использующее преимущества 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 2

См. 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 3

Вот решение без какого-либо дополнительного импорта, использующее рекурсию, чтобы сделать количество внутренних циклов динамическим. Он принимает внутреннюю формулу как функцию, из которой берется количество аргументов для определения необходимой глубины рекурсии.

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

Answer 4

Мое предложение:

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

---

Объяснение:

с использованием product с опцией 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))

или, для краткости записи, если у вас гораздо больше переменных, вы можете использовать functools.reduce:

from operator import mul
from functools import reduce

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