Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python

Cursos Empresas Blog Live Conf Precios

Contenido del curso

Fundamentos de Programación y Python

Colección y Procesamiento de Datos en Python

Control de Flujo en Python

Funciones y Manejo de Excepciones en Python

Programación Orientada a Objetos en Python

Lectura y escritura de archivos

Biblioteca estándar de Python

Conceptos avanzados de Python

Decoradores

Métodos y estructura de clases en Python

Programación concurrente y asíncrona

Creación de módulos y paquetes

Proyecto final

Tomar examen

Para entender mejor la Programación Orientada a Objetos (POO), es esencial recordar los conceptos básicos de atributos y métodos.

Atributos: Son variables que pertenecen a una clase o a sus objetos. Definen las propiedades de un objeto. Por ejemplo, pensemos en una persona: ¿Qué caracteriza a una persona en general? Las personas tienen nombre, edad, dirección, etc. En términos de POO, estos serían los atributos de la clase Person.
Métodos: Son funciones definidas dentro de una clase que operan sobre sus objetos. Definen los comportamientos de un objeto. Siguiendo con el ejemplo de una persona, ¿Qué acciones puede realizar una persona? Puede hablar, caminar, comer, etc. En POO, estas acciones serían métodos de la clase Person.

Ejemplo Básico de una Clase

class Person:
    def __init__(self, name, age):
        self.name = name  # Atributo
        self.age = age    # Atributo

    def greet(self):
        print(f"Hola, mi nombre es {self.name} y tengo {self.age} años.")  # Método

# Crear una instancia de la clase Person
persona1 = Person("Ana", 30)
persona1.greet()  # Output: Hola, mi nombre es Ana y tengo 30 años.

al usar herencia vimos el método init() que es le cosntructor, el mismo es llamado automáticamente cuando se crea una nueva instancia de una clase y se utiliza para inicializar los atributos del objeto.

Ejemplo de Constructor

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Crear una instancia de Person
person1 = Person("Ana", 30)
print(person1.name)  # Output: Ana
print(person1.age)   # Output: 30

En este ejemplo, el constructor __init__ inicializa los atributos name y age de la clase Person.

Uso de super() en Python

La función super() en Python te permite acceder y llamar a métodos definidos en la superclase desde una subclase. Esto es útil cuando quieres extender o modificar la funcionalidad de los métodos de la superclase sin tener que repetir su implementación completa.

Ejemplo de Uso de super()

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print("Hello! I am a person.")

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)
        self.student_id = student_id

    def greet(self):
        super().greet()
        print(f"Hi, I'm {self.name}, and I'm a student with ID: {self.student_id}")

# Crear instancia de Student y llamar a greet
student = Student("Ana", 20, "S12345")
student.greet()  # Output: Hello! I am a person.
                 #         Hi, I'm Ana, and I'm a student with ID: S12345

En este ejemplo:

La clase Person define un método greet() que imprime un saludo genérico.
La clase Student, que es una subclase de Person, utiliza super().__init__(name, age) para llamar al constructor de la superclase Person y luego sobrescribe el método greet() para agregar información específica del estudiante.

Jerarquía de Clases y Constructores

¿Qué sucede si una clase tiene una clase padre y esa clase padre tiene otra clase padre? En este caso, usamos super() para asegurar que todas las clases padre sean inicializadas correctamente.

Ejemplo de Jerarquía de Clases

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'm {self.name}, {self.age} years old, and my student ID is {self.student_id}")

# Crear instancia de Student
student = Student("Carlos", 21, "S54321")
student.introduce()  # Output: Hi, I'm Carlos, 21 years old, and my student ID is S54321

En este ejemplo:

LivingBeing es la clase base que inicializa el atributo name.
Person es una subclase de LivingBeing que inicializa name a través de super().__init__(name) y luego inicializa age.
Student es una subclase de Person que inicializa name y age a través de super().__init__(name, age) y luego inicializa student_id.

Métodos que Vienen por Defecto en Python

En Python, todas las clases heredan de la clase base object. Esto significa que todas las clases tienen ciertos métodos por defecto, algunos de los cuales pueden ser útiles para personalizar el comportamiento de tus clases.

