Opérations de tuple élément par élément Python comme sum

Existe-t-il de toute façon pour que les opérations de tuple en Python fonctionnent comme ceci:

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

au lieu de:

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

Je sais que cela fonctionne comme ça parce que les méthodes __add__et __mul__sont définies pour fonctionner comme ça. Alors le seul moyen serait de les redéfinir?

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

Utilisation de tous les éléments intégrés.

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

Cette solution ne nécessite pas d'importation:

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

En quelque sorte combiné les deux premières réponses, avec un ajustement du code d'ironfroggy pour qu'il renvoie un tuple:

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)

Remarque: utilisez self.__class__au lieu de stuplepour faciliter le sous-classement.

from numpy import *

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

print a + b

donne array([4,4,4]).

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

La compréhension du générateur pourrait être utilisée à la place de la carte. La fonction de carte intégrée n'est pas obsolète mais elle est moins lisible pour la plupart des gens que la compréhension de liste / générateur / dict, donc je vous recommande de ne pas utiliser la fonction de carte en général.

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

solution simple sans définition de classe qui retourne tuple

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

Toute solution de générateur. Je ne suis pas sûr des performances (itertools est rapide, cependant)

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

Oui. Mais vous ne pouvez pas redéfinir les types intégrés. Vous devez les sous-classer:

class MyTuple (tuple):
    def __add __ (soi, autre):
         si len (soi)! = len (autre):
             lever ValueError ("les longueurs de tuple ne correspondent pas")
         retourne MyTuple (x + y pour (x, y) dans zip (self, other))

encore plus simple et sans utiliser de carte, vous pouvez le faire

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

Je sous-classe actuellement la classe "tuple" pour surcharger +, - et *. Je trouve que cela rend le code beau et l'écriture du code plus facile.

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)

Au cas où quelqu'un aurait besoin de faire la moyenne d'une liste de tuples:

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