목록의 제품 반품

다음을 수행하는 더 간결하고 효율적이거나 단순한 파이썬 방법이 있습니까?

def product(list):
    p = 1
    for i in list:
        p *= i
    return p

편집하다:

실제로 이것은 operator.mul을 사용하는 것보다 약간 빠릅니다.

from operator import mul
# from functools import reduce # python3 compatibility

def with_lambda(list):
    reduce(lambda x, y: x * y, list)

def without_lambda(list):
    reduce(mul, list)

def forloop(list):
    r = 1
    for x in list:
        r *= x
    return r

import timeit

a = range(50)
b = range(1,50)#no zero
t = timeit.Timer("with_lambda(a)", "from __main__ import with_lambda,a")
print("with lambda:", t.timeit())
t = timeit.Timer("without_lambda(a)", "from __main__ import without_lambda,a")
print("without lambda:", t.timeit())
t = timeit.Timer("forloop(a)", "from __main__ import forloop,a")
print("for loop:", t.timeit())

t = timeit.Timer("with_lambda(b)", "from __main__ import with_lambda,b")
print("with lambda (no 0):", t.timeit())
t = timeit.Timer("without_lambda(b)", "from __main__ import without_lambda,b")
print("without lambda (no 0):", t.timeit())
t = timeit.Timer("forloop(b)", "from __main__ import forloop,b")
print("for loop (no 0):", t.timeit())

나에게 준다

('with lambda:', 17.755449056625366)
('without lambda:', 8.2084708213806152)
('for loop:', 7.4836349487304688)
('with lambda (no 0):', 22.570688009262085)
('without lambda (no 0):', 12.472226858139038)
('for loop (no 0):', 11.04065990447998)

람다를 사용하지 않고 :

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

더 좋고 빠릅니다. 파이썬 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 |
------- + ----------- + ----------- ++ ---------- + ------ ----- +
 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.34ms 3.51ms 16.7µs 38.9µs
 D 46.6ms 38.5ms 180µs 216µs

결과 : 데이터 구조로 np.prod사용 np.array하는 경우 가장 빠릅니다 (작은 배열의 경우 18x, 큰 배열의 경우 250x).

파이썬 3.3.2로 :

       | 1 | 2 | 3 | 4 |
------- + ----------- + ----------- ++ ---------- + ------ ----- +
 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.79ms 3.74ms 18.6µs 40.9µs
 D 48.4ms 36.8ms 187µs 214µs

파이썬 3이 느려 집니까?

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

목록에 숫자 만있는 경우 :

from numpy import prod
prod(list)

편집 : @ off99555에 의해 지적 된대로 이것은 큰 정수 결과에 대해 작동하지 않습니다.이 경우 numpy.int64Ian Clelland의 솔루션을 기반으로 operator.mul하고 reduce큰 정수 결과에 대해 반환하는 동안 형식 결과를 반환합니다 long.

실제로 가져 오기없이 한 줄로 만들고 싶다면 다음을 수행하십시오.

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

그러나하지 마십시오.

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

시작 Python 3.8하여 prod함수가 math표준 라이브러리 의 모듈에 포함되었습니다 .

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

startiterable 숫자 의 값 (기본값 : 1) 곱의 곱을 반환합니다 .

import math

math.prod([2, 3, 4]) # 24

iterable이 비어 있으면 1(또는 start제공된 경우 값) 생성됩니다.

comp.lang.python (죄송하지만 포인터를 생성하기에는 너무 게으르다)에 대한 오랜 토론을 기억 하며 원래 product()정의가 가장 Pythonic 이라고 결론 내 렸습니다 .

제안은 당신이 그것을 원할 때마다 for 루프를 작성하는 것이 아니라 함수를 한 번 (축소 유형별로) 작성하고 필요에 따라 호출하는 것입니다! 축소 함수를 호출하는 것은 매우 Pythonic입니다. 생성기 표현식과 잘 작동하며,을 성공적으로 도입 한 sum()이후 Python은 점점 더 기본 제공되는 축소 함수를 계속 증가 any()시키고 all()있습니다.

이 결론은 좀 공식입니다 - reduce()한 제거 말, 파이썬 3.0에 내장 명령에서 :

" functools.reduce()실제로 필요한 경우 사용하십시오 . 그러나 명시 적 for 루프가 더 읽기 쉬운 시간의 99 %입니다."

Guido의 지원 인용문 및 해당 블로그를 읽는 Lispers의 의견이 적지 않은 내용은 Python 3000의 reduce () 운명을 참조하십시오 .

우연히 product()조합론 이 필요한 경우 PS math.factorial()(신규 2.6)를 참조하십시오 .

이 답변의 목적은 특정 상황에서 유용한 계산을 제공하는 것입니다. 즉, a) 최종 제품이 매우 크거나 작을 수 있도록 많은 수의 값을 곱한 경우 b) 실제로 정확한 답에 신경 쓰지 말고 대신 많은 수의 시퀀스를 가지며 각 제품에 따라 주문할 수 있기를 원합니다.

