Ir al contenido principal

3_Ejercicio 1: robot1 y robot 2 ____programacion orientada a objetos

Sirve intérprete online de python 3, la consola de Python instalada(q se llama REPL) o Google Colab

¡¡¡OJO!!!Cuidado con la indentación

EXPLICACIÓN MUY buena(_mar_di_c)

En programación orientada a objetos (y específicamente en Python):

  • Función: Es un bloque de código reutilizable definido con def de forma independiente (fuera de una clase).

  • Método: Es exactamente lo mismo (una función), pero al estar definida dentro de una clase, pasa a llamarse método porque

pertenece a esa clase y define el comportamiento de

los objetos que se creen a partir de ella.

Detalle clave:

El parámetro self que ves en por en este ejemplo:

class CuentaBancaria:

    def __init__(self, titular, saldo_inicial):

        self.titular = titular

        self.__saldo = saldo_inicial  # Atributo privado con __


    def depositar(self, monto):

        if monto > 0:

            self.__saldo += monto

        else:

            raise ValueError("El monto debe ser positivo")

def depositar(self, monto): es lo que convierte a esa función en un método de instancia. Gracias a self, el método sabe exactamente a cuál cuenta bancaria concreta debe sumarle el dinero (por ejemplo, si tienes la cuenta de Ana y la de Carlos, self distingue de quién es el saldo que se está modificando).

Muy importante la siguiente explicación:


Conversación co

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.

Puedes explicarlo 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.


