मैं पायथन के साथ एक सूची में सभी वस्तुओं को कैसे गुणा कर सकता हूं?

Question

मुझे एक फ़ंक्शन लिखने की ज़रूरत है जो संख्याओं की सूची लेती है और उन्हें एक साथ गुणा करती है। उदाहरण: [1,2,3,4,5,6]मुझे दूंगा 1*2*3*4*5*6। मैं वास्तव में आपकी मदद का उपयोग कर सकता हूं।

Answer 1

पायथन 3: उपयोग functools.reduce:

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

अजगर 2: उपयोग reduce:

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

2 और 3 उपयोग के साथ संगत के लिए pip install six, फिर:

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

Comments

आप ऑपरेटर आयात नहीं करते हैं, इसलिए यह समाधान थोड़ा अधिक कॉम्पैक्ट है। मुझे आश्चर्य है कि जो तेज है।

— २२:०२ पर जूल

@jheld: मैंने 1 से 100 तक की संख्या को उत्पाद-आईएनजी दिया। दोनों lambdaपायथन 2 और 3 में, .02s / 1000 रिपेटिशन operator.mulका औसत लिया , जबकि .009s / 1000 रिपिटिशन का औसत लिया, जिससे operator.mulपरिमाण का क्रम तेजी से बना।

— व्हेरेस्वाल्डेन

@wordsforthewise शायद यह है कि एक अतिरिक्त समारोह (लैम्ब्डा) से गुजरना ओवरहेड जोड़ता है, जबकि operator.mulसीधे सी पर जाता है

— whereswalden

मैं वास्तव में .009 को परिमाण के एक आदेश को कम नहीं करूँगा .02 से कम। यह सिर्फ आधे के बारे में है।

— jlh

पायथन 3.8 के रूप में, यह बस के साथ किया जा सकता है math.prod([1,2,3,4,5,6])। (कोर्स के आयात की आवश्यकता होती है)

— टॉमेरिकू

Answer 2

आप उपयोग कर सकते हैं:

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

स्पष्टीकरण के लिए देखें reduceऔर operator.mulदस्तावेज़।

आपको import functoolsपाइथन 3+ में लाइन की आवश्यकता है ।

Comments

ध्यान दें कि python3 में, reduce()फ़ंक्शन को वैश्विक नामस्थान से हटा दिया गया है और functoolsमॉड्यूल में रखा गया है । तो python3 में आपको कहने की जरूरत है from functools import reduce।

— यूजीन यर्मश

तीसरे तर्क के रूप में '1' यहाँ अनावश्यक है, ऐसा क्या मामला है जहाँ इसकी आवश्यकता होगी?

— 18

तीसरे तर्क के बिना @wordsforthewise, यदि आप इसे एक खाली अनुक्रम पास करते हैं, तो यह एक

— टाइप

lambda x,y: x*yइसके बजाय काम करता हैoperator.mul

Answer 3

मैं numpy.prodकार्य करने के लिए उपयोग करूंगा । निचे देखो।

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

Comments

सुविधाजनक है अगर आप पहले से ही Numpy का उपयोग कर रहे हैं। आपको शायद इसे पहले एक सूची के रूप में डालने की आवश्यकता नहीं है, यह ज्यादातर मामलों के लिए काम करना चाहिएresult = np.prod(mylist)

— निक

देखने के लिए दो चीजें: 1) यह अतिप्रवाह हो सकता है, खासकर अगर 2 सेnumpy.int32 ऊपर डिफ़ॉल्ट का उपयोग करते हुए ) छोटी सूचियों के लिए यह काफी धीमी हो जाएगी, क्योंकि न्यूमपी को एक सरणी आवंटित करने की आवश्यकता है (प्रासंगिक यदि बार-बार दोहराया जाता है)

— अस्वीकृत

21 से ऊपर के मूल्यों के लिए अतिप्रवाह यहांnp.prod(np.array(range(1,21)))

— पैट्रिक टीटी

यह एक अच्छा विकल्प नहीं है। यह अतिप्रवाह कर सकता है और यह धीमा है। कोशिश करो reduce।

— पीमन

Answer 4

यदि आप कुछ भी आयात करने से बचना चाहते हैं और पाइथन के अधिक जटिल क्षेत्रों से बचना चाहते हैं, तो आप लूप के लिए एक सरल का उपयोग कर सकते हैं

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

Comments