리스트의 요소를 곱하려면 (여기서 l은리스트 임) 다음을 수행 할 수 있습니다.

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

이제 그 접근 방식은 읽을 수 없습니다

from operator import mul
reduce(mul, list)

reduce ()에 익숙하지 않은 수학자라면 그 반대 일 수도 있지만 정상적인 상황에서는 사용하지 않는 것이 좋습니다. 또한 질문에 언급 된 product () 함수보다 읽기 쉽지 않습니다 (적어도 비 수학자에게는).

그러나 다음과 같이 언더 플로 또는 오버플로 위험이있는 상황에 처한 경우

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

당신의 목적은 제품이 무엇인지 아는 것이 아니라 다른 시퀀스의 제품을 비교하는 것입니다.

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

이 방법을 사용하면 오버플로 또는 언더 플로가 발생하는 실제 문제가 거의 불가능하기 때문에 갈 수있는 방법입니다. (계산 결과가 클수록 계산할 수 있는 경우 제품이 커집니다 .)

perfplot (작은 프로젝트)으로 다양한 솔루션을 테스트 한 결과

numpy.prod(lst)

입니다 지금까지 가장 빠른 솔루션 (목록은 매우 짧은 아닌 경우).

줄거리를 재현하는 코드 :

import perfplot
import numpy

import math
from operator import mul
from functools import reduce

from itertools import accumulate


def reduce_lambda(lst):
    return reduce(lambda x, y: x * y, lst)


def reduce_mul(lst):
    return reduce(mul, lst)


def forloop(lst):
    r = 1
    for x in lst:
        r *= x
    return r


def numpy_prod(lst):
    return numpy.prod(lst)


def math_prod(lst):
    return math.prod(lst)


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


perfplot.show(
    setup=numpy.random.rand,
    kernels=[reduce_lambda, reduce_mul, forloop, numpy_prod, itertools_accumulate, math_prod],
    n_range=[2 ** k for k in range(15)],
    xlabel="len(a)",
    logx=True,
    logy=True,
)

아무도 itertools.accumulate와 함께 사용 하도록 제안한 것에 놀랐습니다 operator.mul. 이것은 reducePython 2와 3에 functools대해 (파이썬 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

하나의 옵션은 numba및 @jit또는 @njitdecorator 를 사용 하는 것 입니다. 또한 코드에 하나 또는 두 개의 작은 조정을했습니다 (적어도 Python 3에서 "list"는 변수 이름에 사용해서는 안되는 키워드입니다).

@njit
def njit_product(lst):
    p = lst[0]  # first element
    for i in lst[1:]:  # loop over remaining elements
        p *= i
    return p

타이밍 목적으로, numba를 사용하여 함수를 먼저 컴파일하려면 한 번 실행해야합니다. 일반적으로 함수는 처음 호출 될 때 컴파일 된 다음 메모리에서 더 빨리 호출됩니다.

njit_product([1, 2])  # execute once to compile

이제 코드를 실행하면 컴파일 된 버전의 함수로 코드가 실행됩니다. Jupyter 노트북과 %timeit마법 기능을 사용하여 시간을 정했습니다 .

product(b)  # yours
# 32.7 µs ± 510 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

njit_product(b)
# 92.9 µs ± 392 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

내 컴퓨터에서 Python 3.5를 실행하면 기본 Python for루프가 실제로 가장 빠릅니다. Jupyter 노트북과 %timeit마법 기능 을 사용하여 numba로 꾸며진 성능을 측정 할 때 트릭이있을 수 있습니다 . 위의 타이밍이 올바른지 확실하지 않으므로 시스템에서 시도해보고 numba가 성능을 향상시키는 지 확인하는 것이 좋습니다.

내가 찾은 가장 빠른 방법은 다음을 사용하는 것입니다.

mysetup = '''
import numpy as np
from find_intervals import return_intersections 
'''

# code snippet whose execution time is to be measured
mycode = '''

x = [4,5,6,7,8,9,10]
prod = 1
i = 0
while True:
    prod = prod * x[i]
    i = i + 1
    if i == len(x):
        break
'''

# timeit statement for while:
print("using while : ",
timeit.timeit(setup=mysetup,
              stmt=mycode))

# timeit statement for mul:
print("using mul : ",
    timeit.timeit('from functools import reduce;
    from operator import mul;
    c = reduce(mul, [4,5,6,7,8,9,10])'))

# timeit statement for mul:
print("using lambda : ",      
    timeit.timeit('from functools import reduce;
    from operator import mul;
    c = reduce(lambda x, y: x * y, [4,5,6,7,8,9,10])'))

타이밍은 다음과 같습니다.

>>> using while : 0.8887967770060641

>>> using mul : 2.0838719510065857

>>> using lambda : 2.4227715369997895

OP 테스트를위한 Python 3 결과 : (각각 3 개씩)

with lambda: 18.978000981995137
without lambda: 8.110567473006085
for loop: 10.795806062000338
with lambda (no 0): 26.612515013999655
without lambda (no 0): 14.704098362999503
for loop (no 0): 14.93075215499266

이것은 또한 부정 행위를 통해 작동

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]