Uso de super() en Python (CLASE NUEVA)

🟢 **Diferencia entre el atributo y el argumento del constructor** Te habrás fijado que `name` y self.name parecen ser lo mismo, pues no, son diferentes aunque contengan el mismo valor. La sentencia `self.name` hace referencia al atributo del objeto, mientras que `name` hace referencia al valor del argumento de `__init__` cuando se crea una instancia. Por ejemplo, voy a repetir el código pero con variables diferentes: ```python class Person: def __init__(self, nombre, edad): self.name = nombre self.age = edad instancia = Person("Andres", 25) instancia.name # "Andres" instancia.age # 25 ``` Espero que te haya servido. ¡Nunca pares de aprender! 🚀

El uso de `super()` en Python está relacionado con la herencia de clases. Permite llamar métodos o acceder a atributos de la \*\*clase padre\*\* desde una \*\*clase hija\*\*, sin necesidad de referenciar explícitamente el nombre de la clase padre. Es especialmente útil cuando se trabaja con herencia múltiple o se desea extender la funcionalidad de la clase base sin sobrescribir completamente su comportamiento. \### Sintaxis básica de `super()` ```python super().metodo\_de\_la\_clase\_padre() ``` Aquí, `super()` devuelve un objeto que representa a la clase base, permitiendo llamar a sus métodos o acceder a sus atributos. \### Ejemplo básico con herencia y `super()` ```python class Animal: def \_\_init\_\_(self, nombre): self.nombre = nombre def hacer\_sonido(self): print("El animal hace un sonido") class Perro(Animal): def \_\_init\_\_(self, nombre, raza): \# Llamamos al constructor de la clase padre con super() super().\_\_init\_\_(nombre) self.raza = raza def hacer\_sonido(self): \# Extendemos la funcionalidad del método de la clase padre super().hacer\_sonido() print("El perro ladra") \# Uso de las clases mi\_perro = Perro("Firulais", "Golden Retriever") print(mi\_perro.nombre) # Firulais mi\_perro.hacer\_sonido() ``` \#### Salida: ``` El animal hace un sonido El perro ladra ``` \### Explicación: 1\. \*\*`super().\_\_init\_\_(nombre)`\*\*: Llama al constructor de la clase base `Animal`, lo que permite que la clase hija `Perro` también inicialice la variable `nombre` que está definida en la clase `Animal`. 2\. \*\*`super().hacer\_sonido()`\*\*: Llama al método `hacer\_sonido` de la clase base `Animal` antes de agregar el comportamiento específico de `Perro`. \### Beneficios de usar `super()`: 1\. \*\*Herencia Múltiple\*\*: En casos donde una clase hereda de múltiples clases, `super()` sigue el \*\*orden de resolución de métodos (MRO)\*\*, lo que garantiza que se llame al método correcto en la cadena de herencia. 2\. \*\*Reutilización\*\*: Permite reutilizar el código de la clase base, extendiendo su funcionalidad sin necesidad de duplicar código. 3\. \*\*Mantenibilidad\*\*: Si el nombre de la clase base cambia, no es necesario modificar los métodos que usan `super()`, ya que no se hace referencia directa a la clase padre. \### Ejemplo con Herencia Múltiple ```python class Mamifero: def \_\_init\_\_(self, nombre): self.nombre = nombre def hacer\_sonido(self): print("Sonido de mamífero") class Volador: def \_\_init\_\_(self, velocidad): self.velocidad = velocidad def volar(self): print(f"El animal vuela a {self.velocidad} km/h") class Murcielago(Mamifero, Volador): def \_\_init\_\_(self, nombre, velocidad): super().\_\_init\_\_(nombre) # Llama al constructor de Mamifero Volador.\_\_init\_\_(self, velocidad) # Llama al constructor de Volador \# Uso de las clases bat = Murcielago("Batty", 50) bat.hacer\_sonido() # Sonido de mamífero bat.volar() # El animal vuela a 50 km/h ``` En este ejemplo, `Murcielago` hereda de ambas clases, `Mamifero` y `Volador`. `super()` es útil para llamar al constructor de `Mamifero`, pero también es necesario llamar explícitamente al constructor de `Volador` para inicializar `velocidad`. \### Resumen: \- `super()` es una herramienta poderosa para interactuar con clases base. \- Facilita la herencia en programas orientados a objetos, permitiendo la reutilización y extensión del comportamiento de las clases padres. \- Es crucial en escenarios de herencia múltiple para seguir el orden correcto de llamadas a métodos.

