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个值

p（a ＝ 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

一般方法：

一起压缩术语
应用元素的乘积。没有内置功能，但是您可以使用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

类似的东西：

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）

Answer 4

您可以通过将行交换为列来获得所需的对，这是用成语完成的

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 5

天真的实现

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 6

使用函数式编程

import sys
from PyQt5 import QtCore, QtGui, QtWidgets

class Main(QtWidgets.QWizard):
    def __init__(self, parent=None):
        super(Main, self).__init__(parent)
        buttons = [
            QtWidgets.QWizard.Stretch, 
            QtWidgets.QWizard.BackButton,
            QtWidgets.QWizard.NextButton, 
            QtWidgets.QWizard.FinishButton
        ]
        self.setButtonLayout(buttons)
        self.addPage(FirstPage())
        self.addPage(SecondPage())

class FirstPage(QtWidgets.QWizardPage):
    def __init__(self, parent=None):
        super(FirstPage, self).__init__(parent)
        self.setTitle("First page")

class SecondPage(QtWidgets.QWizardPage):
    def __init__(self, parent=None):
        super(SecondPage, self).__init__(parent)
        self.setTitle("Second page")

if __name__ == '__main__':
    app = QtWidgets.QApplication(sys.argv)
    main = Main()
    main.show()
    sys.exit(app.exec_())

Answer 7

可能使用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数组的所有列并计算每列的prod。然后将所有结果相加。

输出

0.9990000000000001

Answer 8

如前所述，您可以按照以下方式使用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，而在Python3中没有import是不可能的，因此您需要自己实现约数乘法，我可以通过以下方式实现：

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可以很容易地改制成任何算术运算。

遍历列表列表并乘以每个元素

8 个答案:

说明：