PYTHON

class Punto:
    # Se usan valores estándar al construir el objeto
    def __init__(self, x=0.0, y=0.0):
        self.x = x
        self.y = y

    # Los getters se usar para obtener algún valor que existe dentro de un objeto.
    # (getter)
    def demeX(self):
        return self.x

    # (getter)
    def demeY(self):
        return self.y

    # Los setters se usan para modificar valores existente dentro de un objeto.
    # (setter)
    def modificarY(self, y):
        self.y = y

    # (setter)
    def modificarX(self, x):
        self.x = x

    # TODO: Investigar si podemos solo llamar a la función para que sólo se cree una nueva variable
    # En este caso asumimos que self puede ser un punto definido anteriormente

    # En este caso se define un nuevo punto, esto no es necesario (1era iteración resolviendo)
    # Se pasa el self como parámetro (no es necesario)
    # El nuevo objeto se crea a partir del self
    #Se accede a las variables de objeto directamente (mal)
    def clonar(self, p):
        np = Punto()
        np.y = p.x
        np.x = p.y
        return np

    # En este caso se define un nuevo punto, esto no es necesario (2da iteración resolviendo)
    # No es necesario pasar un punto como parámetro
    # El nuevo objeto se crea a partir del self
    def clonar(self):
        np = Punto()
        np.y = self.y
        np.x = self.x
        return np

    # En este caso sólo se reducen las lineas de codigo del método, no es necesario usar parámetros.
    # El objeto se crea a partir del self, el objeto sobre el cual es llamado el método clonarNuevo().
    # (3ra iteración resolviendo, luego de investigar).
    # El llamado a Punto() ya genera un objeto nuevo.
    def clonarNuevo(self):
        return Punto(self.x, self.y)

    # Este metodo solo toma el self y un punto YA EXISTENTE y copia los valores de uno a otro.
    # Se asume que los 2 puntos ya existen y cada uno tiene sus propios valores.
    def copiar(self, p):
        self.y = p.y
        self.x = p.x

    # Este metodo solo toma el self y un punto YA EXISTENTE y copia los valores de uno a otro
    # Es igual al anterior pero en este se usan los getters definidos anteriormente
    def copiarNuevo(self, p):
        self.y = p.demeY()
        self.x = p.demeX()

    # Este metodo solo toma el self y un punto YA EXISTENTE y copia los valores de uno a otro
    # Se usan los setters y getters antes definidos
    def copiarNuevo2(self, p):
        self.modificarX(p.demeX())
        self.modificarY(p.demeY())

p1 = Punto(10, 60)

# El objeto se crea a partir del self
# p2 = p1.clonar(p1)

# El objeto se crea a partir del self
# p2 = p1.clonar()

# El objeto se crea a partir del self, el objeto sobre el cual es llamado el método clonarNuevo()
p2 = p1.clonarNuevo()

print("1er punto (p1)")
print(f"X= {p1.x}")
print(f"Y= {p1.y}")

print("Punto cl onado (p1 ---> p2)")
print(f"X=  {p2.x}")
print(f"Y=  {p2.y}")

# Podemos ver que los puntos no comparten memoria, no se han generado dependencias.
# Los 2 objetos son independientes.
print("Ids: ")
print(f"p1: {id(p1)}")
print(f"p2: {id(p2)}")

p3 = Punto(35, 44)
print("3er punto (p3)")
print(f"X= {p3.x}")
print(f"Y= {p3.y}")

# Uso de la 1ra iteración de copiar
# p3.copiar(p1)

# Uso de la 2da iteración de copiar
#p3.copiarNuevo(p1)

#Uso de la 3ra iteracion de copiar
p3.copiarNuevo2(p1)

print("Punto copiado (p1 --> p3)")
print(f"p1.x= {p1.x}")
print(f"p1.y= {p1.y}")
print(f"p3.x= {p3.x}")
print(f"p3.y= {p3.y}")

# En cambio, cuando copiamos un punto, éstos van a compartir espacios de memoria.
# Esto se da porque las variables x de los dos puntos apuntan al mismo espacio de memoria
# Lo mismo para las variables y de cada punto
# Generamos dependencia entre ellos.

print("Ids: ")
print(f"p1.x: {id(p1.x)}")
print(f"p3.x: {id(p3.x)}")
print(f"p1.y: {id(p1.y)}")
print(f"p3.y: {id(p3.y)}")