दो सूचियों का तत्व-वार गुणन कैसे करें?

Question

मैं एक तत्व वार गुणा करना चाहता हूं, पायथन में मूल्य द्वारा दो सूचियों को एक साथ गुणा करना, जैसे कि हम इसे माटाब में कर सकते हैं।

इस तरह मैं इसे मतलाब में करूंगा।

a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]

एक सूची बोध से और से और के हर संयोजन x * yके लिए 16 सूची प्रविष्टियाँ दी जाएंगी । यह कैसे नक्शा करने के लिए अनिश्चित।xayb

अगर किसी को दिलचस्पी है कि क्यों, मेरे पास एक डेटासेट है, और इसके द्वारा गुणा करना चाहते हैं Numpy.linspace(1.0, 0.5, num=len(dataset)) =)।

Comments

जब आप पहले से ही सुन्न के बारे में पूछ रहे हैं तो आप यह क्यों पूछ रहे हैं?

— pwuertz

और वैसे, यह तत्व-वार गुणन है, यह एक डॉट उत्पाद नहीं है।

— pwuertz

वैकल्पिक: नक्शा (लैम्ब्डा x, y: x * y, list1, list2) #derp ...

— xxjjnn

Answer 1

के साथ मिश्रित एक सूची समझ का उपयोग करें zip():।

[a*b for a,b in zip(lista,listb)]

Comments

दूसरी ओर, यदि वे तुच्छ मामले से परे कुछ और करना चाहते हैं तो ओपी को अच्छी तरह से नम्पी का उपयोग करने की सलाह दी जाएगी।

— हेनरी गोमर्सल

पायथन 2 पर izip () एक बेहतर विकल्प हो सकता है।

— याक

आप भी इस्तेमाल कर सकते हैं map(lambda x,y:x*y,lista,listb)।

— mbomb007

यदि हम listbटाइप के तत्वों के बजाय सूची में दिए गए हैं तो उत्तर कैसे बदलेंगे listbऔर हमें एक सूची प्राप्त करने के लिए काम करने की आवश्यकता है। पूर्व। (x, पी, ई) [(४, ५, २), (१, २, ४), (४, ५, ६), (१, १, २), (३, ३, ४)], के साथ जब (x, pi, e) को (4, 5, 2) और फिर (x, pi, e) के साथ संचालित किया गया (1, 2, 4) ... तो।

— 17

@gxyd आपको एक अलग प्रश्न पूछना चाहिए

— mbomb007

Answer 2

चूंकि आप पहले से ही उपयोग कर रहे हैं numpy, इसलिए यह आपके डेटा को numpyसूची के बजाय किसी सरणी में संग्रहीत करने के लिए समझ में आता है । एक बार जब आप ऐसा करते हैं, तो आपको मुफ्त में तत्व-वार उत्पाद जैसी चीजें मिलती हैं:

In [1]: import numpy as np

In [2]: a = np.array([1,2,3,4])

In [3]: b = np.array([2,3,4,5])

In [4]: a * b
Out[4]: array([ 2,  6, 12, 20])

Comments

शायद सबसे वैज्ञानिक नहीं, लेकिन मैंने समय का उपयोग करते हुए गाहुआ के जवाब के खिलाफ यह समय दिया। Numpy वास्तव में ज़िप विधि से थोड़ा धीमा है।

— चेस रॉबर्ट्स

मेरे मामले में, जहां सूचियों में द्विआधारी मूल्य होते हैं, खतना समाधान izip का उपयोग करने की तुलना में बहुत तेज था।

— सीरिपेंडिटी

Google खोज से यहां पहुंचने वाले अन्य लोगों के लाभ के लिए मैंने नीचे एक टाइमिट तुलना शामिल की है।

— धान

Answer 3

Np.multiply (a, b) का उपयोग करें:

import numpy as np
a = [1,2,3,4]
b = [2,3,4,5]
np.multiply(a,b)

Answer 4

आप प्रत्येक तत्व को लूप में गुणा करने का प्रयास कर सकते हैं। ऐसा करने के लिए छोटा हाथ

ab = [a[i]*b[i] for i in range(len(a))]

Comments

stackoverflow में आपका स्वागत है! कोड-केवल उत्तर आमतौर पर हतोत्साहित किए जाते हैं - कृपया कुछ स्पष्टीकरण जोड़ें कि यह प्रश्नकर्ता के प्रश्न को कैसे हल करता है।

— कॉर्ली ब्रिग्मेन

@CorleyBrigman मैं असहमत; एक उत्तर के बीच बहुत कम अंतर है जो "यहां ऐसा करने का एक तरीका है: <कोड>" और सिर्फ "<कोड>"। इस विशेष स्थिति में, "यह कोड आपकी समस्या को हल करता है" के अलावा अन्य को समझाने के लिए बहुत कम है।

— इकताराज

@CorleyBrigman मैं असहमत; परिणाम प्रदर्शित करने के साथ एक उदाहरण डेटा वास्तव में अधिक उपयोगी होगा

— तजोर्रीमेरी

यह कैसे एक सी, सी ++, या जावा प्रोग्रामर है जो पायथन नौसिखिया है समस्या को हल करेगा। स्वीकार किए जाते हैं जवाब मुहावरेदार अजगर है।

— डेविड कलन

@Tjorriemorrie परिणाम स्पष्ट हैं क्योंकि वे प्रश्न में स्पष्ट रूप से अनुरोध किए गए हैं। हो सकता है कि लिस्ट कॉम्प्रिहेंशन कैसे काम करता है, इसका विवरण अच्छा हो सकता है या यह उल्लेख करना चाहिए कि इससे लिस्ट कॉम्प्रिहेंशन का उपयोग होता है और फिर हर कोई इसे देख सकता है, अगर वे इसे नहीं जानते हैं।

