2
votes

parcourir une liste de liste et multiplier chaque élément

    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]
I wish to multiply this so that it becomes. This wont work for more than 2 values(a = 0.9 x 0.5 x 1.1 + 0.7 x 0.6 x 1.2 = 0.999). Basically given a list of list each with same size multiply it.without imports

python list

4 commentaires

Expliquez, dans vos propres mots, le raisonnement derrière la partie len (L) -2 et la multiplication. Supposons qu'il y ait 100 paires dans L; combien de valeurs devez-vous multiplier à chaque étape de multiplication et combien de ces résultats devez-vous additionner?

pourquoi avez-vous ajouté sans importations ?

J'ai oublié de le mentionner

choix personnel et merci beaucoup!

8 Réponses :

1
votes

Quelque chose comme ceci:

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)

qui donne

(0.49500000000000005, 0.504)

0 commentaires

3
votes

ceci est une version que vous pouvez utiliser pour les listes et sous-listes de longueur arbitraire:

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

comme demandé ceci est une version sans importations:

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

0 commentaires

2
votes

la manière générale:

compresser les termes ensemble
appliquer le produit des éléments. Il n'y a pas de fonction intégrée mais vous pouvez le faire avec reduce
dans une compréhension de liste

comme ceci:

0.999

résultat:

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

pour la somme utilisons somme :

[0.49500000000000005, 0.504]

donne approximativement:

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 commentaires

1
votes

Vous pouvez obtenir les paires que vous voulez en échangeant des lignes en colonnes, ce qui est fait avec l'idiome

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

Ensuite, implémentez simplement un produit (analogue à 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

Et utilisez une compréhension de liste.

columns = zip(*rows)

0 commentaires

1
votes

Implémentation naïve

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)

0 commentaires

1
votes

utiliser la programmation fonctionnelle

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

1 commentaires

multiplier est juste operator.mul fyi :)

1
votes

Solution possible avec numpy:

0.9990000000000001

Parcourez toutes les colonnes du tableau 2d et calculez le prod de chaque colonne. Additionnez ensuite tous les résultats.

Sortie

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

0 commentaires

1
votes

Comme indiqué, vous pouvez utiliser zip pour obtenir la liste des tuple s, de la manière

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

qui pourrait être converti en liste de liste s, de la manière suivante

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

Ensuite, si vous utilisez Python2, vous pouvez utiliser réduire , ce qui sans import est impossible en Python3, vous devez donc implémenter vous-même la réduction de la multiplication, je le ferais de la manière suivante:

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

0 commentaires