обход списка и умножение каждого элемента

Question

    L = [[0.9, 0.7] ,[0.5, 0.6], [1.1, 1.2]]
    a = 0

    for i in L[len(L)-2]:
       a = L[0][i] * L[1][i]

Я хочу умножить это так, чтобы оно стало. Это не будет работать для более чем 2 значений

(а = 0,9 х 0,5 х 1,1 + 0,7 х 0,6 х 1,2 = 0,999). В основном, учитывая список из списка с одинаковым размером, умножьте его.

без импорта

Answer 1

это версия, которую вы можете использовать для списков и подсписков произвольной длины:

from functools import reduce
from operator import mul

L = [[0.9, 0.7], [0.5, 0.6], [1.1, 1.2]]

res = sum(reduce(mul, p, 1) for p in zip(*L))
# 0.999

по запросу это версия без импорта:

s = 0
for items in zip(*L):
    prod = 1
    for factor in items:
        prod *= factor
    s += prod

---

Пояснение:

zip выбирает соответствующие элементы ваших подсписков:

for p in zip(*L):
    print(p)
# (0.9, 0.5, 1.1)
# (0.7, 0.6, 1.2)

я использую reduce и mul для получения продукта кортежейи sum им.

Answer 2

общий способ:

• условия zip вместе
• применяются произведения элементов.Там нет встроенного, но вы можете сделать это с reduce
• в понимании списка

вот так:

from functools import reduce
import operator

L = [[0.9, 0.7] ,[0.5, 0.6], [1.1, 1.2]]

result = [reduce(operator.mul,terms,1) for terms in zip(*L)]

результат:

[0.49500000000000005, 0.504]

для суммы давайте используем sum:

total = sum(reduce(operator.mul,terms,1) for terms in zip(*L))

примерно дает:

0.999

Answer 3

Как отмечалось, вы можете использовать zip, чтобы получить list из tuple с, следующим образом

L = [[0.9, 0.7] ,[0.5, 0.6], [1.1, 1.2]]
L2 = list(zip(*L))
print(L2) #[(0.9, 0.5, 1.1), (0.7, 0.6, 1.2)]

, которое можно преобразовать в list из list с, следующим образом

L2 = [list(i) for i in L2]
print(L2) #[[0.9, 0.5, 1.1], [0.7, 0.6, 1.2]]

Тогда, если вы используете Python2, вы можете использовать reduce, что без import невозможно в Python3, поэтому вам нужно самостоятельно реализовать умножение с уменьшением, я бы сделал это следующим образом:

def mult(x):
    while len(x)>=2: x[:2] = [x[0]*x[1]]
    return x[0]

Обратите внимание, что я предположил, что в вашем списке не менее 1 элемента, и данные в вашем списке верны (могут быть умножены), и вам больше не понадобится список после подачи его в mult, рассмотрите следующий пример:

t = [9,5,3]
mt = mult(t)
print(mt) # 135 as you might expect
print(t) # [135] i.e. list with 1 element equal to value returned by mult

Если это не проблема в этом случае, вы можете сделать:

a = sum([mult(i) for i in L2])
print(a) # 0.9990000000000001

Однако, если вы хотите сохранить оригинальный список и использовать mult, то вы можете использовать копию списка, например:

k = [3,10,5]
mk = mult(k[:])
print(mk) # 150
print(k) # [3,10,5]

Обратите внимание, что mult, как показано, может быть легко переработан для использования любой арифметической операции.

Answer 4

Возможное решение с numpy:

import numpy as np

L = [[0.9, 0.7] ,[0.5, 0.6], [1.1, 1.2]]
L = np.array(L)
np.sum([np.prod(L[:,i]) for i in range(L.shape[1])])

Пройдите по всем столбцам массива 2d и вычислите значение каждого столбца.Затем суммируйте все результаты.

Вывод

0.9990000000000001

Answer 5

использовать функциональное программирование

>>> from functools import reduce
>>> def multiply(x, y):
...     return x * y
>>> L = [[0.9, 0.7] ,[0.5, 0.6], [1.1, 1.2]]
>>> sum([reduce(multiply, item) for item in zip(*L)])
0.9990000000000001

Answer 6

Наивная реализация

L = [[0.9, 0.7] ,[0.5, 0.6], [1.1, 1.2]]
b = []
for i in range(len(L)) :
    a=1 
    for j in range(len(L[0])):
        a*=L[i][j]
    b.append(a)

Answer 7

Вы можете получить нужные пары, поменяв строки в столбцы, что делается с помощью идиомы

columns = zip(*rows)

Затем просто реализуйте product (аналогично sum)

import itertools
import operator

def product(iterable):
    return itertools.reduce(operator.mul, iterable, 1)
    # or:
    # acc = 1
    # for el in iterable:
    #     acc *= el
    # return acc

И используйте понимание списка.

results = sum(product(col) for col in columns)

Answer 8

Примерно так:

L = [[0.9, 0.7] ,[0.5, 0.6], [1.1, 1.2]]
a = (1, 1)

for i in L:
   a = (a[0] * i[0], a[1] * i[1])

print(a)

, что дает

(0,49500000000000005, 0,504)