Hướng dẫn how do you product an element in a list python? - làm thế nào để bạn tạo ra một phần tử trong một python danh sách?

193

Mới! Lưu câu hỏi hoặc câu trả lời và sắp xếp nội dung yêu thích của bạn. Tìm hiểu thêm.
Learn more.

Có một cách ngắn gọn, hiệu quả hơn hoặc đơn giản là pythonic để làm như sau?

def product[lst]:
    p = 1
    for i in lst:
        p *= i
    return p

EDIT:

Tôi thực sự thấy rằng điều này nhanh hơn một chút so với sử dụng toán tử.mul:

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

đưa cho tôi

['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]

QNEILL

1.62313 huy hiệu bạc18 Huy hiệu đồng13 silver badges18 bronze badges

hỏi ngày 20 tháng 1 năm 2010 lúc 20:40Jan 20, 2010 at 20:40

Simon Watkinssimon WatkinsSimon Watkins

1.9652 Huy hiệu vàng12 Huy hiệu bạc7 Huy hiệu đồng2 gold badges12 silver badges7 bronze badges

Mà không sử dụng Lambda:

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

Nó tốt hơn và nhanh hơn. Với 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]

Trong cấu hình sau:

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

Kết quả với 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

Kết quả:

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

0 là nhanh nhất, nếu bạn sử dụng

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

1 làm cấu trúc dữ liệu [18 lần cho mảng nhỏ, 250x cho mảng lớn]

với 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 có chậm hơn không?

Đã trả lời ngày 20 tháng 1 năm 2010 lúc 21:33Jan 20, 2010 at 21:33

Ruggero Turraruggero TurraRuggero Turra

16.1K14 Huy hiệu vàng86 Huy hiệu bạc135 Huy hiệu đồng14 gold badges86 silver badges135 bronze badges

from functools import reduce

a = [1, 2, 3]
reduce[lambda x, y: x * y, a, 1]

Đã trả lời ngày 20 tháng 1 năm 2010 lúc 20:42Jan 20, 2010 at 20:42

Johannes Charrajohannes CharraJohannes Charra

28.7K5 Huy hiệu vàng41 Huy hiệu bạc 50 Huy hiệu Đồng5 gold badges41 silver badges50 bronze badges

Bắt đầu

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

2, hàm

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

3 đã được đưa vào mô -đun

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

4 trong thư viện tiêu chuẩn:

math.prod [có thể lặp lại, *, start = 1]

trả về sản phẩm của giá trị

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

5 [mặc định: 1] nhiều lần số lượng của các số:

import math

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

Lưu ý rằng nếu có thể trống, điều này sẽ tạo ra

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

6 [hoặc giá trị

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

5 nếu được cung cấp].

Đã trả lời ngày 14 tháng 2 năm 2019 lúc 19:12Feb 14, 2019 at 19:12

Xavier Guihotxavier GuihotXavier Guihot

47.8K21 Huy hiệu vàng266 Huy hiệu bạc170 Huy hiệu Đồng21 gold badges266 silver badges170 bronze badges

Nếu bạn chỉ có số trong danh sách của mình:

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

Chỉnh sửa: Như được chỉ ra bởi @off99555, điều này không hoạt động cho kết quả số nguyên lớn, trong trường hợp nó trả về kết quả của loại

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

8 trong khi giải pháp của Ian Clelland dựa trên

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

9 và

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]

0 hoạt động cho kết quả số nguyên lớn vì nó trả về

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]

Đã trả lời ngày 9 tháng 12 năm 2012 lúc 21:47Dec 9, 2012 at 21:47

Andre Holznerandre HolznerAndre Holzner

Huy hiệu vàng 18K653 Huy hiệu bạc62 Huy hiệu Đồng6 gold badges53 silver badges62 bronze badges

Tốt nếu bạn thực sự muốn làm cho nó một dòng mà không nhập bất cứ điều gì bạn có thể làm:

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

Nhưng đừng.

Đã trả lời ngày 21 tháng 8 năm 2015 lúc 3:49Aug 21, 2015 at 3:49

Tôi nhớ một số cuộc thảo luận dài trên comp.lang.python [xin lỗi, quá lười để sản xuất con trỏ bây giờ] kết luận rằng định nghĩa

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]

2 ban đầu của bạn là pythonic nhất.your original
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]
2 definition is the most Pythonic.

Lưu ý rằng đề xuất không phải là viết một vòng lặp mỗi khi bạn muốn làm điều đó, mà là viết một chức năng một lần [cho mỗi loại giảm] và gọi nó là cần thiết! Các chức năng giảm gọi là rất pythonic - nó hoạt động ngọt ngào với các biểu thức của máy phát, và kể từ khi giới thiệu thành công của

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]

3, Python tiếp tục phát triển các chức năng giảm tích hợp ngày càng nhiều -

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]

4 và

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]

5 là những bổ sung mới nhất ...

Kết luận này là chính thức -

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]

