python - una - Agregando valores de tuplas de la misma longitud

que es una tupla

Question

En un programa gráfico que estoy escribiendo usando pygame, uso una tupla que representa una coordenada como esta: (50, 50).

A veces, llamo a una función que devuelve otra tupla como (3, -5), que representa el cambio en las coordenadas.

¿Cuál es la mejor manera de agregar el valor de cambio al valor de coordenada? Sería bueno si pudiera hacer algo como la coordenada + = cambio, pero parece que simplemente concatenaría las dos tuplas a algo como (50, 50, 3, -5). En lugar de agregar el primer valor al primer valor y el segundo al segundo, y devolver una tupla resultante.

Hasta ahora he estado usando este método bastante aburrido: coord = (coord [0] + cambio [0], coord [1] + cambio [1])

¿Qué es un método mejor y más conciso para sumar los valores de dos tuplas de la misma longitud? Parece especialmente importante saber cómo hacerlo si las tuplas son de una longitud arbitraria o de una longitud particularmente larga que harían que el método anterior sea aún más aburrido.

Answer 1

Bueno, una forma sería

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

Si está haciendo muchos cálculos matemáticos, es posible que desee investigar utilizando NumPy , que tiene un soporte de matriz mucho más potente y un mejor rendimiento.

Answer 2

Como menciona John Y, esto es bastante fácil de usar numpy.

import numpy as np

x1 = (0,3)
x2 = (4,2)
tuple(np.add(x1,x2))

Answer 3

Este es un trabajo en progreso ya que estoy aprendiendo Python por mí mismo. Podemos usar clases aquí, podríamos simplificar algunas operaciones más adelante. Propongo usar una clase de coordenadas para almacenar las coordenadas. Anularía agregar y sub para que usted pudiera hacer sumas y restas simplemente usando los operadores + y -. Podría obtener la representación de la tupla con una función incorporada en ella.

Clase

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)

Uso

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

podría mejorar la coordenada para extender otros operadores también (menor que, mayor que ..).

En esta versión, después de hacer tus cálculos, puedes llamar a los métodos de pygame esperando tuplas con solo decir coord.t (). Sin embargo, podría haber una mejor manera que tener una función para devolver la forma de tupla.

Answer 4

La comprensión de la lista es probablemente más legible, pero aquí hay otra manera:

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

Answer 5

Mis dos centavos, espero que esto ayude.

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

Answer 6

Para obtener su comportamiento "+" y "+ =", puede definir su propia clase e implementar el __add__() . La siguiente es una muestra incompleta:

# 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)

EDITAR: He encontrado una mejor manera ...

Defina la clase T como una subclase de tupla y anule los métodos __new__ y __add__ . Esto proporciona la misma interfaz que la clase tuple (pero con un comportamiento diferente para __add__ ), por lo que las instancias de la clase T se pueden pasar a cualquier cosa que espere una tupla.

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