130

无论如何让Python中的元组操作像这样工作：

>>> 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__and__mul__方法被定义为这样工作。那么唯一的方法是重新定义它们吗？

4

14 回答 14

159 
import operator
tuple(map(operator.add, a, b))
于 2009-01-31T00:55:01.313 回答
149

使用所有内置插件..

tuple(map(sum, zip(a, b)))
于 2009-01-31T02:49:16.993 回答
38

此解决方案不需要导入：

tuple(map(lambda x, y: x + y, tuple1, tuple2))
于 2012-10-03T06:20:20.357 回答
21 
from numpy import array

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

print a + b

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

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

于 2009-01-31T22:25:06.467 回答
20

将前两个答案组合在一起，对 Ironfroggy 的代码进行了调整，使其返回一个元组：

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简化子类化。

于 2009-01-31T01:10:18.303 回答
17

可以使用生成器理解而不是地图。内置的 map 函数并没有过时，但对大多数人来说，它的可读性不如 list/generator/dict 理解，所以我建议一般不要使用 map 函数。

tuple(p+q for p, q in zip(a, b))
于 2016-01-14T20:22:45.280 回答
6

没有返回元组的类定义的简单解决方案

import operator
tuple(map(operator.add,a,b))
于 2010-06-24T16:10:24.917 回答
6

所有发电机解决方案。不确定性能（虽然 itertools 很快）

import itertools
tuple(x+y for x, y in itertools.izip(a,b))
于 2012-09-26T21:25:32.603 回答
6

更简单，不使用地图，你可以做到这一点

>>> tuple(sum(i) for i in zip((1, 2, 3), (3, 2, 1)))
(4, 4, 4)
于 2016-06-12T23:17:31.947 回答
3

是的。但是你不能重新定义内置类型。您必须对它们进行子类化：

MyTuple 类（元组）：
    def __add__(self, other):
         如果 len(self) != len(other):
             raise ValueError("元组长度不匹配")
         return MyTuple(x + y for (x, y) in zip(self, other))
于 2009-01-31T00:55:54.213 回答
1

我目前将“元组”类子类化以重载 +、- 和 *。我发现它使代码更漂亮并且更容易编写代码。

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)
于 2019-06-25T18:06:48.720 回答
0

如果您已经在使用numpy. 它很紧凑，加法运算可以用任何numpy 表达式代替。

import numpy as np
tuple(np.array(a) + b)
于 2020-12-17T16:23:46.943 回答
0

我一直回到这个问题，我并不特别喜欢任何答案，因为他们都在回答一般情况的问题，我通常在寻找特殊情况的答案：我通常使用一个固定的元组计数，例如对于 n 维。

   # eg adding a dx/dy to an xy point.
   # if I have a point xy and another point dxdy
   x, y = xy
   dx, dy = dxdy
   return x+dx, y+dy

虽然我通常对不必要的变量感到不寒而栗，但我解包元组的原因通常是因为我正在作为个人处理元素，这就是上面要求的元组添加所发生的事情。

于 2021-12-28T22:32:05.827 回答
-2

如果有人需要平均一个元组列表：

import operator 
from functools import reduce
tuple(reduce(lambda x, y: tuple(map(operator.add, x, y)),list_of_tuples))
于 2018-01-20T04:32:32.870 回答