ejemplos 2 y 3 _Programación orientada a objetos_estrella Pop Y CÁCULO DE distancia (teorema de la hipotenusa) PLEDÍN 3.0

 class EstrellaPop:

    # Atributo de Clase (algo que todas tienen en esta agencia)

    agencia = "Galaxy Music"

    def __init__(self, nombre, estilo, cancion_favorita):

        # Atributos de Instancia (lo que tú personalizas)

        self.nombre = nombre

        self.estilo = estilo

        self.cancion_favorita = cancion_favorita

        self.energia = 100  # Todas empiezan con la energía al máximo

    def actuar(self):

        return f"¡Hola! Soy {self.nombre}, mi estilo es {self.estilo} y voy a cantar mi éxito: '{self.cancion_favorita}'."

# --- AQUÍ INSTANCIAMOS (CREAMOS A LAS ARTISTAS) ---

# Creamos a la primera cantante

artista1 = EstrellaPop("Luna", "K-Pop Urbano", "Neon Lights")

# Creamos a la segunda cantante

artista2 = EstrellaPop("Mia", "R&B Alternativo", "Midnight Sky")

# --- LAS PONEMOS A ACCIONAR ---

print(artista1.actuar())

print(f"Agencia: {artista1.agencia} | Energía: {artista1.energia}%")

print("---")

print(artista2.actuar())

print(f"Agencia: {artista2.agencia} | Energía: {artista2.energia}%")

Ejemplo 3 Programación orientada a objetos

import math

class Punto:

    """Representación de un punto en el plano, los atributos son x e y

    que representan los valores de las coordenadas cartesianas."""

    def __init__(self, x=0, y=0):

        self.x = x

        self.y = y

    def mostrar(self):

        return str(self.x) + ":" + str(self.y)

    def distancia(self, otro):

        """Devuelve la distancia entre ambos puntos."""

        dx = self.x - otro.x

        dy = self.y - otro.y

        return math.sqrt(dx*dx + dy*dy)

#en celda 2 de gooogle colab:

punto1 = Punto() punto2 = Punto(4, 5) print(punto1.distancia(punto2))

#mejor, más completo usando el método mostrar(), escribe en la celda 2 de gooogle colab:

punto1 = Punto() punto2 = Punto(4, 5) # Aquí sí llamamos a mostrar() para ver las coordenadas print("Las coordenadas de punto1 son:", punto1.mostrar()) print("Las coordenadas de punto2 son:", punto2.mostrar()) # Y aquí calculamos la distancia print("La distancia entre ellos es:", punto1.distancia(punto2))

Explicación

 El molde del punto (class Punto)

• __init__(self, x=0, y=0): Es el constructor. Cuando creas un punto, le dices en qué coordenada horizontal (x) y vertical (y) está.

• El truco: Si creas un punto sin ponerle números (como hicimos antes con Punto()), por defecto se coloca automáticamente en el origen (0, 0)

•  Mostrar el punto (mostrar)

  • def mostrar(self):: Este método es como una etiqueta de presentación. Agarra las coordenadas numéricas y las convierte en un texto bonito para leer fácilmente, por ejemplo, devolviendo algo como "3:4".

. Calcular la distancia (distancia)

def distancia(self, otro):: Este es el superpoder del programa. Le permite a un punto compararse con otro punto distinto.

• Usa el famoso Teorema de Pitágoras por dentro (dx y dy) para medir los kilómetros o píxeles de distancia en línea recta entre ambos y te da el resultado numérico exacto usando la raíz cuadrada (math.sqrt).

• Cuando defines def distancia(self, otro):, estás

 preparando la función

 para recibir exactamente

 dos cosas:

self: Es el objeto que llama a la función (en este caso, punto1). Python lo coloca ahí de forma automática cuando escribes punto1.distancia(...).

• otro: Es el segundo objeto que le pasas tú manualmente dentro de los paréntesis (en este caso, punto2).

• ¿Para qué sirve esto en la vida real?

  Imagina que estás programando un videojuego y quieres

 saber si tu personaje

 está lo

suficientemente

 cerca de un
 

enemigo para atacarlo,

 o estás usando una app 

de mapas

 (como Google Maps)

 para medir la

 distancia 

entre dos

ciudades en un plano.

¡Las clases y objetos se 

usan
 

exactamente para eso!

Repetición de la

 explicación

 aclaradora:

self representa al objeto desde dentro de la clase, mientras que el nombre de la variable (como robot1 o robot2) representa al objeto desde fuera.

Se puede explicar de esta forma:

Dentro de la clase se usa self, fuera de la clase se usa el nombre del objeto (robot1, robot2).

• Desde DENTRO de la clase: Usas self para referirte al propio objeto y acceder a sus datos o acciones.

  • Ejemplo dentro de un método: self.nombre, self.color

• Desde FUERA de la clase: Usas la variable que creaste para llamar a ese objeto concreto.

  • Ejemplo fuera de la clase: robot1.nombre, robot2.color

Python

class Robot:

    def __init__(self, color, bateria):
        self.color = color  # Guarda el color DENTRO del objeto
        self.bateria = bateria

    def saludar(self):
        # Aquí DENTRO usamos self porque el robot habla de sí mismo
        return f"¡Hola! Soy un robot de color {self.color}."


# --- FUERA DE LA CLASE ---

# Creamos el objeto
robot2 = Robot("Azul", 85)

# Aquí FUERA usamos robot2 para llamar a sus métodos y propiedades
print(robot2.saludar())
print(f"Mi color es {robot2.color} y mi batería está al {robot2.bateria}%.")

Una analogía sencilla que suele funcionar muy bien es la de los pronombres:

• self es como decir "yo" o "mi" cuando el robot habla desde dentro de su código ("mi color es...").

• robot2 es como llamar al robot por su nombre propio cuando interactúas con él desde fuera.

Se abre en una ventana nueva