ส่งคืนผลิตภัณฑ์ของรายการ

มีวิธีรัดกุมมีประสิทธิภาพหรือเรียบง่ายกว่าในการทำสิ่งต่อไปนี้หรือไม่?

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

แก้ไข:

ฉันพบว่ามันเร็วกว่าการใช้โอเปอเรเตอร์เล็กน้อย

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)

มันดีกว่าและเร็วกว่า ด้วย 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 13s 13.3 22s 22.6 39s 39.6 .s     
 B 106 95s 95.3 5.s 5.92 26s 26.1 µs
 C 4.34 ms 3.51 ms 16.7 38s 38.9 µs
 D 46.6 ms 38.5 ms 180 216s 216 .s

ผลลัพธ์: np.prodเป็นสิ่งที่เร็วที่สุดถ้าคุณใช้np.arrayเป็นโครงสร้างข้อมูล (18x สำหรับอาร์เรย์ขนาดเล็ก, 250x สำหรับอาร์เรย์ขนาดใหญ่)

ด้วย python 3.3.2:

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

หลาม 3 ช้าลงไหม?

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

หากคุณมีตัวเลขอยู่ในรายการ:

from numpy import prod
prod(list)

แก้ไข : เป็นแหลมออกโดย @ off99555 นี้ไม่ได้ทำงานเพื่อให้ได้ผลลัพธ์จำนวนเต็มขนาดใหญ่ซึ่งในกรณีนี้ก็จะส่งกลับผลของชนิดnumpy.int64ในขณะที่การแก้ปัญหาเอียน Clelland บนพื้นฐานoperator.mulและการทำงานเพื่อให้ได้ผลลัพธ์จำนวนเต็มขนาดใหญ่เพราะผลตอบแทนreducelong

ถ้าคุณต้องการทำให้มันเป็นหนึ่งบรรทัดโดยไม่ต้องนำเข้าสิ่งที่คุณสามารถทำได้:

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)

ซึ่งส่งคืนผลิตภัณฑ์ที่มีstartค่า (ค่าเริ่มต้น: 1) คูณด้วยจำนวนซ้ำได้:

import math

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

โปรดทราบว่าหาก iterable ว่างเปล่าสิ่งนี้จะสร้างขึ้น1(หรือstartค่าถ้ามีให้)

ผมจำได้ว่าการอภิปรายยาวบางอย่างเกี่ยวกับ comp.lang.python (ขออภัยขี้เกียจเกินไปในการผลิตตัวชี้ตอนนี้) ซึ่งได้ข้อสรุปว่าต้นฉบับของคุณproduct()นิยามเป็น Pythonic

โปรดทราบว่าข้อเสนอนี้ไม่ได้เขียน for for loop ทุกครั้งที่คุณต้องการ แต่เขียนฟังก์ชั่นหนึ่งครั้ง (ตามประเภทของการลด) และเรียกมันตามต้องการ! ฟังก์ชั่นการลดเสียงเรียกนั้นเป็นแบบ Pythonic - มันใช้งานได้ดีกับนิพจน์เครื่องกำเนิดไฟฟ้าและตั้งแต่การแนะนำที่สำเร็จsum()Python ยังคงเพิ่มฟังก์ชั่นการลดในตัวมากขึ้นเรื่อย ๆ - any()และall()เป็นส่วนเสริมล่าสุด ...

ข้อสรุปนี้เป็นทางการครับ - reduce()ถูกลบออกจาก buildins ใน Python 3.0 โดยพูดว่า:

"ใช้functools.reduce()ถ้าคุณต้องการจริงๆอย่างไรก็ตามร้อยละ 99 ของเวลาที่ชัดเจนสำหรับลูปสามารถอ่านได้มากกว่า"

ดูเพิ่มเติมชะตากรรมของการลด () ใน Python 3000สำหรับคำพูดสนับสนุนจาก Guido (และความเห็นที่สนับสนุนน้อยโดย Lispers ที่อ่านบล็อกนั้น)

ป.ล. ถ้าบังเอิญคุณต้องการproduct()combinatorics ดูmath.factorial()(ใหม่ 2.6)

ความตั้งใจของคำตอบนี้คือการให้การคำนวณที่มีประโยชน์ในบางสถานการณ์ - คือเมื่อ a) มีค่าจำนวนมากที่ถูกคูณเช่นผลิตภัณฑ์สุดท้ายอาจมีขนาดใหญ่มากหรือเล็กมากและ b) คุณไม่ได้ ไม่สนใจคำตอบที่แน่นอน แต่มีลำดับจำนวนมากและต้องการที่จะสามารถสั่งซื้อได้ตามผลิตภัณฑ์ของแต่ละคน

หากคุณต้องการคูณองค์ประกอบของรายการโดยที่ l คือรายการคุณสามารถทำสิ่งต่อไปนี้

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

ตอนนี้วิธีการนั้นไม่สามารถอ่านได้เหมือน

from operator import mul
reduce(mul, list)

หากคุณเป็นนักคณิตศาสตร์ที่ไม่คุ้นเคยกับการลด () ตรงกันข้ามอาจเป็นจริง แต่ฉันจะไม่แนะนำให้ใช้ในสถานการณ์ปกติ นอกจากนี้ยังสามารถอ่านได้น้อยกว่าฟังก์ชั่นผลิตภัณฑ์ () ที่กล่าวถึงในคำถาม (อย่างน้อยสำหรับผู้ที่ไม่ใช่นักคณิตศาสตร์)

อย่างไรก็ตามหากคุณเคยอยู่ในสถานการณ์ที่เสี่ยงต่อการได้รับเงินทุนหมุนเวียนหรือล้นเช่นใน

>>> 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วิธีนี้หลีกเลี่ยงการใช้reduceซึ่งแตกต่างจาก Python 2 และ 3 (เนื่องจากfunctoolsการนำเข้าที่จำเป็นสำหรับ Python 3) และนอกจากนี้ยังถือว่าไม่ได้เป็น pythonic โดย 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หรือ@njitมัณฑนากร ฉันได้ปรับแต่งโค้ดของคุณหนึ่งหรือสองเล็กน้อย (อย่างน้อยใน 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 forloop แบบดั้งเดิมนั้นเร็วที่สุด อาจมีกลอุบายที่นี่เมื่อพูดถึงการวัดประสิทธิภาพที่ตกแต่งด้วยชาด้วยโน๊ตบุ๊ค Jupyter และ%timeitฟังก์ชั่นเวทมนต์ ฉันไม่แน่ใจว่าการกำหนดเวลาด้านบนถูกต้องดังนั้นฉันขอแนะนำให้ลองใช้ระบบของคุณและดูว่า 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

Python 3 ส่งผลให้การทดสอบของ OP: (ดีที่สุด 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]