6 đã bị xóa khỏi tích hợp trong Python 3.0, nói rằng:

"Sử dụng

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]

7 Nếu bạn thực sự cần nó; tuy nhiên, 99 phần trăm thời gian rõ ràng cho vòng lặp là dễ đọc hơn."

Xem thêm Số phận của giảm [] trong Python 3000 để biết trích dẫn hỗ trợ từ Guido [và một số bình luận ít hỗ trợ của Lispers đọc blog đó].

P.S. Nếu tình cờ bạn cần

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]

2 cho tổ hợp, xem

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]

9 [mới 2.6].

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

Đã trả lời ngày 20 tháng 1 năm 2010 lúc 21:38Jan 20, 2010 at 21:38

Ian Clellandian ClellandIan Clelland

42K8 Huy hiệu vàng84 Huy hiệu bạc87 Huy hiệu đồng8 gold badges84 silver badges87 bronze badges

Tôi đã thử nghiệm các giải pháp khác nhau với perfplot [một dự án nhỏ của tôi] và thấy rằng

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

cho đến nay là giải pháp nhanh nhất [nếu danh sách không ngắn lắm].

Mã để tái tạo lô:

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

Đã trả lời ngày 22 tháng 3 năm 2019 lúc 10:13Mar 22, 2019 at 10:13

Nico Schlömernico SchlömerNico Schlömer

49K24 Huy hiệu vàng186 Huy hiệu bạc225 Huy hiệu Đồng24 gold badges186 silver badges225 bronze badges

Mục đích của câu trả lời này là cung cấp một tính toán hữu ích trong một số trường hợp nhất định - cụ thể là khi a] có một số lượng lớn các giá trị được nhân lên sao cho sản phẩm cuối cùng có thể cực kỳ lớn hoặc cực kỳ nhỏ, và b] bạn không ' T thực sự quan tâm đến câu trả lời chính xác, nhưng thay vào đó có một số trình tự và muốn có thể đặt hàng chúng dựa trên sản phẩm của mỗi người.

Nếu bạn muốn nhân các yếu tố của danh sách, trong đó L là danh sách, bạn có thể làm:

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

Bây giờ, cách tiếp cận đó không thể đọc được như

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

Nếu bạn là một nhà toán học không quen thuộc với giảm [] thì điều ngược lại có thể đúng, nhưng tôi sẽ không khuyên sử dụng nó trong những trường hợp bình thường. Nó cũng không thể đọc được hơn hàm sản phẩm [] được đề cập trong câu hỏi [ít nhất là đối với các nhà không phải là người nhận thức].

Tuy nhiên, nếu bạn đã từng ở trong tình huống mà bạn có nguy cơ tăng hoặc tràn, chẳng hạn như trong

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

và mục đích của bạn là so sánh các sản phẩm của các chuỗi khác nhau thay vì biết các sản phẩm là gì, sau đó

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

là con đường để đi bởi vì hầu như không thể có một vấn đề trong thế giới thực, trong đó bạn sẽ tràn hoặc tràn ngập phương pháp này. [Kết quả của tính toán đó càng lớn thì sản phẩm sẽ càng lớn nếu bạn có thể tính toán nó.]

Đã trả lời ngày 2 tháng 2 năm 2012 lúc 15:07Feb 2, 2012 at 15:07

Garyrobgaryrobgaryrob

5687 Huy hiệu bạc17 Huy hiệu đồng7 silver badges17 bronze badges

Tôi ngạc nhiên là không ai đề xuất sử dụng

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

0 với

from operator import mul
# from functools import reduce # python3 compatibility
reduce[mul, list, 1]

9. Điều này tránh sử dụng

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]

0, khác với Python 2 và 3 [do nhập khẩu

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

3 cần thiết cho Python 3], và hơn nữa được coi là không pythonic bởi chính Guido van Rossum:

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

def with_lambda[lst]:
    reduce[lambda x, y: x * y, lst]

def without_lambda[lst]:
    reduce[mul, lst]

def forloop[lst]:
    r = 1
    for x in lst:
        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[]]

Example:

