Bir listedeki tüm öğeleri Python ile nasıl çarpabilirim?

Ben bir sayı listesi alır ve birlikte çoğalır bir işlev yazmak gerekiyor . Örnek: [1,2,3,4,5,6]Bana verecek 1*2*3*4*5*6. Yardımını gerçekten kullanabilirim.

Python 3: kullanın functools.reduce:

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

Python 2: kullanın reduce:

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

2 ve 3 kullanımı ile uyumlu pip install six, daha sonra:

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

Kullanabilirsiniz:

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

Bkz reduceve operator.mulbir açıklama belgeleri.

import functoolsPython 3 + ' da çizgiye ihtiyacınız var .

Ben numpy.prodgörevi yerine getirmek için kullanın . Aşağıya bakınız.

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

Bir şey içe aktarmaktan ve Python'un daha karmaşık alanlarından kaçınmak istiyorsanız, basit bir döngü kullanabilirsiniz.

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

Başlangıçta Python 3.8, standart kütüphanedeki modüle bir .prodfonksiyon dahil edilmiştir math:

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

Yöntem, bir startdeğerin ürününü (varsayılan: 1) yinelenebilir sayılardan döndürür:

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

>>> 720

Yinelenebilir boşsa, bu üretilecektir 1(veya startvarsa değer).

İşte makinemden bazı performans ölçümleri. Bunun uzun süren bir döngüdeki küçük girişler için yapılması durumunda geçerlidir:

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

Sonuçlar:

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

Çarpma işleminden önce bir dizi ayırdığı için Numpy'nin daha küçük girişlerde biraz daha yavaş olduğunu görebilirsiniz. Ayrıca Numpy'deki taşmaya dikkat edin.

Ben şahsen genel listenin tüm unsurlarını bir araya getiren bir fonksiyon için bunu beğendim:

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

Kompakt, basit şeyler (bir değişken ve bir for döngüsü) kullanıyor ve bana sezgisel geliyor (sorunu nasıl düşündüğüm gibi görünüyor, sadece bir tane al, çarp, sonra bir sonraki ile çarp, vb. )

Basit yol:

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

Numpyprod()bir listenin ürününü döndüren işleve sahiptir veya bu durumda numpy olduğundan, belirli bir eksen üzerindeki bir dizinin ürünüdür:

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

... yoksa yalnızca şunları içe aktarabilirsiniz numpy.prod():

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

Bu soruyu bugün buldum None, ancak listede yer alan bir durumun olmadığını fark ettim . Yani, tam çözüm şöyle olacaktır:

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

Ekleme durumunda:

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

Bunu şu şekilde istiyorum:

    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

Bu benim kodum:

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

sonuç: ('1 * 1 * 2 * 3 * 4', 24)

Özyineleme kullanmaya ne dersiniz?

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

Çözümüm:

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

  pass

'' 'Döngü için mantık kullanımını anlamak için tek basit yöntem' ''

Tur = [2,5,7,7,9] x = Turdaki i için 1: x = i * x baskı (x)

Hiçbir şey ithal etmemek çok basittir. Bu benim kodum. Bu, listedeki tüm öğeleri çarpan ve ürünlerini döndüren bir işlev tanımlayacaktır.

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