— xuiqzy

Answer 5

अभी तक एक और जवाब:

-1... आयात की आवश्यकता है
+1... बहुत पठनीय है

import operator
a = [1,2,3,4]
b = [10,11,12,13]

list(map(operator.mul, a, b))

आउटपुट [10, 22, 36, 52]

Comments

यदि आप मानचित्र जानते हैं, तो यह वास्तव में पठनीय समाधान है! क्या फ़ाइल के शीर्ष पर होने के अलावा आयात का कोई नकारात्मक परिणाम है? (संपादक यदि चाहें तो आयात को छिपा सकते हैं) जहाँ तक मैं देख सकता हूँ, यह हर 2 और 3 संस्करण में उपलब्ध होना चाहिए!

— xuiqzy

Answer 6

ऐसा करने का काफी सहज तरीका:

a = [1,2,3,4]
b = [2,3,4,5]
ab = []                        #Create empty list
for i in range(0, len(a)):
     ab.append(a[i]*b[i])      #Adds each element to the list

Answer 7

आप का उपयोग कर गुणा कर सकते हैं lambda

foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)

Answer 8

बड़ी सूचियों के लिए, हम इसे पुनरावृत्त कर सकते हैं:

product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])

product_iter_object.next() आउटपुट सूची में प्रत्येक तत्व देता है।

आउटपुट दो इनपुट सूचियों में से छोटी लंबाई होगी।

Answer 9

लोगों की एक सरणी बनाएँ; प्रत्येक सूची को सरणी से गुणा करें; सरणी को सूची में बदलें

import numpy as np

a = [1,2,3,4]
b = [2,3,4,5]

c = (np.ones(len(a))*a*b).tolist()

[2.0, 6.0, 12.0, 20.0]

Answer 10

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

0.0049ms -> N = 4, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0075ms -> N = 4, a = [i for i in range(N)], c = a * b
0.0167ms -> N = 4, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 4, a = np.arange(N), c = a * b
0.0171ms -> N = 40, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0095ms -> N = 40, a = [i for i in range(N)], c = a * b
0.1077ms -> N = 40, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0013ms -> N = 40, a = np.arange(N), c = a * b
0.1485ms -> N = 400, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)]
0.0397ms -> N = 400, a = [i for i in range(N)], c = a * b
1.0348ms -> N = 400, a = np.arange(N), c = [a*b for a,b in zip(a, b)]
0.0020ms -> N = 400, a = np.arange(N), c = a * b

यानी निम्नलिखित परीक्षण कार्यक्रम से।

import timeit

init = ['''
import numpy as np
N = {}
a = {}
b = np.linspace(0.0, 0.5, len(a))
'''.format(i, j) for i in [4, 40, 400] 
                  for j in ['[i for i in range(N)]', 'np.arange(N)']]

func = ['''c = [a*b for a,b in zip(a, b)]''',
'''c = a * b''']

for i in init:
  for f in func:
    lines = i.split('\n')
    print('{:6.4f}ms -> {}, {}, {}'.format(
           timeit.timeit(f, setup=i, number=1000), lines[2], lines[3], f))

Answer 11

Enumerate का उपयोग कर सकते हैं।

a = [1, 2, 3, 4]
b = [2, 3, 4, 5]

ab = [val * b[i] for i, val in enumerate(a)]

Answer 12

mapसमारोह यहां बहुत उपयोगी हो सकता है। mapहम प्रयोग करके किसी भी फ़ंक्शन को चलने के प्रत्येक तत्व पर लागू कर सकते हैं।

अजगर 3.x

>>> def my_mul(x,y):
...     return x*y
...
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>>
>>> list(map(my_mul,a,b))
[2, 6, 12, 20]
>>>

बेशक:

map(f, iterable)

के बराबर है

[f(x) for x in iterable]

तो हम अपने समाधान के माध्यम से प्राप्त कर सकते हैं:

>>> [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
>>>

पायथन में 2.x का map()अर्थ है: एक चलने वाले के प्रत्येक तत्व के लिए एक फ़ंक्शन लागू करें और एक नई सूची का निर्माण करें। पायथन 3.x में, mapसूचियों के बजाय पुनरावृत्तियों का निर्माण करें।

इसके बजाय my_mulहम mulऑपरेटर का उपयोग कर सकते हैं

पायथन 2.7

>>>from operator import mul # import mul operator
>>>a = [1,2,3,4]
>>>b = [2,3,4,5]
>>>map(mul,a,b)
[2, 6, 12, 20]
>>>

पायथन 3.5+

>>> from operator import mul
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>> [*map(mul,a,b)]
[2, 6, 12, 20]
>>>

कृपया ध्यान दें कि चूंकि map()एक *पुनरावृत्तिकर्ता का निर्माण करता है, इसलिए हम सूची प्राप्त करने के लिए चलने योग्य अनपैकिंग ऑपरेटर का उपयोग करते हैं । अनपैकिंग एप्रोच थोड़ा तेज है तो listकंस्ट्रक्टर:

>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>

Answer 13

सूची प्रकार को बनाए रखने के लिए, और इसे एक पंक्ति में करें (np के रूप में सुन्न आयात करने के बाद, निश्चित रूप से):

list(np.array([1,2,3,4]) * np.array([2,3,4,5]))

या

list(np.array(a) * np.array(b))

Answer 14

आप इसे समान लंबाई की सूचियों के लिए उपयोग कर सकते हैं

def lstsum(a, b):
    c=0
    pos = 0
for element in a:
   c+= element*b[pos]
   pos+=1
return c