['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]

Đã trả lời ngày 25 tháng 5 năm 2017 lúc 12:15May 25, 2017 at 12:15

Chris_RandsChris_RandsChris_Rands

36,5K13 Huy hiệu vàng79 Huy hiệu bạc110 Huy hiệu đồng13 gold badges79 silver badges110 bronze badges

Một lựa chọn là sử dụng

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

4 và

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

5 hoặc

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

6. Tôi cũng đã thực hiện một hoặc hai điều chỉnh nhỏ vào mã của bạn [ít nhất là trong Python 3, "Danh sách" là một từ khóa không nên được sử dụng cho một tên biến]:

['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]

Đối với mục đích thời gian, bạn cần chạy một lần để biên dịch chức năng trước tiên bằng Numba. Nói chung, hàm sẽ được biên dịch ngay lần đầu tiên nó được gọi, và sau đó được gọi từ bộ nhớ sau đó [nhanh hơn].

['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]

Bây giờ khi bạn thực thi mã của mình, nó sẽ chạy với phiên bản biên dịch của hàm. Tôi đã hẹn giờ bằng cách sử dụng máy tính xách tay Jupyter và hàm ma thuật

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

['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]

Lưu ý rằng trên máy của tôi, chạy Python 3.5, vòng lặp Python

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

8 gốc thực sự là nhanh nhất. Có thể có một mẹo ở đây khi nói đến việc đo lường hiệu suất được trang trí numba với máy tính xách tay Jupyter và hàm ma thuật

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

7. Tôi không chắc chắn rằng thời gian trên là chính xác, vì vậy tôi khuyên bạn nên dùng thử trên hệ thống của bạn và xem Numba có tăng hiệu suất không.

Đã trả lời ngày 7 tháng 1 năm 2019 lúc 19:45Jan 7, 2019 at 19:45

EngineeroEngineeroEngineero

11.7K5 Huy hiệu vàng51 Huy hiệu bạc73 Huy hiệu đồng5 gold badges51 silver badges73 bronze badges

Cách nhanh nhất tôi tìm thấy là, sử dụng trong khi:

['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]

Và thời gian là:

['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]

Đã trả lời ngày 20 tháng 9 năm 2018 lúc 16:18Sep 20, 2018 at 16:18

Python 3 Kết quả cho các bài kiểm tra của OP: [tốt nhất 3 cho mỗi lần]

['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]

Đã trả lời ngày 22 tháng 10 năm 2019 lúc 11:23Oct 22, 2019 at 11:23

Tôi không chắc chắn về cách nhanh nhất, nhưng đây là mã ngắn để có được sản phẩm của bất kỳ bộ sưu tập nào mà không cần nhập bất kỳ thư viện hoặc mô -đun nào.

['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]

Đã trả lời ngày 2 tháng 7 năm 2021 lúc 10:04Jul 2, 2021 at 10:04

Đây là mã:

['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]

Xavier Guihot

47.8K21 Huy hiệu vàng266 Huy hiệu bạc170 Huy hiệu Đồng21 gold badges266 silver badges170 bronze badges

Đã trả lời ngày 18 tháng 7 năm 2021 lúc 2:02Jul 18, 2021 at 2:02

Điều này cũng hoạt động mặc dù gian lận của nó

['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]

Boppreh

6.3993 Huy hiệu vàng31 Huy hiệu bạc65 Huy hiệu Đồng3 gold badges31 silver badges65 bronze badges

Đã trả lời ngày 28 tháng 2 năm 2013 lúc 18:30Feb 28, 2013 at 18:30

Làm thế nào để bạn tạo ra một sản phẩm trong Python?

Example:..

# Ví dụ chương trình Python để tìm sản phẩm của các yếu tố từ một điều khác. Nhập toán ..

# Một python tuple. Trình tự = [1, 1.2, 2, 2.2, 3, 3.2] ;.

# Tìm sản phẩm của các phần tử của tuple với giá trị sản phẩm bắt đầu là 4. sản phẩm = math.prod [trình tự, start = 4] ;.

in ["Sản phẩm:"]; In [sản phẩm] ;.

Làm thế nào để bạn nhân hai yếu tố trong danh sách Python?

Nhân hai danh sách sử dụng cho vòng lặp qua cho vòng lặp, chúng ta có thể lặp lại trong danh sách.Tương tự, với mỗi lần lặp, chúng ta có thể nhân các yếu tố từ cả hai danh sách.Đối với mục đích này, chúng ta có thể sử dụng chức năng zip.Hàm zip [] trong Python có thể kết hợp nội dung từ 2 hoặc nhiều vòng lặp.using for loop Through for loop, we can iterate through the list. Similarly, with every iteration, we can multiply the elements from both lists. For this purpose, we can use Zip Function. The zip[] function in python can combine the contents of 2 or more iterables.

Làm thế nào để bạn nhân tất cả các mục trong một danh sách trong Python?

Để nhân mỗi phần tử trong một danh sách với một số:..

Tuyên bố một biến mới lưu trữ một danh sách trống ..

Sử dụng một vòng lặp để lặp qua danh sách ban đầu ..

Trên mỗi lần lặp, nhân mục Danh sách hiện tại với số ..

Nối kết quả vào danh sách mới ..

Làm thế nào để bạn nhân một giá trị trong Python?

Sự nhân trong python được thực hiện bởi toán tử [ *], sau đó kết quả được lưu trong biến sản phẩm và được in ra bằng định dạng chuỗi.[ * ] operator, Then the result is saved in the product variable and printed out using string formatting.

Làm thế nào để bạn tạo ra một sản phẩm trong Python?

Làm thế nào để bạn nhân hai yếu tố trong danh sách Python?

Làm thế nào để bạn nhân tất cả các mục trong một danh sách trong Python?

Làm thế nào để bạn nhân một giá trị trong Python?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề