पायथन में 2 सूचियों को घटाना

Question 1

अभी मेरे पास सूचियों के रूप में प्रतिनिधित्व वाले वेक्टर 3 मूल्य हैं। वहाँ वेक्टर 3 मूल्यों की तरह इनमें से 2 को घटाने का एक तरीका है, जैसे

[2,2,2] - [1,1,1] = [1,1,1]

क्या मुझे टुपल्स का उपयोग करना चाहिए?

यदि उनमें से कोई भी इन प्रकारों पर इन ऑपरेंड को परिभाषित नहीं करता है, तो क्या मैं इसके बजाय इसे परिभाषित कर सकता हूं?

यदि नहीं, तो क्या मुझे एक नया वेक्टर 3 वर्ग बनाना चाहिए?

Question 2

यदि यह ऐसा कुछ है जिसे आप बार-बार करते हैं, और विभिन्न कार्यों के साथ, तो आपको संभवतः इस तरह के मामलों को संभालने के लिए एक वर्ग बनाना चाहिए, या कुछ पुस्तकालय जैसे नम्पी का बेहतर उपयोग करना चाहिए ।

अन्यथा, जिप बिलिन फ़ंक्शन के साथ उपयोग की जाने वाली सूची समझ के लिए देखें :

[a_i - b_i for a_i, b_i in zip(a, b)]

Question 3

यहाँ सूची समझ का एक विकल्प है। मानचित्र सूची (ओं) (बाद वाले तर्कों) के माध्यम से पुनरावृत्त करता है, ऐसा करने के लिए, और साथ ही उनके तत्वों को फ़ंक्शन (पहले arg) के तर्क के रूप में पारित करता है। यह परिणामी सूची देता है।

map(operator.sub, a, b)

यह कोड क्योंकि कम सिंटैक्स है (जो मेरे लिए अधिक सौंदर्यवादी है), और जाहिर है यह लंबाई 5 की सूचियों के लिए 40% तेज है (देखें बॉबिन की टिप्पणी)। फिर भी, या तो समाधान काम करेगा।

Question 4

यदि आपकी सूचियाँ a और b हैं, तो आप यह कर सकते हैं:

map(int.__sub__, a, b)

लेकिन आप शायद नहीं करना चाहिए। किसी को नहीं पता होगा कि इसका क्या मतलब है।

Question 5

मेरा सुझाव है होगा NumPy साथ ही

यह न केवल वेक्टर गणित करने के लिए तेज़ है, बल्कि इसमें एक टन सुविधा कार्य भी है।

यदि आप 1 डी वैक्टर के लिए और भी तेज़ चाहते हैं, तो vop आज़माएँ

यह MatLab के समान है, लेकिन मुफ्त और सामान है। यहाँ एक उदाहरण है कि आप क्या करेंगे

from numpy import matrix
a = matrix((2,2,2))
b = matrix((1,1,1))
ret = a - b
print ret
>> [[1 1 1]]

बूम।

Question 6

यदि आपके पास 'a' और 'b' नामक दो सूचियाँ हैं, तो आप यह कर सकते हैं: [m - n for m,n in zip(a,b)]

Question 7

import numpy as np
a = [2,2,2]
b = [1,1,1]
np.subtract(a,b)

Question 8

थोड़ा अलग वेक्टर क्लास।

class Vector( object ):
    def __init__(self, *data):
        self.data = data
    def __repr__(self):
        return repr(self.data) 
    def __add__(self, other):
        return tuple( (a+b for a,b in zip(self.data, other.data) ) )  
    def __sub__(self, other):
        return tuple( (a-b for a,b in zip(self.data, other.data) ) )

Vector(1, 2, 3) - Vector(1, 1, 1)

Question 9

यदि आप साधारण एक से अधिक लाइनरों के प्रदर्शन की योजना बनाते हैं, तो बेहतर होगा कि अपनी कक्षा को लागू करें और उपयुक्त ऑपरेटरों को ओवरराइड करें क्योंकि वे आपके मामले में लागू होते हैं।

पायथन में गणित से लिया गया :

class Vector:

  def __init__(self, data):
    self.data = data

  def __repr__(self):
    return repr(self.data)  

  def __add__(self, other):
    data = []
    for j in range(len(self.data)):
      data.append(self.data[j] + other.data[j])
    return Vector(data)  

x = Vector([1, 2, 3])    
print x + x

Question 10

जो Pycharm पर कोड करता था, उसके लिए यह दूसरों को भी पुनर्जीवित करता है।

 import operator
 Arr1=[1,2,3,45]
 Arr2=[3,4,56,78]
 print(list(map(operator.sub,Arr1,Arr2)))

Question 11

इस तरह की समस्या के लिए पायथन में mapऔर lambdaकार्यों का संयोजन एक अच्छा समाधान है:

a = [2,2,2]
b = [1,1,1]
map(lambda x,y: x-y, a,b)

zip फ़ंक्शन एक और अच्छा विकल्प है, जैसा कि @UncleZeiv द्वारा प्रदर्शित किया गया है

Question 12

arr1=[1,2,3]
arr2=[2,1,3]
ls=[arr2-arr1 for arr1,arr2 in zip(arr1,arr2)]
print(ls)
>>[1,-1,0]

Question 13

यह उत्तर दिखाता है कि "सामान्य / आसानी से समझने योग्य" पायथोनिक कोड कैसे लिखना है।

मेरा सुझाव है कि zipवास्तव में हर कोई इसके बारे में नहीं जानता।

समाधान सूची समझ और सामान्य अंतर्निहित कार्यों का उपयोग करते हैं।

वैकल्पिक 1 (अनुशंसित):

a = [2, 2, 2]
b = [1, 1, 1]
result = [a[i] - b[i] for i in range(len(a))]

अनुशंसित है क्योंकि यह केवल पायथन में सबसे बुनियादी कार्यों का उपयोग करता है

वैकल्पिक 2:

a = [2, 2, 2]
b = [1, 1, 1]
result = [x - b[i] for i, x in enumerate(a)]

वैकल्पिक 3 (जैसा कि BioCoder द्वारा उल्लिखित है ):

a = [2, 2, 2]
b = [1, 1, 1]
result = list(map(lambda x, y: x - y, a, b))

Question 14

इसे इस्तेमाल करे:

list(array([1,2,3])-1)