पाइथन तत्व-वार टपल ऑपरेशन जैसे योग

Question

क्या इस तरह से काम करने के लिए पाइथन में टुपल ऑपरेशन करवाना है:

>>> a = (1,2,3)
>>> b = (3,2,1)
>>> a + b
(4,4,4)

के बजाय:

>>> a = (1,2,3)
>>> b = (3,2,1)
>>> a + b
(1,2,3,3,2,1)

मुझे पता है कि यह इस तरह काम करता है क्योंकि इस तरह काम करने के लिए तरीकों __add__और __mul__तरीकों को परिभाषित किया जाता है। तो उन्हें फिर से परिभाषित करने का एकमात्र तरीका होगा?

Answer 1

import operator
tuple(map(operator.add, a, b))

Comments

मैं कहूंगा कि यह सबसे पायथन समाधान है।

— मैथ्यू Schinckel

सिवाय इसके कि नक्शा () अर्ध-पदावनत है। एक लेख के लिए artima.com/weblogs/viewpost.jsp?thread=98196 देखें, जहां गिदो ने उल्लेख किया है कि मानचित्र को सूची बोध के रूप में बेहतर कैसे लिखा जाता है।

— एडम पार्किन

यह भी अगर एक समान बी तत्वों की संख्या शामिल नहीं है, या "जोड़ने योग्य" नहीं हैं (पूर्व:map(operator.add, (1,2), ("3", "4"))

— एडम पार्किन

tuple([item1 + item2 for item1, item2 in zip(a, b)])सूची बोध के रूप में समतुल्य होगा।

— एडम पार्किन

@AdamParkin, जनरेटर की समझ और भी बेहतर है tuple(item1 + item2 for item1, item2 in zip(a, b))।

— बजे क्रिस्टियन सियुपिटु

Answer 2

सभी बिल्ट-इन का उपयोग ..

tuple(map(sum, zip(a, b)))

Comments

यह सरल, श्रेष्ठ उत्तर प्रतीत होता है। इसे स्वीकार क्यों नहीं किया जाता?

— मार्क सिनडेला

यह अच्छा है, लेकिन तकनीकी रूप से ऐसा नहीं है, क्योंकि नक्शा एक सूची देता है, न कि टपल ... इसलिए:tuple(map(sum,zip(a,b))

— बेन

वाक्य-विन्यास रहस्यवादी है।

— अनातोली टेकटोनिक

इसका लाभ यह है कि आप इसे बढ़ा सकते हैं:tuple(map(sum,zip(a,b, c))

— एंडी हेडन

Answer 3

इस समाधान के लिए आयात की आवश्यकता नहीं है:

tuple(map(lambda x, y: x + y, tuple1, tuple2))

Comments

यह समाधान अन्य नो-इंपोर्ट, वन-लाइनर समाधान ( map(sum, zip(a, b)))

— एयर

Answer 4

संयुक्त पहले दो उत्तरों को क्रमबद्ध करें, जिसमें आयरनफ्रॉग्जी के कोड के साथ एक मोड़ दिया जाए ताकि यह टपल लौटे:

import operator

class stuple(tuple):
    def __add__(self, other):
        return self.__class__(map(operator.add, self, other))
        # obviously leaving out checking lengths

>>> a = stuple([1,2,3])
>>> b = stuple([3,2,1])
>>> a + b
(4, 4, 4)

नोट: उपवर्ग को कम करने के self.__class__बजाय उपयोग करना stuple।

Answer 5

from numpy import *

a = array( [1,2,3] )
b = array( [3,2,1] )

print a + b

देता है array([4,4,4])।

Http://www.scipy.org/Tentative_NumPy_Tutorial देखें

Comments

यह काम करेगा, लेकिन सिंपल इंपोर्ट ऑपरेशन के लिए सिर्फ खतना आयात करना थोड़ा भारी है।

Answer 6

नक्शे के बजाय जेनरेटर की समझ का इस्तेमाल किया जा सकता है। अंतर्निहित मानचित्र फ़ंक्शन अप्रचलित नहीं है, लेकिन यह सूची / जनरेटर / तानाशाह समझ की तुलना में ज्यादातर लोगों के लिए कम पठनीय है, इसलिए मैं सामान्य रूप से मानचित्र फ़ंक्शन का उपयोग नहीं करने की सलाह दूंगा।

tuple(p+q for p, q in zip(a, b))

Answer 7

वर्ग परिभाषा के बिना सरल समाधान जो टपल लौटाता है

import operator
tuple(map(operator.add,a,b))

Answer 8

सभी जनरेटर समाधान। प्रदर्शन पर निश्चित नहीं है (यह तेजी से तेज है, हालांकि)

import itertools
tuple(x+y for x, y in itertools.izip(a,b))

Answer 9

हाँ। लेकिन आप अंतर्निहित प्रकारों को फिर से परिभाषित नहीं कर सकते। आपको उन्हें उप-वर्ग करना होगा:

वर्ग MyTuple (टुपल):
    def __add __ (स्व, अन्य):
         अगर लेन (स्व)! = लेन (अन्य):
             ValueRrror बढ़ाएँ ("टुपल लंबाई मेल नहीं खाती")
         MyTuple (x + y for (x, y) के लिए ज़िप में लौटें (स्व, अन्य))

Comments

लेकिन तब आप टूपल सिंटैक्स का उपयोग नहीं कर सकते।

— Airportyh

Answer 10

और भी सरल और नक्शे का उपयोग किए बिना, आप ऐसा कर सकते हैं

>>> tuple(sum(i) for i in zip((1, 2, 3), (3, 2, 1)))
(4, 4, 4)

Answer 11

मैं वर्तमान में "टपल" वर्ग को अधिभार +, - और * के लिए उपवर्ग में रखता हूँ। मुझे लगता है कि यह कोड को सुंदर बनाता है और कोड को लिखना आसान बनाता है।

class tupleN(tuple):
    def __add__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x+y for x,y in zip(self,other))
    def __sub__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x-y for x,y in zip(self,other))
    def __mul__(self, other):
        if len(self) != len(other):
             return NotImplemented
        else:
             return tupleN(x*y for x,y in zip(self,other))


t1 = tupleN((1,3,3))
t2 = tupleN((1,3,4))
print(t1 + t2, t1 - t2, t1 * t2, t1 + t1 - t1 - t1)
(2, 6, 7) (0, 0, -1) (1, 9, 12) (0, 0, 0)

Answer 12

यदि किसी को टुपल्स की सूची औसत करने की आवश्यकता होती है:

import operator 
from functools import reduce
tuple(reduce(lambda x, y: tuple(map(operator.add, x, y)),list_of_tuples))