Добавление значений из кортежей одинаковой длины

В графической программе, которую я пишу, используя pygame, я использую кортеж, представляющий такую координату: (50, 50).

Иногда я вызываю функцию, которая возвращает другой кортеж, такой как (3, -5), который представляет изменение координат.

Каков наилучший способ добавить значение изменения к значению координаты. Было бы неплохо, если бы я мог сделать что-то вроде координат + = изменение, но, похоже, это просто соединит два кортежа с чем-то вроде (50, 50, 3, -5). Вместо добавления 1-го значения к 1-му значению и 2-го к 2-му и возврата результирующего кортежа.

До сих пор я использовал этот довольно утомительный метод: Координата = (координата [0] + изменение [0], координата [1] + изменение [1])

Что является лучшим, более кратким методом для объединения значений двух кортежей одинаковой длины. Особенно важно знать, как это сделать, если кортежи имеют произвольную длину или особенно длинную длину, что сделало бы предыдущий метод еще более утомительным.

Ответ 1

Ну, одним из способов было бы

coord = tuple(sum(x) for x in zip(coord, change))

Если вы делаете много математики, вы можете исследовать с помощью NumPy, который имеет гораздо более мощную поддержку массива и лучше производительность.

Ответ 2

Понимание списка, вероятно, более читаемо, но здесь другой способ:

>>> a = (1,2)
>>> b = (3,4)
>>> tuple(map(sum,zip(a,b)))
(4,6)

Ответ 3

Это незавершенное производство, так как я сам изучаю Python. Можем ли мы использовать классы здесь, могли бы упростить некоторые операции позже. Я предлагаю использовать координатный класс для хранения координат. Он будет переопределять add и sub, чтобы вы могли делать сложение и вычитание, просто используя операторов + и -. Вы можете получить представление кортежа с встроенной функцией.

Класс

class coord(object):    
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __add__(self,c):
        return coord(self.x + c.x, self.y + c.y)

    def __sub__(self,c):
        return coord(self.x - c.x, self.y - c.y)

    def __eq__(self,c): #compares two coords
        return self.x == c.x and self.y == c.y

    def t(self): #return a tuple representation.
        return (self.x,self.y)

Использование

c1 = coord(4,3) #init coords
c2 = coord(3,4)

c3 = c1 + c2    #summing two coordinates. calls the overload __add__
print c3.t()    #prints (7, 7)
c3 = c3 - c1
print c3.t()    #prints (3, 4)
print c3 == c2  #prints True

вы можете улучшить координацию, чтобы расширить другие операторы (меньше, больше, чем..).

В этой версии после выполнения ваших вычислений вы можете вызвать методы pygame, ожидающие кортежи, просто произнесите команду coord.t(). Может быть, есть лучший способ, чем функция вернуть форму кортежа.

Ответ 4

Чтобы получить поведение "+" и "+ =", вы можете определить свой собственный класс и реализовать метод __add__(). Ниже приведен неполный пример:

# T.py
class T(object):
    def __init__(self, *args):
        self._t = args
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self._t, other._t)]))
    def __str__(self):
        return str(self._t)
    def __repr__(self):
        return repr(self._t)

>>> from T import T
>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)

EDIT: я нашел лучший способ...

Определите класс T как подкласс кортежа и переопределите методы __new__ и __add__. Это обеспечивает тот же интерфейс, что и класс tuple (но с другим поведением для __add__), поэтому экземпляры класса T могут быть переданы на все, что ожидает кортеж.

class T(tuple):
    def __new__(cls, *args):
        return tuple.__new__(cls, args)
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self, other)]))
    def __sub__(self, other):
        return self.__add__(-i for i in other)

>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)
>>> 
>>> c = a + b
>>> c[0]
60
>>> c[-1]
60
>>> for x in c:
...     print x
... 
60
40
60

Ответ 5

Мои два цента, надеюсь, что это поможет

>>> coord = (50, 50)
>>> change = (3, -5)
>>> tuple(sum(item) for item in zip(coord, change))
(53, 45)