Як я можу помножити всі елементи у списку разом із Python?

Мені потрібно написати функцію, яка бере список чисел і множує їх разом. Приклад: [1,2,3,4,5,6]дасть мені 1*2*3*4*5*6. Я справді міг би скористатися вашою допомогою.

Python 3: використання functools.reduce:

>>> from functools import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

Python 2: використання reduce:

>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

Для сумісного з 2 та 3 використанням pip install six, то:

>>> from six.moves import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

Ви можете використовувати:

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

Див. reduceТа operator.mulдокументацію для пояснення.

Вам потрібна import functoolsлінія в Python 3+.

Я б використав numpy.prodдля виконання завдання. Дивись нижче.

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

Якщо ви хочете уникнути що-небудь імпортувати і уникати більш складних областей Python, ви можете використовувати простий цикл

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

Починаючи Python 3.8, .prodфункція була включена в mathмодуль у стандартній бібліотеці:

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

Метод повертає добуток startзначення (за замовчуванням: 1) разів ітерабельного чисел:

import math
math.prod([1, 2, 3, 4, 5, 6])

>>> 720

Якщо ітерабельний номер порожній, це призведе до отримання 1(або startзначення, якщо воно надане).

Ось кілька вимірювань продуктивності моєї машини. Доречно, якщо це виконується для невеликих входів у довго працюючу петлю:

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}')

Результати:

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

Ви можете бачити, що Numpy є дещо повільнішим на менших входах, оскільки він виділяє масив перед тим, як проводиться множення. Також стежте за переповненням у Numpy.

Мені особисто це подобається за функцію, яка множує всі елементи загального списку разом:

def multiply(n):
    total = 1
    for i in range(0, len(n)):
        total *= n[i]
    print total

Він компактний, використовує прості речі (змінну і for цикл), і мені здається інтуїтивно зрозумілим (схоже, як я б подумав про проблему, просто візьміть одну, помножте її, потім помножте на наступну тощо)! )

Простий спосіб:

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

Numpyмає prod()функцію, яка повертає добуток списку, або в цьому випадку, оскільки він нудний, це добуток масиву над заданою віссю:

import numpy
a = [1,2,3,4,5,6]
b = numpy.prod(a)

... інакше ви можете просто імпортувати numpy.prod():

from numpy import prod
a = [1,2,3,4,5,6]
b = prod(a)

Я знайшов це питання сьогодні, але я помітив, що у нього немає випадків, коли їх Noneу списку є. Отже, повним рішенням було б:

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

У випадку додавання ми маємо:

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

Я хотів би це наступним чином:

    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

Це мій код:

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

результат: ('1 * 1 * 2 * 3 * 4', 24)

Як щодо використання рекурсії?

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

Моє рішення:

def multiply(numbers):
    a = 1
    for num in numbers:
        a *= num
        return a

  pass

'' 'єдиний простий метод для розуміння використання логіки для циклу' ''

Кол = [2,5,7,7,9] х = 1 для i в колі: x = i * x print (x)

Дуже просто нічого не імпортувати. Це мій код. Це визначить функцію, яка множить усі елементи у списку та повертає їх товар.

def myfunc(lst):
    multi=1
    for product in lst:
        multi*=product
    return product