Métodos por Defecto Más Comunes

__init__(self): Constructor de la clase. Es llamado cuando se crea una nueva instancia de la clase. Inicializa los atributos del objeto.
__str__(self): Devuelve una representación en cadena del objeto, utilizada por print() y str(). Este método es útil para proporcionar una representación legible del objeto.
__repr__(self): Devuelve una representación "oficial" del objeto, utilizada por repr(). Este método está diseñado para devolver una cadena que represente al objeto de manera que se pueda recrear.

Ejemplo de Métodos __str__ y __repr__

Vamos a crear una clase Person que sobrescriba los métodos __str__ y __repr__.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name}, {self.age} años"

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

# Crear instancias de Person
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

# Uso de __str__
print(person1)  # Output: Alice, 30 años

# Uso de __repr__
print(repr(person1))  # Output: Person(name=Alice, age=30)

Explicación del Código

El método __str__ devuelve una representación en cadena del objeto, útil para mensajes de salida amigables.
El método __repr__ devuelve una representación más detallada del objeto, útil para la depuración.

Estos métodos proporcionan una manera conveniente de representar y comparar objetos, lo que facilita la depuración y el uso de los objetos en el código.

Importancia de Aprender estos Conceptos

Comprender y utilizar super(), los métodos por defecto y los constructores es crucial para escribir código limpio, eficiente y reutilizable en Python. Estos conceptos permiten:

Extender Funcionalidades: super() permite extender las funcionalidades de una superclase sin duplicar código.
Inicialización Correcta: El uso adecuado de constructores asegura que todos los atributos sean inicializados correctamente.
Personalizar Representaciones: Métodos como __str__ y __repr__ permiten personalizar cómo se representan los objetos, facilitando la depuración y el manejo de datos.
Comparar y Ordenar Objetos: Métodos como __eq__, __lt__, etc., permiten definir cómo se comparan y ordenan los objetos, lo cual es esencial para muchas operaciones de datos.

Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python

Danny Alejandro fernandez gallego

Estudiante

Señores buen dia! Espero esta implementación de un ejemplo de POO con animales les pueda orientar, investigando un poco e interactuando con el codigo pude, hacer una clase bastante buena y aplicando los 4 pilares de la POO, espero les pueda orientar:

from abc import ABC, abstractmethod
import os

os.system('cls')

# Clase abstracta
class Animal(ABC):
    # Implementación de Type hints
    def __init__(self, raza:str, onomatopeya:str):
        self._raza = raza
        self._onomatopeya = onomatopeya # Descripción del sonido con el que se comunica el animal

    @property
    def razaAnimal(self)->str:
        return self._raza
    
    @razaAnimal.setter
    def razaAnimal(self, nuevaRaza):
        if isinstance(nuevaRaza, str):
            self._raza = nuevaRaza
        else:
            raise ValueError("La raza debe ser un string")

    @property
    def onomatopeyaAnimal(self)->str:
        return self._onomatopeya
    
    def valorCuidoxKilo(self, valor: int, kilo: int):
        raise NotImplementedError("Esta clase solo debe ser implementada por una subclase")
    
    @abstractmethod
    def habilidad(self):
        pass
    
    @onomatopeyaAnimal.setter
    def onomatopeyaAnimal(self, nuevaOnomatopeya):
        if isinstance(nuevaOnomatopeya, str):
           self._onomatopeya = nuevaOnomatopeya
        else:
           raise ValueError("La onomatopeya debe ser un string")

    def __str__(self)->str:
        return f"El {self.razaAnimal} y dice {self.onomatopeyaAnimal}"
    

