Operações de tupla em elementos do Python, como soma

Existe alguma maneira de fazer com que as operações de tupla em Python funcionem assim:

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

ao invés de:

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

Eu sei que funciona assim porque os métodos __add__e __mul__são definidos para funcionar assim. Então, a única maneira seria redefini-los?

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

Usando todos os integrados ..

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

Esta solução não requer importação:

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

Uma espécie de combinação das duas primeiras respostas, com um ajuste no código do ironfroggy para que ele retornasse uma tupla:

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)

Nota: usar em self.__class__vez de stuplepara facilitar a subclasse.

from numpy import *

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

print a + b

dá array([4,4,4]).

Veja http://www.scipy.org/Tentative_NumPy_Tutorial

A compreensão do gerador pode ser usada em vez do mapa. A função de mapa embutida não é obsoleta, mas é menos legível para a maioria das pessoas do que a compreensão de lista / gerador / dicionário, então eu recomendo não usar a função de mapa em geral.

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

solução simples sem definição de classe que retorna tupla

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

Toda solução de gerador. Não tenho certeza sobre o desempenho (embora os itertools sejam rápidos)

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

Sim. Mas você não pode redefinir os tipos integrados. Você deve subclassificá-los:

classe MyTuple (tuple):
    def __add __ (self, other):
         se len (próprio)! = len (outro):
             aumentar ValueError ("comprimentos de tupla não correspondem")
         return MyTuple (x + y for (x, y) in zip (self, other))

ainda mais simples e sem usar o mapa, você pode fazer isso

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

Atualmente, eu subclasse a classe "tupla" para sobrecarregar +, - e *. Acho que torna o código mais bonito e mais fácil escrevê-lo.

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)

Caso alguém precise calcular a média de uma lista de tuplas:

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