माइनर नोट: पाइथन में स्लाइस बहुत आसान हैं, और चूंकि हम यहां केवल प्राइमेटिक्स के साथ काम कर रहे हैं, आप सूची [0] के साथ शुरू करके और सूची से अधिक ध्यान देकर 1 से शुरू होने के मामूली कीचड़ से बच सकते हैं। हालाँकि यहाँ अधिक कार्यात्मक 'कम' उत्तरों के साथ सहज होना दीर्घावधि में मूल्यवान है क्योंकि यह अन्य परिस्थितियों में भी उपयोगी है।

— कुंगफू

@kungphu खाली उत्पाद को आम तौर पर 1 के रूप में परिभाषित किया जाता है, यदि आप इसे खाली अनुक्रम देते हैं तो आपका समाधान IndexError अपवाद को फेंक देगा

— फ्रांसिस्को Couzo

@ फ्रैंसिस्को ग्रांटेड, लेकिन इस फंक्शन को शायद उस मामले में अपवाद का कुछ स्वाद फेंकना चाहिए , क्योंकि एक खाली अनुक्रम इस फ़ंक्शन के लिए अमान्य इनपुट होगा। वास्तव में, यह फ़ंक्शन दो से कम मूल्यों वाले किसी भी अनुक्रम के लिए सार्थक नहीं है; यदि आप एक मान के साथ एक अनुक्रम पास करते हैं और इसे 1 से गुणा करते हैं, तो आपने अनिवार्य रूप से एक मूल्य जोड़ा है जो वहां नहीं था, जिसे मैं अप्रत्याशित व्यवहार के लिए मात्रा कहूंगा।

— कुंगफू

@kungphu, इस उत्तर के लिए व्यवहार सही है, अर्थात लंबाई 1 की सूची को पास करने से मान लौटता है, और लंबाई 0 रिटर्न की सूची पास करना 1. यह सोचने की एक ही पंक्ति में है जो 0 या योग के रूप में योग ([]) देता है। ([3]) ३ के रूप में: देखें: en.wikipedia.org/wiki/Empty_product

— emorris

मैं गणितीय कार्यों के संबंध में आपकी बात देखता हूं। हालांकि, एक व्यावहारिक विकास की स्थिति में, मैं इसे एक बहुत ही दुर्लभ स्थिति कहूंगा जहां इनपुट पर काम करने के लिए स्पष्ट रूप से एक फ़ंक्शन है जो किसी इनपुट या अमान्य इनपुट के लिए दी गई मात्रा को वापस करना चाहिए । मुझे लगता है कि यह व्यायाम के लक्ष्य पर निर्भर करता है: यदि यह सिर्फ मानक पुस्तकालय को दोहराने के लिए है, तो ठीक है, शायद यह लोगों को कुछ सिखाता है कि भाषा (या) कैसे है या इसे लागू किया जा सकता है। अन्यथा मैं कहूंगा कि यह वैध और अमान्य तर्कों पर एक सबक प्रदान करने के अच्छे अवसर से चूक जाता है।

— कुंगफू

Answer 5

प्रारंभ Python 3.8, मानक पुस्तकालय में मॉड्यूल में एक .prodफ़ंक्शन शामिल किया गया है math:

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

विधि startमान का उत्पाद लौटाती है (डिफ़ॉल्ट: 1) संख्याओं के चलने योग्य समय:

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

>>> 720

यदि चलने योग्य खाली है, तो यह उत्पादन करेगा 1(या startमूल्य, यदि प्रदान किया गया है)।

Answer 6

यहाँ मेरी मशीन से कुछ प्रदर्शन माप हैं। यदि यह लंबे समय से चल रहे लूप में छोटे इनपुट के लिए किया जाता है, तो प्रासंगिक:

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

परिणाम:

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

आप देख सकते हैं कि Numpy छोटे इनपुट पर काफी धीमा है, क्योंकि यह गुणा करने से पहले एक सरणी आवंटित करता है। इसके अलावा, Numpy में अतिप्रवाह के लिए बाहर देखो।

Comments

आप जिज्ञासा से बाहर निकलने का रास्ता जोड़ सकते हैं

— Mr_and_Mrs_D