class Comportamiento(Animal):
     def __init__(self, raza: str, onomatopeya: str, defensa: str):
         super().__init__(raza, onomatopeya)
         self._defensa = defensa

     @property
     def defensa(self)->str:
         return self._defensa
     
     @defensa.setter
     def defensa(self, nuevoDefensa):
         if isinstance(nuevoDefensa, str):
           self._defensa = nuevoDefensa
         else:
           raise ValueError("La defensa debe ser un string")

     def metodoDefensa(self):
         return f"\nEl {self.razaAnimal} y su metodo de defensa, primero te dice {self.onomatopeyaAnimal} y despues {self.defensa}"
     
     # Uso de Abstracción
     def habilidad(self):
       return f"\nEl {self.razaAnimal} puede olfatear para detectar por Ejemplo: Narcoticos, Explosivos"
     
     # Uso de polimorfismo
     def valorCuidoxKilo(self, valor:int, kilo:int):
       return f"\nEl perro come {kilo}Kg de purina, y su valor es: ${valor * kilo} pesos colombianos"


# Subclase Perro que hereda de animal
class Perro(Animal):
   
   # Uso de Abstracción
   def habilidad(self):
       return "\nEl perro puede olfatear para detectar por Ejemplo: Narcoticos, Explosivos"
   
   # Uso de polimorfismo
   def valorCuidoxKilo(self, valor:int, kilo:int):
       return f"\nEl perro come {kilo}Kg de purina, y su valor es: ${valor * kilo} pesos colombianos"

# Subclase Gato que hereda de animal
class Gato(Animal):
    def habilidad(self):
        return "\nEl gato puede escalar arboles"
    
    # Uso de polimorfismo
    def valorCuidoxKilo(self, valor:int, kilo:int):
       return f"\nEl gato come {kilo}Kg de catChow, y su valor es: ${valor * kilo} pesos colombianos"


# INSTANCIAS DE CLASES

comportamiento = Comportamiento("perro","guau","te muerde")
print(comportamiento)
print(comportamiento.habilidad())
print(comportamiento.valorCuidoxKilo(7000,2))

print("\n===========================================")

perro = Perro("perro","guaua")
print(perro.habilidad())
print(perro.valorCuidoxKilo(8000, 3))

print("\n===========================================")

gato = Gato("gato","miau")
print(gato.habilidad())
print(gato.valorCuidoxKilo(5000, 5))
     
