Làm cách nào tôi có thể nhân tất cả các mục trong danh sách cùng với Python?

Tôi cần phải viết một hàm lấy danh sách các số và nhân chúng lại với nhau. Ví dụ: [1,2,3,4,5,6]sẽ cho tôi 1*2*3*4*5*6. Lẽ ra tôi đã có thể nhận sự trợ giúp của anh.

Python 3: sử dụng functools.reduce:

>>> from functools import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

Python 2: sử dụng reduce:

>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

Để tương thích với 2 và 3 sử dụng pip install six, sau đó:

>>> from six.moves import reduce
>>> reduce(lambda x, y: x*y, [1,2,3,4,5,6])
720

Bạn có thể dùng:

import operator
import functools
functools.reduce(operator.mul, [1,2,3,4,5,6], 1)

Xem reducevà operator.multài liệu cho một lời giải thích.

Bạn cần import functoolsdòng trong Python 3+.

Tôi sẽ sử dụng numpy.prodđể thực hiện nhiệm vụ. Xem bên dưới.

import numpy as np
mylist = [1, 2, 3, 4, 5, 6] 
result = np.prod(np.array(mylist))  

Nếu bạn muốn tránh nhập bất cứ thứ gì và tránh các khu vực phức tạp hơn của Python, bạn có thể sử dụng một vòng lặp đơn giản cho

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

Bắt đầu Python 3.8, một .prodchức năng đã được đưa vào mathmô-đun trong thư viện chuẩn:

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

Phương thức trả về sản phẩm của một startgiá trị (mặc định: 1) nhân với số lần lặp:

import math
math.prod([1, 2, 3, 4, 5, 6])

>>> 720

Nếu iterable trống, điều này sẽ tạo ra 1(hoặc startgiá trị, nếu được cung cấp).

Đây là một số phép đo hiệu suất từ ​​máy của tôi. Có liên quan trong trường hợp điều này được thực hiện cho các đầu vào nhỏ trong một vòng lặp dài:

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}')

Các kết quả:

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

Bạn có thể thấy rằng Numpy chậm hơn một chút trên các đầu vào nhỏ hơn, vì nó phân bổ một mảng trước khi phép nhân được thực hiện. Ngoài ra, xem ra cho tràn trong Numpy.

Cá nhân tôi thích điều này cho một hàm nhân tất cả các thành phần của danh sách chung với nhau:

def multiply(n):
    total = 1
    for i in range(0, len(n)):
        total *= n[i]
    print total

Nó nhỏ gọn, sử dụng những thứ đơn giản (một biến và một vòng lặp for) và cảm thấy trực quan với tôi (có vẻ như tôi nghĩ về vấn đề này, chỉ cần lấy một, nhân nó, sau đó nhân lên tiếp theo, v.v. )

Cách đơn giản là:

import numpy as np
np.exp(np.log(your_array).sum())

Numpycó prod()chức năng trả về sản phẩm của một danh sách hoặc trong trường hợp này vì nó không rõ ràng, đó là sản phẩm của một mảng trên một trục nhất định:

import numpy
a = [1,2,3,4,5,6]
b = numpy.prod(a)

... Hoặc nếu không bạn chỉ có thể nhập numpy.prod():

from numpy import prod
a = [1,2,3,4,5,6]
b = prod(a)

Tìm thấy câu hỏi này ngày hôm nay nhưng tôi nhận thấy rằng nó không có trường hợp có Nonetrong danh sách. Vì vậy, giải pháp hoàn chỉnh sẽ là:

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))

Trong trường hợp bổ sung, chúng tôi có:

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))

Tôi muốn điều này theo cách sau:

    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

Đây là mã của tôi:

def product_list(list_of_numbers):
    xxx = 1
    for x in list_of_numbers:
        xxx = xxx*x
    return xxx

print(product_list([1,2,3,4]))

kết quả: ('1 * 1 * 2 * 3 * 4', 24)

Làm thế nào về việc sử dụng đệ quy?

def multiply(lst):
    if len(lst) > 1:
        return multiply(lst[:-1])* lst[-1]
    else:
        return lst[0]

Giải pháp của tôi:

def multiply(numbers):
    a = 1
    for num in numbers:
        a *= num
        return a

  pass

'' 'phương pháp đơn giản duy nhất để hiểu cách sử dụng logic cho vòng lặp' ''

Lập = [2,5,7,7,9] x = 1 cho i trong Lập: x = i * x in (x)

Nó rất đơn giản không nhập bất cứ thứ gì. Đây là mã của tôi. Điều này sẽ xác định một chức năng nhân tất cả các mục trong danh sách và trả về sản phẩm của họ.

def myfunc(lst):
    multi=1
    for product in lst:
        multi*=product
    return product