```python #ahora LivingBegin sera nuestra super clase class LivingBeing: def __init__(self, name): self.name = name class Person(LivingBeing): def __init__(self, name, age): super().__init__(name) self.age = age class Student(Person): def __init__(self, name, age, student_id): super().__init__(name, age) self.student_id = student_id def introduce(self): print(f"Hi, I am {self.name}, I have {self.age} years old, and my student ID is {self.student_id}") student = Student("Ana", 20, "S123") student.introduce() # Hi, I am Ana, I have 20 years old, and my student ID is S123 ```

En Python, `super()` es una función que te permite acceder a métodos o atributos de una clase padre desde una clase hija. Es especialmente útil en el contexto de la herencia para garantizar que las clases derivadas llamen a los métodos de sus clases base correctamente, evitando sobreescrituras accidentales. ```python class Animal: def __init__(self, name): self.name = name def speak(self): return f"{self.name} hace un sonido." class Perro(Animal): def __init__(self, name, breed): # Llama al constructor de la clase padre (Animal) super().__init__(name) self.breed = breed def speak(self): # Llama al método speak de la clase padre y lo extiende return super().speak() + " ¡Guau!" # Crear un objeto de la clase Perro mi_perro = Perro("Max", "Labrador") print(mi_perro.speak()) # Output: Max hace un sonido. ¡Guau! ```

Estoy trabajando a la par con ChatGPT para entender el curos de Python, asi que le pedi que me ayude con este código que explica Clases, Subclases, etc. Espero que les sea de ayuda. ```js # **Clase Base** class Platillo: # Definición de la clase # **Constructor** def __init__(self, nombre, precio): # Método especial para inicializar atributos self.nombre = nombre # Atributo de instancia self.precio = precio # Atributo de instancia # **Método Público** def mostrar_detalles(self): # Método que se puede acceder desde fuera de la clase return f"{self.nombre}: ${self.precio}" # **Método Abstracto** def preparar(self): # Método que debe ser implementado por las subclases raise NotImplementedError("Este método debe implementarse en cada platillo.") # **Subclase** class Pizza(Platillo): # Pizza hereda de Platillo (Relación de Herencia) # **Sobrescritura de Método** def preparar(self): # Sobrescribe el método preparar de la clase base return f"Preparando la pizza {self.nombre} (amasar, hornear, agregar ingredientes)." # **Subclase** class Sopa(Platillo): # Sopa hereda de Platillo # **Sobrescritura de Método** def preparar(self): # Sobrescribe el método preparar de la clase base return f"Preparando la sopa {self.nombre} (hervir agua, agregar ingredientes)." # **Instanciación de Objetos** pizza = Pizza("Margarita", 8) # Crear un objeto de la clase Pizza sopa = Sopa("Minestrone", 6) # Crear un objeto de la clase Sopa # **Uso de Métodos** print(pizza.mostrar_detalles()) # Llama al método público de la clase base print(sopa.preparar()) # Llama al método sobrescrito en la subclase ```

me gustaria profundizar en un error que cometi. se como arreglarlo pero quisiera saber la naturaleza del mensaje de error que me salio: mi error fue escribir la linea: super.**init**(name) entiendo que asi estaria accediendo al constructor del metodo super o que pasa ahi ? porque el error que me salio fue :TypeError: descriptor '\_\_init\_\_' requires a 'super' object but received a 'str'

la curiosidad de ver que habia metodos que iniciaban con \_\_ y que los atributosa tambien investigue y me encontre con algo llamado name manling. esta convencion de iniciar el combre de metodos y atributos con \_\_ indica internamente que el metodo o atributo es privado y no debe ser accedido fuera de la clasae, entonces empieza el namemanlign que cambia el nombre del atributo o metodo internamente a algo con la siguiente forma *clase*\_metodo *clase*\_atributo la idea de hacer esto es : 1. Claridad: Facilita la comprensión de qué métodos y atributos son internos a la clase y no deben ser utilizados externamente. 2\. Seguridad: Desalienta el acceso directo a los atributos y métodos internos, aunque no lo impide completamente. 3\. Organización: Ayuda a mantener el código más organizado y modular.

Wow esta clase la entendí super claro jajajaj alucinante :D