मुझे संदेह है कि multiply_functoolsऔर multiply_numpy देखने के लिए नीचे तौले हुए हैं np, functoolsऔर operatorग्लोबल्स, विशेषता लुकअप के बाद। क्या आप स्थानीय लोगों के लिए स्विच करना चाहेंगे? _reduce=functools.reduce, _mul = समारोह हस्ताक्षर तो में operator.mul` return _reduce(_mul, iterable)शरीर, आदि में

— मार्टिन पीटर्स

इसके अलावा, संख्यात्मक संस्करण को पहले संख्याओं को एक संख्यात्मक सरणी में बदलना होगा; आपने सामान्य रूप से उस रूपांतरण को पहले ही बना लिया है, यह सुनिश्चित करने के लिए कि समयावधि वास्तव में उचित नहीं है। सूची को एक बार एक अफीम सरणी में बदलने के साथ, np.prod()विकल्प 100 तत्वों या उससे अधिक पर सबसे तेज शुरू होता है।

— मार्टिन पीटर्स

Answer 7

मैं व्यक्तिगत रूप से एक फ़ंक्शन के लिए इसे पसंद करता हूं जो एक जेनेरिक सूची के सभी तत्वों को एक साथ गुणा करता है:

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

यह कॉम्पैक्ट है, सरल चीजों का उपयोग करता है (एक चर और एक लूप के लिए), और मेरे लिए सहज महसूस करता है (ऐसा लगता है कि मैं समस्या के बारे में कैसे सोचूंगा, बस एक ले लो, इसे गुणा करें, फिर अगले से गुणा करें, और इसी तरह) )

Comments

महान, यह सबसे सरल और सबसे सरल है।

— भूतक्रविज

क्यों नहीं for i in n:, तब total *= i? क्या यह ज्यादा सरल नहीं होगा?

— मुनीम मुन्ना

@MunimMunnaIt ने मेरे लिए उपरोक्त तरीके से काम नहीं किया।

— एथुल

Answer 8

सरल तरीका है:

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

Comments

क्या बस के बारे में np.prod(your_Array)

— dashesy

Answer 9

Numpyहै prod()समारोह है कि एक सूची के उत्पाद लौटाता है, या यह numpy के बाद से इस मामले में, यह किसी दिए गए अक्ष पर एक सरणी के उत्पाद है:

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

... या फिर आप आयात कर सकते हैं numpy.prod():

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

Answer 10

आज यह सवाल मिला, लेकिन मैंने देखा कि यह मामला नहीं है जहां Noneसूची में हैं। तो, पूरा समाधान होगा:

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

इसके अलावा, हमारे पास:

print(reduce(lambda x, y: (x if x else 0) + (y if y else 0), a))

Answer 11

nums = str(tuple([1,2,3]))
mul_nums = nums.replace(',','*')
print(eval(mul_nums))

Comments

कृपया अपने उत्तर में कुछ स्पष्टीकरण जोड़ें। उत्तर कैसे दें

— xenteros

मैं झंकार करता हूं और कोड को समझाने की कोशिश करता हूं: मैं व्यक्तिगत रूप से इस कोड को ज्यादा पसंद नहीं करता हूं, क्योंकि यह eval का उपयोग करता है, जो स्ट्रिंग को एक तर्क या फ़ंक्शन के रूप में व्याख्या करता है (और इस प्रकार आमतौर पर एक असुरक्षित चीज के रूप में देखा जाता है, खासकर जब इनपुट डेटा को संभालना होता है। )। इससे पहले की रेखा हर परिसीमन को एक गुणक द्वारा बदल देती है *, जैसे कि eval इसे गुणक के रूप में मान्यता देगा। मुझे आश्चर्य है कि इस पर प्रदर्शन, अन्य समाधानों की तुलना में

— निस्संदेह है

वाह, इतना बुरा विचार!

— कोवलस्की 21

Answer 12

मैं निम्नलिखित तरीके से इसे पसंद करूंगा:

    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

Answer 13

यह मेरा कोड है:

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

परिणाम: ('1 * 1 * 2 * 3 * 4', 24)

Answer 14

पुनरावर्तन का उपयोग कैसे करें?

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

Answer 15

मेरा समाधान:

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

  pass

Answer 16

'' 'लूप के लिए लॉजिक उपयोग को समझने की एकमात्र सरल विधि' ''

गोद = [2,5,7,7,9] x = 1 मेरे लिए गोद में: x = i * x प्रिंट (x)

Comments

आपका उत्तर इस प्रश्न की चर्चा में कुछ नया नहीं जोड़ता है।

— सिड

Answer 17

यह बहुत आसान है कुछ भी आयात न करें। यह मेरा कोड है। यह एक फ़ंक्शन को परिभाषित करेगा जो एक सूची में सभी वस्तुओं को गुणा करता है और उनके उत्पाद को वापस करता है।

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

Comments

डेडशेक्स के उत्तर के लिए डुप्लिकेट करें, पीआईएसओएक्स का जवाब, शक्ति नंदन का जवाब। पहले से सुझाए गए उत्तर को पोस्ट न करें।

— मुनीम मुन्ना

यह भी बहु लौटना चाहिए | - |

— लार्स