Các phép toán tuple khôn ngoan phần tử Python như sum

Có cách nào để các hoạt động tuple trong Python hoạt động như thế này không:

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

thay vì:

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

Tôi biết nó hoạt động như vậy vì các __add__và __mul__phương thức được định nghĩa để hoạt động như vậy. Vì vậy, cách duy nhất sẽ là xác định lại chúng?

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

Sử dụng tất cả cài sẵn ..

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

Giải pháp này không yêu cầu nhập:

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

Sắp xếp kết hợp hai câu trả lời đầu tiên, với một chỉnh sửa đối với mã của ironfroggy để nó trả về một bộ giá trị:

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)

Lưu ý: sử dụng self.__class__thay vì stupleđể dễ phân lớp.

from numpy import *

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

print a + b

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

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

Khả năng hiểu của máy phát điện có thể được sử dụng thay cho bản đồ. Chức năng bản đồ tích hợp không lỗi thời nhưng nó kém dễ đọc đối với hầu hết mọi người so với khả năng hiểu danh sách / trình tạo / đọc chính tả, vì vậy tôi khuyên bạn không nên sử dụng chức năng bản đồ nói chung.

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

giải pháp đơn giản không có định nghĩa lớp trả về tuple

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

Tất cả các giải pháp máy phát điện. Không chắc chắn về hiệu suất (mặc dù itertools nhanh)

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

Đúng. Nhưng bạn không thể xác định lại các loại tích hợp. Bạn phải phân loại chúng:

lớp MyTuple (tuple):
    def __add __ (tự, khác):
         if len (self)! = len (other):
             tăng ValueError ("độ dài bộ giá trị không khớp")
         trả về MyTuple (x + y cho (x, y) ở dạng zip (self, other))

thậm chí đơn giản hơn và không cần sử dụng bản đồ, bạn có thể làm điều đó

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

Tôi hiện phân lớp lớp "tuple" thành quá tải +, - và *. Tôi thấy nó làm cho mã đẹp và viết mã dễ dàng hơn.

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)

Trong trường hợp ai đó cần tính trung bình một danh sách các bộ giá trị:

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