Возврат продукта из списка

Ответ 1

Без использования лямбда:

from operator import mul
reduce(mul, list, 1)

это лучше и быстрее. С python 2.7.5

from operator import mul
import numpy as np
import numexpr as ne
# from functools import reduce # python3 compatibility

a = range(1, 101)
%timeit reduce(lambda x, y: x * y, a)   # (1)
%timeit reduce(mul, a)                  # (2)
%timeit np.prod(a)                      # (3)
%timeit ne.evaluate("prod(a)")          # (4)

В следующей конфигурации:

a = range(1, 101)  # A
a = np.array(a)    # B
a = np.arange(1, 1e4, dtype=int) #C
a = np.arange(1, 1e5, dtype=float) #D

Результаты с python 2.7.5

       |     1     |     2     |     3     |     4     |
-------+-----------+-----------+-----------+-----------+
 A       20.8 µs     13.3 µs     22.6 µs     39.6 µs     
 B        106 µs     95.3 µs     5.92 µs     26.1 µs
 C       4.34 ms     3.51 ms     16.7 µs     38.9 µs
 D       46.6 ms     38.5 ms      180 µs      216 µs

Результат: np.prod является самым быстрым, если вы используете np.array как структуру данных (18x для малого массива, 250x для большого массива)

с python 3.3.2:

       |     1     |     2     |     3     |     4     |
-------+-----------+-----------+-----------+-----------+
 A       23.6 µs     12.3 µs     68.6 µs     84.9 µs     
 B        133 µs      107 µs     7.42 µs     27.5 µs
 C       4.79 ms     3.74 ms     18.6 µs     40.9 µs
 D       48.4 ms     36.8 ms      187 µs      214 µs

Является ли python 3 медленнее?

Ответ 2

reduce(lambda x, y: x * y, list, 1)

Ответ 3

если у вас просто есть номера в списке:

from numpy import prod
prod(list)

EDIT: как указано в @off99555, это не работает для больших целочисленных результатов, и в этом случае он возвращает результат типа numpy.int64, а решение Ian Clelland на основе operator.mul и reduce работает для больших целых результатов, потому что он возвращает long.

Ответ 4

import operator
reduce(operator.mul, list, 1)

Ответ 5

Я помню некоторые длительные дискуссии о comp.lang.python(извините, слишком ленив, чтобы создавать указатели сейчас), которые пришли к выводу, что ваше исходное определение product() является самым Pythonic.

Обратите внимание, что предложение состоит не в том, чтобы писать цикл for каждый раз, когда вы хотите это сделать, а в том, чтобы написать функцию один раз (по типу сокращения) и называть ее по мере необходимости! Вызывающие функции сокращения очень Pythonic - он сладко работает с генераторными выражениями, и с момента успешного внедрения sum(), Python продолжает все больше и больше встроенных функций сокращения - any() и all() являются последними дополнениями...

Этот вывод является официальным официальным - reduce() был удален из встроенных в Python 3.0, говоря:

"Используйте functools.reduce(), если вам это действительно нужно, но в 99% случаев явный цикл цикла более читабельен".

См. также Судьба reduce() в Python 3000 для поддержки цитаты из Guido (и несколько менее содержательных комментариев от Lispers, которые гласили, что блог).

P.S. если вам понадобится product() для комбинаторики, см. math.factorial() (новый 2.6).

Ответ 6

Цель этого ответа состоит в том, чтобы дать расчет, который полезен в определенных обстоятельствах, а именно когда a) существует большое количество значений, которые умножаются так, что конечный продукт может быть чрезвычайно большим или крайне малым, и b) вам на самом деле не нужен точный ответ, но вместо этого есть несколько последовательностей и вы хотите иметь возможность упорядочивать их на основе каждого продукта.

Если вы хотите размножить элементы списка, где l - список, вы можете сделать:

import math
math.exp(sum(map(math.log, l)))

Теперь этот подход не так читается, как

from operator import mul
reduce(mul, list)

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

Однако, если вы когда-либо находитесь в ситуации, когда вы рискуете переполнением или переполнением, например, в

>>> reduce(mul, [10.]*309)
inf

и ваша цель - сравнить продукты разных последовательностей, а не знать, что такое продукты, тогда

>>> sum(map(math.log, [10.]*309))
711.49879373515785

- это путь, потому что практически невозможно иметь проблему реального мира, в которой вы бы переполняли или переполняли этот подход. (Чем больше результат этого вычисления, тем больше будет продукт, если вы можете его вычислить.)

Ответ 7

Хорошо, если вы действительно хотели сделать это одной строкой, не импортируя ничего, что могли бы сделать:

eval('*'.join(str(item) for item in list))

Но не надо.

Ответ 8

Я удивлен, что никто не предложил использовать itertools.accumulate с operator.mul. Это позволяет избежать использования reduce, которое отличается для Python 2 и 3 (из-за импорта functools, требуемого для Python 3), и, кроме того, считается непитоновым самого Guido van Rossum:

from itertools import accumulate
from operator import mul

def prod(lst):
    for value in accumulate(lst, mul):
        pass
    return value

Пример:

prod([1,5,4,3,5,6])
# 1800

Ответ 9

Это также работает, хотя его обман

def factorial(n):
    x=[]
    if n <= 1:
        return 1
    else:
        for i in range(1,n+1): 
            p*=i
            x.append(p)
        print x[n-1]