समान लंबाई के टुपल्स से मूल्य जोड़ना

Question

एक ग्राफिकल प्रोग्राम में मैं पायगमे का उपयोग कर लिख रहा हूं, मैं इस तरह के समन्वय का प्रतिनिधित्व करने वाले टुपल का उपयोग करता हूं: (50, 50)।

कभी-कभी, मैं एक फ़ंक्शन को कॉल करता हूं जो एक और टुपल (3, -5) देता है, जो समन्वय में परिवर्तन का प्रतिनिधित्व करता है।

समन्वय मूल्य में परिवर्तन मूल्य जोड़ने का सबसे अच्छा तरीका क्या है। यह अच्छा होगा अगर मैं समन्वय + = परिवर्तन की तरह कुछ कर सकता था, लेकिन ऐसा लगता है कि बस दो tuples को कुछ (50, 50, 3, -5) में जोड़ देगा। पहले मान को 1 मान और दूसरे से दूसरे में जोड़ने और परिणामी टुपल लौटने की बजाय।

अब तक मैं इस बल्कि थकाऊ विधि का उपयोग किया गया है: coord = (coord [0] + परिवर्तन [0], coord [1] + परिवर्तन [1])

क्या एक बेहतर, अधिक है एक ही लंबाई के दो tuples के मूल्यों को एक साथ जोड़ने के लिए संक्षिप्त विधि। यह जानना विशेष रूप से महत्वपूर्ण है कि यह कैसे करना है यदि टुपल्स मनमानी लंबाई या विशेष रूप से लंबी लंबाई के होते हैं जो पिछली विधि को और भी कठिन बना देता है।

Answer 1

ठीक है, एक तरह से किया जाएगा

coord = tuple(sum(x) for x in zip(coord, change)) 

यदि आप बहुत सारे गणित कर रहे हैं, तो आप NumPy का उपयोग करके जांच करना चाहेंगे, जिसमें बहुत अधिक पाउ है rful सरणी समर्थन और बेहतर प्रदर्शन।

Answer 2

मेरे दो सेंट, इस में मदद करता है

>>> coord = (50, 50) 
>>> change = (3, -5) 
>>> tuple(sum(item) for item in zip(coord, change)) 
(53, 45) 

Answer 3

सूची समझ शायद अधिक पठनीय है, लेकिन यहाँ एक और तरीका है आशा:

>>> a = (1,2) 
>>> b = (3,4) 
>>> tuple(map(sum,zip(a,b))) 
(4,6) 

Answer 4

यह एक काम प्रगति पर है क्योंकि मैं खुद पाइथन सीख रहा हूं। क्या हम यहां कक्षाओं का उपयोग कर सकते हैं, बाद में कुछ परिचालनों को सरल बना सकते हैं। मैं निर्देशांक स्टोर करने के लिए एक समन्वय वर्ग का उपयोग करने का प्रस्ताव करता हूं। यह ऐड और उप ओवरराइड करेगा ताकि आप ऑपरेटर + और - का उपयोग करके अतिरिक्त और घटाव कर सकें। आप इसमें बनाए गए फ़ंक्शन के साथ टुपल प्रस्तुति प्राप्त कर सकते हैं।

कक्षा

class coord(object):  
    def __init__(self,x,y): 
     self.x = x 
     self.y = y 

    def __add__(self,c): 
     return coord(self.x + c.x, self.y + c.y) 

    def __sub__(self,c): 
     return coord(self.x - c.x, self.y - c.y) 

    def __eq__(self,c): #compares two coords 
     return self.x == c.x and self.y == c.y 

    def t(self): #return a tuple representation. 
     return (self.x,self.y) 

प्रयोग

c1 = coord(4,3) #init coords 
c2 = coord(3,4) 

c3 = c1 + c2 #summing two coordinates. calls the overload __add__ 
print c3.t() #prints (7, 7) 
c3 = c3 - c1 
print c3.t() #prints (3, 4) 
print c3 == c2 #prints True 

आप अन्य ऑपरेटरों का विस्तार करने के साथ ही coord सुधार सकता है (कम से कम, इससे बड़ा ..)।

अपनी गणना करने के बाद इस संस्करण में आप केवल pygame विधियों को tuples की अपेक्षा कर सकते हैं। Com.t()। यद्यपि टुपल फॉर्म को वापस करने के लिए फ़ंक्शन होने से बेहतर तरीका हो सकता है।

Answer 5

अपना "+" और "+ =" व्यवहार प्राप्त करने के लिए आप अपनी कक्षा को परिभाषित कर सकते हैं और __add__() विधि लागू कर सकते हैं।

# T.py 
class T(object): 
    def __init__(self, *args): 
     self._t = args 
    def __add__(self, other): 
     return T(*([sum(x) for x in zip(self._t, other._t)])) 
    def __str__(self): 
     return str(self._t) 
    def __repr__(self): 
     return repr(self._t) 

>>> from T import T 
>>> a = T(50, 50) 
>>> b = T(3, -5) 
>>> a 
(50, 50) 
>>> b 
(3, -5) 
>>> a+b 
(53, 45) 
>>> a+=b 
>>> a 
(53, 45) 
>>> a = T(50, 50, 50) 
>>> b = T(10, -10, 10) 
>>> a+b 
(60, 40, 60) 
>>> a+b+b 
(70, 30, 70) 

संपादित करें: निम्नलिखित एक अधूरी नमूना है मैं एक बेहतर तरीका मिल गया है ...

कक्षा टी को ट्यूपल के उप-वर्ग के रूप में परिभाषित करें और __new__ और __add__ विधियों को ओवरराइड करें। यह कक्षा tuple (लेकिन __add__ के लिए अलग-अलग व्यवहार के साथ) के समान इंटरफ़ेस प्रदान करता है, इसलिए कक्षा टी के उदाहरण किसी भी चीज को पारित किए जा सकते हैं।

class T(tuple): 
    def __new__(cls, *args): 
     return tuple.__new__(cls, args) 
    def __add__(self, other): 
     return T(*([sum(x) for x in zip(self, other)])) 
    def __sub__(self, other): 
     return self.__add__(-i for i in other) 

>>> a = T(50, 50) 
>>> b = T(3, -5) 
>>> a 
(50, 50) 
>>> b 
(3, -5) 
>>> a+b 
(53, 45) 
>>> a+=b 
>>> a 
(53, 45) 
>>> a = T(50, 50, 50) 
>>> b = T(10, -10, 10) 
>>> a+b 
(60, 40, 60) 
>>> a+b+b 
(70, 30, 70) 
>>> 
>>> c = a + b 
>>> c[0] 
60 
>>> c[-1] 
60 
>>> for x in c: 
...  print x 
... 
60 
40 
60