Как найти произведение всех чисел питон

Python

Python3

Python3

Python3

Python3

Python3

Python

Python3

Python3

Для заданного списка выведите значение, полученное после умножения всех чисел в списке.

Примеры:

Input :  list1 = [1, 2, 3] 
Output : 6 
Explanation: 1*2*3=6 

Input : list1 = [3, 2, 4] 
Output : 24 

Метод 1: обход

Инициализируйте значение продукта равным 1 (не 0, если 0, умноженное на что-либо, возвращает ноль). Пройдите до конца списка, умножьте каждое число на произведение. Значение, сохраненное в продукте в конце, даст вам ваш окончательный ответ.

Ниже этого Python реализация вышеупомянутого подхода:

Выход:

6
24 

Способ 2: использование numpy.prod ()

Мы можем использовать numpy.prod () из import numpy, чтобы получить умножение всех чисел в списке. Возвращает целое число или значение с плавающей запятой в зависимости от результата умножения.

Ниже Python3 реализация вышеуказанного подхода:

Выход:

6
24 

Метод 3 из 3: Использование лямбда-функции: Использование numpy.array

Лямбда-определение не содержит оператора return , оно всегда содержит выражение, которое возвращается. Мы также можем поместить лямбда-определение везде, где ожидается функция, и нам вообще не нужно присваивать ее переменной. Это простота лямбда-функций. Функция Reduce () в Python принимает функцию и список в качестве аргумента. Функция вызывается с лямбда-функцией и списком, и возвращается результат, уменьшенный на ew . Это выполняет повторяющуюся операцию над парами списка.

Ниже приведена реализация вышеуказанного подхода в Python3:

Выход:

6
24 

Рекомендуемые посты:

• Python | Умножьте целое число в смешанном списке строк и чисел
• Python — умножить два списка
• Python — Умножение последовательных элементов в списке
• Python | Повторить и умножить расширение списка
• Python | Способы суммирования списка списков и возврата списка сумм
• Python | Способы преобразования 3D-списка в 2D-список
• Python | Способы перемешать список
• Расширение списка в Python (5 разных способов)
• Различные способы очистить список в Python
• Python | Способы выравнивания 2D-списка
• Python | Способы поворота списка
• Python | Способы пролить список на какое-то значение
• Python | Способы инициализации списка алфавитами
• Python | Способы найти длину списка
• Python | Способы создания триплетов из данного списка

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

Мне лично это нравится для функции, которая объединяет все элементы общего списка:

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

Он компактный, использует простые вещи (переменную и цикл for) и чувствует себя интуитивно понятным для меня (похоже, как я думаю об этой проблеме, просто возьмите ее, умножьте ее, затем умножьте на следующую и и так далее!)

Вот некоторые измерения производительности от моей машины. Относится к случаю, если это выполняется для небольших входов в длительном цикле:

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.

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

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

Начиная с 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, если оно предусмотрено).

Нашел этот вопрос сегодня, но я заметил, что он не имеет случая, когда в списке есть 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)

var=1
def productlist(number):
global var
var*=number
list(map(productlist,[1,2,4]))
print(var)

Вы можете сделать это с помощью карты

Мое решение для умножения элементов в кортеже или списке

a = 140,10
val = 1
for i in a:
val *= i
print(val)

[ВЫХОД]:

1400

Мое решение:

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

pass

Numpy имеет функцию prod, которая возвращает произведение списка, или, в данном случае, так как это numpy, технически это произведение массива по заданной оси.

в одну сторону:

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

другой просто играет на том, как вы импортируете:

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

def multiply(numbers):
total = numbers[0]
for num in numbers:
total *= num
return total

Как насчет использования рекурсии?

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

Это очень просто, ничего не импортировать. Это мой код Это определит функцию, которая умножает все элементы в списке и возвращает их продукт.

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