class Robot:

    # Atributo de Clase (Común a todos)

    especie = "Autómata Inteligente"

  • class Robot: Es el plano de la fábrica. Le estamos diciendo a Python: "Voy a crear un nuevo tipo de objeto llamado Robot".

  • especie = "Autómata Inteligente": Es una regla general. Todos los robots que salgan de este molde van a pertenecer a esta especie. No importa cómo los bautices, todos llevan esta característica de fábrica compartida.

  • def __init__(self, nombre, modelo, color):

            # Atributos de Instancia (Únicos)

            self.nombre = nombre

            self.modelo = modelo

            self.color = color

            self.bateria = 100


    ¡¡Ojo!!!HAY UN ESPACIO DESPUÉS DEL DEF, ANTES DEL __INIT__

    Cuando le das a "Crear nuevo personaje", aparece una ventana para rellenar datos. Eso es el __init__ (el constructor).

    • self: Significa "este mismo" o "el propio". Cuando creas al robot, self es la etiqueta que le ponemos a ese robot en particular para no confundirlo con los demás.

    • Los datos únicos (nombre, modelo, color): Son las opciones que tú eliges al crearlo. A uno lo puedes llamar "Robín", modelo "X-5", de color "rosa pastel", y a otro "Bip", modelo "Z-9", de color "azul".

    • self.bateria = 100: Es un valor por defecto. No te pedimos que lo escribas al crearlo; por regla general, todos empiezan con la batería al 100%.


    def saludar(self):
            return f"¡Hola! Soy {self.nombre}"
    • Un objeto no solo tiene datos (como su color o nombre), sino también acciones que puede realizar.

    • saludar es una función dentro del robot (a las funciones que viven dentro de una clase las llamamos métodos) Cuando le dices a tu robot que salude, él mira su propio nombre (self.nombre) y te dice: "¡Hola! Soy Robín".

    En resumen:

    • La clase (Robot) es el creador de personajes.

    • Los atributos (nombre, color, batería) son las características de tu personaje.

    • Los métodos (saludar) son lo que tu personaje sabe hacer.


    Ejemplo completo:

    Hasta ahora solo hemos escrito el molde (la fábrica de robots), pero todavía no le hemos dicho a la fábrica que fabrique ninguno ni que los ponga a hablar. Es como tener la receta de un pastel pero sin meter los ingredientes en el horno todavía.

    Para que haga algo, necesitamos dar el siguiente paso: crear los objetos (las instancias) y llamar a sus acciones.


    class Robot:
        # Atributo de Clase (Común a todos)
        especie = "Autómata Inteligente"

        def __init__(self, nombre, modelo, color):
            # Atributos de Instancia (Únicos)
            self.nombre = nombre
            self.modelo = modelo
            self.color = color
            self.bateria = 100

        def saludar(self):
            return f"¡Hola! Soy {self.nombre}"


    # --- AQUÍ EMPEZAMOS A DARLE VIDA AL PROGRAMA ---

    # 1. Creamos nuestro primer robot (Instanciamos la clase)
    robot1 = Robot("Robín", "X-5", "rosa pastel")

    # 2. Creamos un segundo robot con otros datos
    robot2 = Robot("Bip", "Z-9", "azul eléctrico")

    # 3. Hacemos que hagan cosas y mostramos los resultados en pantalla con print()
    print(robot1.saludar())
    print(f"Mi color es {robot1.color} y mi especie es: {robot1.especie}")

    print("---")

    print(robot2.saludar())
    print(f"Mi color es {robot2.color} y mi batería está al {robot2.bateria}%.")

    ¿Qué acabamos de hacer?

    1. robot1 = Robot(...): Aquí es donde "compramos" un robot del molde y le pasamos sus datos reales (nombre, modelo, color).

    2. print(...): Le decimos a Python que imprima en la pantalla lo que devuelven las funciones o los datos de nuestros robots.

    3. return f"¡Hola! Soy {self.nombre}"

    la f le avisa a Python: "Oye, dentro de este texto vas a encontrar llaves {} con variables adentro, por favor reemplázalas por su valor real".

    Sin la f (Forma + antigua ): Tendrías que sumar textos y variables con un signo + así:

    return "¡Hola! Soy " + self.nombre
  • La F de "Formato": La f le avisa a Python que vas a formatear el texto usando llaves {} para meter variables. Piensa en: "¡Voy a darle formato a este texto!".

  • La F de "Fácil": Porque usar la f hace que sea muchísimo más fácil y limpio escribir frases con variables que andar sumando con signos +.

  • Imagina que la F significa "Fusión": Es el momento en el que el texto y la variable se fusionan gracias a las llaves {}.


    1. Los atributos de clase (como especie) o los atributos de instancia (como color o batería)
    no son obligatorios en el sentido de que Python te obligue a ponerlos.
    Tú decides qué características quieres que tenga tu molde.

    def __init__(self, nombre, modelo, color):
    1. Se llama __init__ porque viene de la palabra "inicializar"
    (o initialize en inglés).
    Cada vez que creas objetos que necesitan tener sus propias características individuales,
    sí, siempre hay que usar el __init__ para inicializarlos.

    EXPLICACIÓN MUY importante:


    Conversación con Gemini

    La regla clave: Propiedades vs. Métodos

    1. Las variables (propiedades o atributos) Guardan datos:

      • No hacen ninguna acción, solo almacenan información.

      • Se llaman SIN paréntesis: robot1.color o robot1.bateria.

    2. Las funciones (métodos) Ejecutan acciones:

      • Hacen que el objeto "haga algo" (calcular, imprimir, saludar, etc.).

      • Se llaman CON paréntesis (): robot1.saludar().

      • Los paréntesis le dicen a Python: "¡Ejecuta esta acción ahora!".

    ¿Qué pasa si se te olvidan los paréntesis?

    Es supercomún que a los alumnos de 17 años se les olvide poner los () al principio. Les mostramos qué ocurre si escriben:

    Python
    print(robot1.saludar)
    

    En lugar de ejecutar la función, Python responderá algo raro como: <bound method Robot.saludar of <__main__.Robot object at 0x...>>

    Eso significa: "Sé que saludar es una función, pero no me has puesto los paréntesis (), así que no la he ejecutado".

    Resumen rápido:

    • Sin paréntesis robot1.color Dame el dato que tienes guardado.

    • Con paréntesis robot1.saludar() Ejecuta la acción.


    ¡Prueba a copiar el ejerciCIo completo y a ejecutarlo en Colab para ver cómo cobra vida!




    Entradas populares de este blog

    BLOQUE 5_Páginas de IA generativa de video (gratis y sin pagar) para 4º ESO IA artificial_Inteligencia artificial

    GrÁfico de lineas, google colab o jupyter ,GRÁFICO DE DISPERSIÓN Y DETECCIÓN DE PROFUNDIDAD, NOTEBOOK, PÍDELE A TU IA FAVORITA,