```from abc import ABC, abstractmethodimport os
os.system('cls')
\# Clase abstractaclass Animal(ABC):    # Implementación de Type hints    def \_\_init\_\_(self, raza:str, onomatopeya:str):        self.\_raza = raza        self.\_onomatopeya = onomatopeya # Descripción del sonido con el que se comunica el animal
    @property    def razaAnimal(self)->str:        return self.\_raza        @razaAnimal.setter    def razaAnimal(self, nuevaRaza):        if isinstance(nuevaRaza, str):            self.\_raza = nuevaRaza        else:            raise ValueError("La raza debe ser un string")
    @property    def onomatopeyaAnimal(self)->str:        return self.\_onomatopeya        def valorCuidoxKilo(self, valor: int, kilo: int):        raise NotImplementedError("Esta clase solo debe ser implementada por una subclase")        @abstractmethod    def habilidad(self):        pass        @onomatopeyaAnimal.setter    def onomatopeyaAnimal(self, nuevaOnomatopeya):        if isinstance(nuevaOnomatopeya, str):           self.\_onomatopeya = nuevaOnomatopeya        else:           raise ValueError("La onomatopeya debe ser un string")
    def \_\_str\_\_(self)->str:        return f"El {self.razaAnimal} y dice {self.onomatopeyaAnimal}"   &#x20;
class Comportamiento(Animal):     def \_\_init\_\_(self, raza: str, onomatopeya: str, defensa: str):         super().\_\_init\_\_(raza, onomatopeya)         self.\_defensa = defensa
     @property     def defensa(self)->str:         return self.\_defensa          @defensa.setter     def defensa(self, nuevoDefensa):         if isinstance(nuevoDefensa, str):           self.\_defensa = nuevoDefensa         else:           raise ValueError("La defensa debe ser un string")
     def metodoDefensa(self):         return f"\nEl {self.razaAnimal} y su metodo de defensa, primero te dice {self.onomatopeyaAnimal} y despues {self.defensa}"          # Uso de Abstracción     def habilidad(self):       return f"\nEl {self.razaAnimal} puede olfatear para detectar por Ejemplo: Narcoticos, Explosivos"          # Uso de polimorfismo     def valorCuidoxKilo(self, valor:int, kilo:int):       return f"\nEl perro come {kilo}Kg de purina, y su valor es: ${valor \* kilo} pesos colombianos"

\# Subclase Perro que hereda de animalclass Perro(Animal):      # Uso de Abstracción   def habilidad(self):       return "\nEl perro puede olfatear para detectar por Ejemplo: Narcoticos, Explosivos"      # Uso de polimorfismo   def valorCuidoxKilo(self, valor:int, kilo:int):       return f"\nEl perro come {kilo}Kg de purina, y su valor es: ${valor \* kilo} pesos colombianos"
\# Subclase Gato que hereda de animalclass Gato(Animal):    def habilidad(self):        return "\nEl gato puede escalar arboles"        # Uso de polimorfismo    def valorCuidoxKilo(self, valor:int, kilo:int):       return f"\nEl gato come {kilo}Kg de catChow, y su valor es: ${valor \* kilo} pesos colombianos"

\# INSTANCIAS DE CLASES
comportamiento = Comportamiento("perro","guau","te muerde")print(comportamiento)print(comportamiento.habilidad())print(comportamiento.valorCuidoxKilo(7000,2))
print("\n===========================================")
perro = Perro("perro","guaua")print(perro.habilidad())print(perro.valorCuidoxKilo(8000, 3))
print("\n===========================================")
gato = Gato("gato","miau")print(gato.habilidad())print(gato.valorCuidoxKilo(5000, 5))

Lizette Rosalía Dazza Hernández

Julián Cárdenas

Brando Joel Sandoval

Jhon Freddy Tavera Blandon

Rey Baldemar Cruz Corral

Gustavo Rodriguez

Esteban Diaz Diez

Héctor Omar Hernández Godoy

Erik Taveras

Laura Alejandra Moreno Borda

Jorge Alberto Dazza Hernández

Alexis Dorado Muñoz

German Andres Perez

Emanuel Cardenas Carvajal

Jackssuriss Tatiana Herrera Florez

Platzi

Stanley Smtih Melo Fontalvo

Carli Code

Profesor

Alcira Reyes

Erick Estrada Mancilla

Saul Antonio Cerén Gálvez

Sergio Eduardo Cárdenas Rovira

Jorge Miguel Diaz

Mario Peña

Cristian Ramiro Narváez Guillén

Carlos Giles

Michael David Torres Leon

Luis Fernando Garzón Betancourt

Fundamentos de Programación y Python

Por qué Python se usa en misiones de la NASA

Este curso tiene una nueva versión, link para continuar aprendiendo

Instalación y Uso Básico de Python en Windows y Mac

Semántica y Sintaxis en Programación Python

Práctica: Te doy la bienvenida a los ejercicios interactivos

Manejo de Cadenas y Operaciones Básicas en Python

int, float y bool en Python

Dominio de la función `print` en Python: usos y formatos avanzados

Operaciones matemáticas avanzadas en Python: módulo, potencia y más

Entrada de información y manejo de tipos de datos en Python

Colección y Procesamiento de Datos en Python

Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos

Copiar listas en Python con slicing

Manejo de Matrices y Tuplas en Python

Matrices en Juegos y Imágenes con Python

Diccionarios de Python con datos reales

Control de Flujo en Python

Estructuras Condicionales en Programación: Uso de If, Else y Elif

Bucles for y while en Python

Iteradores y Generadores en Python: Uso Eficiente de Memoria

Listas de Python en una sola línea

Funciones y Manejo de Excepciones en Python

Funciones en Python con calculadora real

Funciones Lambda en Python: Uso y Aplicaciones Prácticas

Recursividad en Python: Factoriales y Serie de Fibonacci

Manejo de Excepciones y Errores en Python

Programación Orientada a Objetos en Python

Programación Orientada a Objetos en Python: Clases y Métodos Básicos

Gestión de Biblioteca con Programación Orientada a Objetos

Herencia en Python con clases de vehículos

Programación Orientada a Objetos: Implementación de Clases y Herencia

Polimorfismo en Programación Orientada a Objetos

Herencia y Uso de la Función super() en Python