Preciso escrever uma função que pegue uma lista de números e os multiplique . Exemplo:
[1,2,3,4,5,6]
vai me dar 1*2*3*4*5*6
. Eu realmente poderia usar sua ajuda.
Preciso escrever uma função que pegue uma lista de números e os multiplique . Exemplo:
[1,2,3,4,5,6]
vai me dar 1*2*3*4*5*6
. Eu realmente poderia usar sua ajuda.
Respostas:
Python 3: use functools.reduce
:
>>> from functools import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720
Python 2: use reduce
:
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720
Para compatível com o uso 2 e 3 pip install six
, então:
>>> from six.moves import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720
lambda
levei uma média de 0,02s / 1000 repetições, enquanto que operator.mul
uma média de 0,009s / 1000 repetições, tornando operator.mul
a ordem de magnitude mais rápida.
operator.mul
vai direto para C.
math.prod([1,2,3,4,5,6])
. (requer importação, é claro)
Você pode usar:
import operator
import functools
functools.reduce(operator.mul, [1,2,3,4,5,6], 1)
Veja reduce
e operator.mul
documentação para uma explicação.
Você precisa da import functools
linha em Python 3+.
reduce()
função foi removida do espaço para nome global e colocada no functools
módulo. Então, em python3, você precisa dizer from functools import reduce
.
Eu usaria o numpy.prod
para executar a tarefa. Ver abaixo.
import numpy as np
mylist = [1, 2, 3, 4, 5, 6]
result = np.prod(np.array(mylist))
result = np.prod(mylist)
numpy.int32
acima. 2) Para listas pequenas, isso será significativamente mais lento, pois o NumPy precisa alocar uma matriz (relevante se repetida com frequência)
np.prod(np.array(range(1,21)))
reduce
.
Se você deseja evitar importar qualquer coisa e evitar áreas mais complexas do Python, pode usar um loop for simples
product = 1 # Don't use 0 here, otherwise, you'll get zero
# because anything times zero will be zero.
list = [1, 2, 3]
for x in list:
product *= x
Iniciando Python 3.8
, uma .prod
função foi incluída no math
módulo na biblioteca padrão:
math.prod(iterable, *, start=1)
O método retorna o produto de um start
valor (padrão: 1) vezes uma iterável de números:
import math
math.prod([1, 2, 3, 4, 5, 6])
>>> 720
Se o iterável estiver vazio, isso produzirá 1
(ou o start
valor, se fornecido).
Aqui estão algumas medidas de desempenho da minha máquina. Relevante caso isso seja realizado para pequenas entradas em um loop de longa execução:
import functools, operator, timeit
import numpy as np
def multiply_numpy(iterable):
return np.prod(np.array(iterable))
def multiply_functools(iterable):
return functools.reduce(operator.mul, iterable)
def multiply_manual(iterable):
prod = 1
for x in iterable:
prod *= x
return prod
sizesToTest = [5, 10, 100, 1000, 10000, 100000]
for size in sizesToTest:
data = [1] * size
timerNumpy = timeit.Timer(lambda: multiply_numpy(data))
timerFunctools = timeit.Timer(lambda: multiply_functools(data))
timerManual = timeit.Timer(lambda: multiply_manual(data))
repeats = int(5e6 / size)
resultNumpy = timerNumpy.timeit(repeats)
resultFunctools = timerFunctools.timeit(repeats)
resultManual = timerManual.timeit(repeats)
print(f'Input size: {size:>7d} Repeats: {repeats:>8d} Numpy: {resultNumpy:.3f}, Functools: {resultFunctools:.3f}, Manual: {resultManual:.3f}')
Resultados:
Input size: 5 Repeats: 1000000 Numpy: 4.670, Functools: 0.586, Manual: 0.459
Input size: 10 Repeats: 500000 Numpy: 2.443, Functools: 0.401, Manual: 0.321
Input size: 100 Repeats: 50000 Numpy: 0.505, Functools: 0.220, Manual: 0.197
Input size: 1000 Repeats: 5000 Numpy: 0.303, Functools: 0.207, Manual: 0.185
Input size: 10000 Repeats: 500 Numpy: 0.265, Functools: 0.194, Manual: 0.187
Input size: 100000 Repeats: 50 Numpy: 0.266, Functools: 0.198, Manual: 0.185
Você pode ver que o Numpy é um pouco mais lento em entradas menores, pois aloca um array antes da multiplicação. Além disso, preste atenção ao excesso no Numpy.
multiply_functools
e multiply_numpy
estão sob o peso de ter que procurar os np
, functools
e operator
globals, seguido por pesquisas de atributo. Você se importaria de mudar para os locais? _reduce=functools.reduce,
_mul = operator.mul` na assinatura da função e depois return _reduce(_mul, iterable)
no corpo, etc.
np.prod()
opção inicia se torna mais rápida com 100 elementos ou mais.
Pessoalmente, gosto disso para uma função que multiplica todos os elementos de uma lista genérica:
def multiply(n):
total = 1
for i in range(0, len(n)):
total *= n[i]
print total
É compacto, usa coisas simples (uma variável e um loop for) e parece intuitivo para mim (parece como eu pensaria no problema, basta pegar um, multiplicar, depois multiplicar pelo próximo, e assim por diante! )
for i in n:
então total *= i
? não seria muito mais simples?
Numpy
tem a prod()
função que retorna o produto de uma lista ou, nesse caso, como está numpy, é o produto de uma matriz em um determinado eixo:
import numpy
a = [1,2,3,4,5,6]
b = numpy.prod(a)
... ou então você pode simplesmente importar numpy.prod()
:
from numpy import prod
a = [1,2,3,4,5,6]
b = prod(a)
Encontrei essa pergunta hoje, mas notei que ela não tem o caso em que há None
na lista. Portanto, a solução completa seria:
from functools import reduce
a = [None, 1, 2, 3, None, 4]
print(reduce(lambda x, y: (x if x else 1) * (y if y else 1), a))
No caso de adição, temos:
print(reduce(lambda x, y: (x if x else 0) + (y if y else 0), a))
nums = str(tuple([1,2,3]))
mul_nums = nums.replace(',','*')
print(eval(mul_nums))
*
, de modo que eval o reconheça como um multiplicativo. Eu me pergunto como o desempenho sobre isso é, especiamente em comparação com outras soluções
Gostaria disso da seguinte maneira:
def product_list(p):
total =1 #critical step works for all list
for i in p:
total=total*i # this will ensure that each elements are multiplied by itself
return total
print product_list([2,3,4,2]) #should print 48
Minha solução:
def multiply(numbers):
a = 1
for num in numbers:
a *= num
return a
pass
'' 'o único método simples para entender o uso lógico do loop' ''
Volta = [2,5,7,7,9] x = 1 para i na Volta: x = i * x impressão (x)
É muito simples, não importe nada. Este é o meu código. Isso definirá uma função que multiplica todos os itens de uma lista e retorna seu produto.
def myfunc(lst):
multi=1
for product in lst:
multi*=product
return product