Espero que el uso que le di a la clase este bien, perdón mi ingles es cavernícola. ```js # super() es utilizado para heredar las caracteristicas de un metodo de la clase padre class Car: def __init__(self, color, brand): self.color = color self.brand = brand def accelerate(self): print(f"Hi, my car is {self.color} and her sound is rrun run") class Lambo(Car): def __init__(self, color, brand, price): super().__init__(color, brand) self.price = price def accelerate(self): super().accelerate() print(f"and her brand is {self.brand}, the price of this car is {self.price}") lambo = Lambo("blue", "Lamborghini", 1500000) lambo.accelerate() ```# super() es utilizado para heredar las caracteristicas de un metodo de la clase padre class Car:    def \_\_init\_\_(self, color, brand):        self.color = color        self.brand = brand     def accelerate(self):        print(f"Hi, my car is {self.color} and her sound is rrun run") class Lambo(Car):    def \_\_init\_\_(self, color, brand, price):        super().\_\_init\_\_(color, brand)        self.price = price     def accelerate(self):        super().accelerate()        print(f"and her brand is {self.brand}, the price of this car is {self.price}")    lambo = Lambo("blue", "Lamborghini", 1500000)lambo.accelerate()

Una aplicación real de `__repr__` en Python es en la creación de clases para representar objetos de forma legible. Por ejemplo, en el desarrollo de aplicaciones de gestión de productos, puedes definir una clase `Producto` que utilice `__repr__` para proporcionar una representación clara de cada producto: ```python class Producto: def __init__(self, nombre, precio): self.nombre = nombre self.precio = precio def __repr__(self): return f"Producto(nombre='{self.nombre}', precio={self.precio})" producto = Producto("Laptop", 1200) print(repr(producto)) # Salida: Producto(nombre='Laptop', precio=1200) ``` Esto ayuda a los desarrolladores a entender rápidamente las instancias de la clase al imprimirlas o depurarlas.

Tienes razón en la diferencia entre `__str__` y `__repr__` en Python. - `__str__`: Su propósito es devolver una representación amigable de la instancia de la clase, generalmente para que sea comprensible para los usuarios. Suele enfocarse en proporcionar información útil en un formato legible. - `__repr__`: Su objetivo es devolver una representación más formal y precisa de la instancia, útil para la depuración. Incluye información detallada sobre la clase y sus atributos, permitiendo que se pueda reconstruir el objeto usando la cadena resultante. Ambos métodos son importantes para el manejo de la presentación de objetos en Python y te ayudarán a mejorar la claridad y el mantenimiento de tu código.

Le hice una pequeña adicion: class LivingBeing: def \_\_init\_\_(self, name, time\_live): self.name = name self.time\_life = time\_live class Person(LivingBeing): def \_\_init\_\_(self, name, age): super().\_\_init\_\_(name, age) # Here, age is used as time\_live self.age = age def ages\_life(self): print(f"El tiempo de vida de {self.name} es {self.time\_life} años.") class Student(Person): def \_\_init\_\_(self, name, age, student\_id): super().\_\_init\_\_(name, age) self.student\_id = student\_id def introduce(self): print(f"Hi, I'm {self.name}, {self.age} years old, and my student ID is {self.student\_id}") \# creamos instancia student student1 = Student("Carlos", 23, "b3409") student1.introduce() \# Objeto 2 como Persona student2 = Person("Diana", 19) student2.ages\_life() \# creamos un instancia de person ricardo = Person("Roberto", 70) ricardo.ages\_life()

El uso de super permite añadir funciones a los métodos de la clase padre sin sobreescribirlos totalmente, se puede declarar el mismo método y acceder a las funcionalidades de la clase padre agregando nuevas, si yo simplemente vuelvo a declarar el método sin llamar a super() el comportamiento de este en la clase hija sobreescribiría el comportamiento original, sin usar super() al crear el constructor en la clase hija sobreescribiríamos los atributos de la clase padre y por tanto en cambio de accederlos tendríamos que volver a declararlos y asignarles valor

El uso de super() en Python es una herramienta muy útil cuando trabajas con herencia en Programación Orientada a Objetos. Permite acceder a métodos o atributos de una clase padre desde una clase hija. en resumen el uso de super: * Llama a los métodos o inicializadores de la clase padre dentro de una clase hija. * Facilita la reutilización de código al no tener que duplicar lógica de la clase padre. * Hace más fácil mantener el código, ya que cualquier cambio en la clase padre se aplicará automáticamente a todas las clases hijas que lo usan.

Muy buenas clases con la profe Carla!