Мне нужно написать функцию, которая берет список чисел и умножает их вместе. Пример:
[1,2,3,4,5,6]
даст мне 1*2*3*4*5*6
. Я мог бы действительно использовать вашу помощь.
Мне нужно написать функцию, которая берет список чисел и умножает их вместе. Пример:
[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
lambda
занял в среднем 0,02 с / 1000 повторений, в то время как operator.mul
в среднем 0,009 с / 1000 повторений, что operator.mul
на порядок быстрее.
operator.mul
идет прямо к C.
math.prod([1,2,3,4,5,6])
. (требуется импорт конечно)
Ты можешь использовать:
import operator
import functools
functools.reduce(operator.mul, [1,2,3,4,5,6], 1)
Смотрите reduce
и operator.mul
документацию для объяснения.
Вам нужна import functools
строка в Python 3+.
reduce()
функция была удалена из глобального пространства имен и помещена в functools
модуль. Так что в python3 вам нужно сказать from functools import reduce
.
Я бы использовал numpy.prod
для выполнения задачи. Увидеть ниже.
import numpy as np
mylist = [1, 2, 3, 4, 5, 6]
result = np.prod(np.array(mylist))
result = np.prod(mylist)
numpy.int32
как указано выше. 2) Для небольших списков это будет значительно медленнее, поскольку NumPy необходимо выделить массив (актуально, если повторяется часто)
np.prod(np.array(range(1,21)))
reduce
.
Если вы хотите избежать импорта чего-либо и избежать более сложных областей Python, вы можете использовать простой цикл for
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.
multiply_functools
и multiply_numpy
отягощено того , чтобы посмотреть на np
, functools
и operator
глобал, с последующими атрибутами поиском. Не могли бы вы перейти на местных жителей? _reduce=functools.reduce,
_mul = operator.mul` в сигнатуре функции, затем return _reduce(_mul, iterable)
в теле и т. д.
np.prod()
параметр запускается быстрее всего при 100 или более элементах.
Мне лично нравится это для функции, которая умножает все элементы общего списка:
def multiply(n):
total = 1
for i in range(0, len(n)):
total *= n[i]
print total
Он компактен, использует простые вещи (переменную и цикл for) и выглядит для меня интуитивно понятным (похоже, что я думаю о проблеме, просто возьми одну, умножь ее, затем умножь на следующую и так далее! )
for i in n:
Тогда почему нет total *= i
? не будет ли это намного проще?
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))
*
, так что eval распознает это как мультипликативный. Интересно, как обстоят дела с этим, особенно по сравнению с другими решениями
Я хотел бы это следующим образом:
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 multiply(numbers):
a = 1
for num in numbers:
a *= num
return a
pass
'' 'единственный простой способ понять логику, используемую для цикла' ''
Lap = [2,5,7,7,9] x = 1 для i на круге: x = i * x print (x)
Это очень просто, ничего не импортировать. Это мой код Это определит функцию, которая умножает все элементы в списке и возвращает их продукт.
def myfunc(lst):
multi=1
for product in lst:
multi*=product
return product