Como posso multiplicar todos os itens de uma lista junto com o Python?

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.

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

Você pode usar:

import operator
import functools
functools.reduce(operator.mul, [1,2,3,4,5,6], 1)

Veja reducee operator.muldocumentação para uma explicação.

Você precisa da import functoolslinha em Python 3+.

Eu usaria o numpy.prodpara executar a tarefa. Ver abaixo.

import numpy as np
mylist = [1, 2, 3, 4, 5, 6] 
result = np.prod(np.array(mylist))  

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 .prodfunção foi incluída no mathmódulo na biblioteca padrão:

math.prod(iterable, *, start=1)

O método retorna o produto de um startvalor (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 startvalor, 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.

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

A maneira mais simples é:

import numpy as np
np.exp(np.log(your_array).sum())

Numpytem 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á Nonena 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))

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

Este é o meu código:

def product_list(list_of_numbers):
    xxx = 1
    for x in list_of_numbers:
        xxx = xxx*x
    return xxx

print(product_list([1,2,3,4]))

resultado: ('1 * 1 * 2 * 3 * 4', 24)

Que tal usar recursão?

def multiply(lst):
    if len(lst) > 1:
        return multiply(lst[:-1])* lst[-1]
    else:
        return lst[0]

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