24- Clases y objectos en Python

Acordeón de los Índices

Índice de los temas

• Pitón Clases y objetos
• Crear una clase
• Crear objeto
• La función "init"()
• La función "Estr"()
• Métodos de objetos
• El propio parámetro
• Modificar las propiedades de los objetos
• Borrar Propiedades de objetos
• Borrar los objetos
• Declaración de aprobación

---

Pitón Clases y objetos

🐍 Clases y Objetos en Python: Los Bloques de Construcción de la Programación Orientada a Objetos

Python es un lenguaje de programación orientado a objetos (POO). Esto significa que nos permite estructurar nuestro código utilizando conceptos de "clases" y "objetos". La POO proporciona una forma poderosa y organizada de modelar el mundo real dentro de nuestros programas, facilitando la creación de código reutilizable y mantenible.

¿Qué es una Clase?

Una clase es como un plano o una plantilla para crear objetos. Define las características (atributos) que tendrá un objeto y los comportamientos (métodos) que podrá realizar. Piensa en una clase como el diseño de un coche: especifica cuántas ruedas tendrá, qué color puede ser, qué motor usará, y qué acciones puede realizar (arrancar, frenar, acelerar).

¿Qué es un Objeto?

Un objeto es una instancia específica de una clase. Siguiendo la analogía del coche, un objeto sería un coche particular que se construyó siguiendo ese plano: un coche rojo con un motor de gasolina específico. Cada objeto creado a partir de una clase tendrá las características y podrá realizar los comportamientos definidos por esa clase, pero sus valores específicos para las características pueden variar.

Conceptos Clave de la POO en Python:

• Clases: Plantillas para crear objetos.
• Objetos (Instancias): Creaciones específicas de una clase.
• Atributos: Variables que almacenan datos sobre el objeto (características).
• Métodos: Funciones que definen el comportamiento del objeto (acciones).

Beneficios de la Programación Orientada a Objetos:

• Modularidad: El código se organiza en bloques lógicos (clases), lo que facilita su comprensión y mantenimiento.
• Reutilización de código: Las clases pueden ser utilizadas para crear múltiples objetos y pueden ser extendidas para crear nuevas clases (herencia).
• Encapsulamiento: Los datos (atributos) y los métodos que operan sobre esos datos se agrupan dentro de las clases, ocultando la complejidad interna y protegiendo los datos.
• Abstracción: Se enfoca en las características esenciales de un objeto, ocultando los detalles de implementación.
• Polimorfismo: Objetos de diferentes clases pueden responder a la misma interfaz (método) de manera diferente.

En las siguientes secciones, aprenderemos cómo definir nuestras propias clases y cómo crear objetos a partir de ellas en Python.

Crear una clase

🛠️ Crear una Clase en Python

Para crear una clase en Python, utilizamos la palabra clave class, seguida del nombre que queremos darle a la clase. Por convención, los nombres de las clases suelen comenzar con una letra mayúscula. El cuerpo de la clase se define dentro de un bloque indentado.

Sintaxis Básica:

class NombreDeLaClase:
    # Cuerpo de la clase: atributos y métodos
    pass  # Se usa 'pass' si la clase está vacía por el momento
    

Ejemplo Sencillo: La Clase Coche

Vamos a crear una clase simple llamada Coche. Por ahora, no le definiremos ningún atributo ni método. Usaremos la palabra clave pass para indicar que la clase está vacía.

      
class Coche:
    pass

# Hemos creado una clase llamada Coche
      
     

Añadiendo Atributos (Propiedades):

Los atributos son variables que pertenecen a la clase. Se utilizan para almacenar datos relacionados con los objetos que se crearán a partir de esta clase. Generalmente, los atributos se definen dentro del método especial __init__(), que se llama automáticamente cuando se crea un nuevo objeto de la clase (lo veremos en detalle en el siguiente tema).

Por ahora, veamos un ejemplo donde definimos atributos directamente en la clase (aunque no es la forma más común):

      
class CocheConAtributos:
    marca = "Desconocida"
    modelo = "Genérico"
    color = "Blanco"

# Hemos creado una clase CocheConAtributos con tres atributos de clase
# Estos atributos tendrán el mismo valor para todos los objetos creados
# a partir de esta clase, a menos que se modifiquen individualmente.
      
     

Añadiendo Métodos (Comportamientos):

Los métodos son funciones que pertenecen a la clase y definen las acciones que los objetos de esa clase pueden realizar. El primer parámetro de un método siempre debe ser self, que es una referencia a la instancia del objeto que llama al método. Lo exploraremos más a fondo en temas posteriores.

Aquí tienes un ejemplo de una clase CocheConMetodo con un método simple:

      
class CocheConMetodo:
    def arrancar(self):
        print("El coche ha arrancado.")

    def detener(self):
        print("El coche se ha detenido.")

# Hemos creado una clase CocheConMetodo con dos métodos: arrancar y detener.
      
     

Convenciones de Nombres:

• Los nombres de las clases deben comenzar con una letra mayúscula (ej: Coche, Persona).
• Los nombres de los atributos y métodos deben ser en minúsculas, con palabras separadas por guiones bajos (ej: marca, velocidad_maxima, arrancar).

Crear una clase es el primer paso para la programación orientada a objetos en Python. Una vez que tenemos una clase definida, podemos crear objetos (instancias) de esa clase, que es lo que veremos en el siguiente tema.

Crear objeto

⚙️ Crear un Objeto (Instancia) en Python

Una vez que hemos definido una clase, podemos crear objetos (también llamados instancias) de esa clase. Crear un objeto es como construir un coche a partir de un plano.

Sintaxis para Crear un Objeto:

nombre_del_objeto = NombreDeLaClase()
    

Simplemente llamamos al nombre de la clase como si fuera una función. Esto crea una nueva instancia de la clase y la asigna a la variable nombre_del_objeto.

Ejemplo: Creando Objetos de la Clase Coche

Usando la clase Coche que definimos en el tema anterior (aunque estaba vacía), vamos a crear algunos objetos:

      
class Coche:
    pass

# Crear dos objetos de la clase Coche
mi_coche = Coche()
otro_coche = Coche()

print(mi_coche)
print(otro_coche)
      
     

Al imprimir los objetos, verás que son instancias de la clase Coche y tienen direcciones de memoria diferentes, lo que significa que son objetos distintos.

Accediendo a los Atributos del Objeto:

Si nuestra clase tiene atributos (como en el ejemplo de CocheConAtributos), podemos acceder a ellos utilizando la notación de punto (.) después del nombre del objeto, seguido del nombre del atributo.

      
class CocheConAtributos:
    marca = "Desconocida"
    modelo = "Genérico"
    color = "Blanco"

mi_coche_con_atributos = CocheConAtributos()

print(f"Marca de mi coche: {mi_coche_con_atributos.marca}")
print(f"Modelo de mi coche: {mi_coche_con_atributos.modelo}")
print(f"Color de mi coche: {mi_coche_con_atributos.color}")

otro_coche_con_atributos = CocheConAtributos()
otro_coche_con_atributos.color = "Rojo" # Modificando el atributo para este objeto
print(f"Color del otro coche: {otro_coche_con_atributos.color}")
print(f"Color de mi coche (sin cambios): {mi_coche_con_atributos.color}")
      
     

Como puedes ver, cada objeto tiene sus propios valores para los atributos. Si modificamos un atributo en un objeto, no afecta a los demás objetos de la misma clase.

Llamando a los Métodos del Objeto:

Si nuestra clase tiene métodos (como en el ejemplo de CocheConMetodo), podemos llamarlos utilizando la misma notación de punto (.) después del nombre del objeto, seguido del nombre del método y los paréntesis (para indicar que es una función que se está llamando).

      
class CocheConMetodo:
    def arrancar(self):
        print("El coche ha arrancado.")

    def detener(self):
        print("El coche se ha detenido.")

mi_coche_con_metodo = CocheConMetodo()
mi_coche_con_metodo.arrancar() # Llama al método arrancar del objeto mi_coche_con_metodo
mi_coche_con_metodo.detener()  # Llama al método detener del objeto mi_coche_con_metodo
      
     

Crear objetos es el paso siguiente después de definir una clase. Cada objeto es una entidad independiente con sus propios atributos y la capacidad de realizar las acciones definidas por los métodos de su clase.

La función "init"()

⚙️ La Función __init__(): El Constructor de Objetos

La función __init__() es un método especial en las clases de Python. Se le conoce como el constructor y se llama automáticamente cada vez que se crea un nuevo objeto (instancia) de la clase.

Propósito de __init__():

El principal propósito del método __init__() es inicializar los atributos del objeto. Dentro de este método, podemos asignar valores iniciales a los atributos del objeto utilizando el parámetro self (que representa la instancia del objeto que se está creando).

Sintaxis de __init__():

class NombreDeLaClase:
    def __init__(self, parametro1, parametro2, ...):
        self.atributo1 = parametro1
        self.atributo2 = parametro2
        # ... otros atributos
    

• El primer parámetro de __init__() siempre debe ser self.
• Después de self, puedes definir otros parámetros que se pasarán al crear el objeto.
• Dentro de __init__(), usamos self.nombre_del_atributo = valor para asignar valores a los atributos del objeto.

Ejemplo: La Clase Persona con __init__()

Vamos a crear una clase llamada Persona con un método __init__() que inicializa los atributos nombre y edad de cada objeto Persona.

      
class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

# Crear objetos de la clase Persona, pasando valores para nombre y edad
persona1 = Persona("Ana", 30)
persona2 = Persona("Carlos", 25)

print(f"Nombre de persona1: {persona1.nombre}, Edad: {persona1.edad}")
# Output: Nombre de persona1: Ana, Edad: 30
print(f"Nombre de persona2: {persona2.nombre}, Edad: {persona2.edad}")
# Output: Nombre de persona2: Carlos, Edad: 25
      
     

Cuando creamos los objetos persona1 y persona2, pasamos los valores para nombre y edad al constructor __init__(). Estos valores se utilizan para inicializar los atributos correspondientes de cada objeto.

__init__() es Opcional (pero Común):

Aunque es muy común y recomendable tener un método __init__() para inicializar los objetos, no es estrictamente necesario. Si una clase no tiene un método __init__(), los objetos de esa clase se crearán sin atributos iniciales definidos en la creación.

      
class ClaseSinInit:
    pass

objeto_sin_init = ClaseSinInit()
print(objeto_sin_init)
      
     

Sin embargo, en la mayoría de los casos prácticos, querrás usar __init__() para asegurarte de que tus objetos se creen con un estado inicial significativo.

En Resumen:

• __init__() es el constructor de la clase.
• Se llama automáticamente al crear un objeto.
• Se utiliza para inicializar los atributos del objeto usando self.
• Es opcional, pero muy recomendable para la mayoría de las clases.

La función __init__() es fundamental para la creación de objetos con un estado inicial definido. En el siguiente tema, exploraremos otro método especial útil: __str__().

La función "Estr"()

💬 La Función __str__(): Representación en Cadena de Texto de un Objeto

El método especial __str__() se utiliza para definir una representación en cadena de texto "amigable" de un objeto. Esta representación se devuelve cuando usamos la función incorporada str() en un objeto o cuando el objeto se imprime directamente con print().

Propósito de __str__():

El objetivo principal de __str__() es proporcionar una forma legible y útil de describir un objeto para los usuarios finales o para propósitos de registro (logging).

Sintaxis de __str__():

class NombreDeLaClase:
    def __init__(self, ...):
        # Inicialización de atributos
        pass

    def __str__(self):
        return "Una cadena que representa el objeto"
    

• Al igual que __init__(), el primer parámetro de __str__() siempre debe ser self.
• El método __str__() debe devolver una cadena de texto. Esta cadena debería contener información relevante sobre el objeto.

Ejemplo: La Clase Libro con __str__()

Vamos a crear una clase llamada Libro con atributos titulo y autor, y definiremos un método __str__() para obtener una representación legible del libro.

      
class Libro:
    def __init__(self, titulo, autor):
        self.titulo = titulo
        self.autor = autor

    def __str__(self):
        return f"Libro: '{self.titulo}' de {self.autor}"

# Crear objetos de la clase Libro
libro1 = Libro("El Señor de los Anillos", "J.R.R. Tolkien")
libro2 = Libro("Cien años de soledad", "Gabriel García Márquez")

print(libro1)
# Output: Libro: 'El Señor de los Anillos' de J.R.R. Tolkien
print(libro2)
# Output: Libro: 'Cien años de soledad' de Gabriel García Márquez
print(str(libro1))
# Output: Libro: 'El Señor de los Anillos' de J.R.R. Tolkien
      
     

Como puedes ver, al imprimir los objetos libro1 y libro2, o al usar la función str() con ellos, obtenemos la cadena de texto que definimos en el método __str__().

Diferencia con __repr__():

Python también tiene otro método especial llamado __repr__(). La principal diferencia es que __str__() está pensado para ser una representación legible para humanos, mientras que __repr__() debería ser una representación "oficial" del objeto, que a menudo (pero no siempre) se puede usar para recrear el objeto. Si una clase no tiene un método __str__() definido, Python utilizará la salida de __repr__() en su lugar para las operaciones de cadena.

Cuándo usar __str__():

• Siempre es una buena práctica definir un método __str__() en tus clases para proporcionar una representación útil de los objetos.
• Piensa en qué información sería más útil mostrar cuando alguien imprime o convierte tu objeto a una cadena.

Definir el método __str__() hace que tus objetos sean más fáciles de entender y trabajar, especialmente durante la depuración o al mostrar información al usuario.

Métodos de objetos

🔩 Métodos de Objetos: El Comportamiento de las Instancias

Los métodos son funciones que están definidas dentro de una clase y que se utilizan para definir el comportamiento de los objetos creados a partir de esa clase. Estos métodos pueden acceder y modificar los atributos del objeto (utilizando el parámetro self) y realizar diversas acciones.

Definiendo Métodos:

Para definir un método dentro de una clase, simplemente definimos una función con la sintaxis estándar de Python, pero con la peculiaridad de que el primer parámetro siempre debe ser self. Este parámetro self es una referencia a la instancia del objeto que llama al método.

Sintaxis de un Método:

class NombreDeLaClase:
    def __init__(self, atributo1, atributo2):
        self.atributo1 = atributo1
        self.atributo2 = atributo2

    def nombre_del_metodo(self, parametro_adicional):
        # Código del método que puede usar self.atributo1, self.atributo2,
        # y parametro_adicional
        pass
    

Ejemplo: La Clase Calculadora con Métodos

Vamos a crear una clase llamada Calculadora con un método sumar que toma otro número como argumento y devuelve la suma del atributo interno de la calculadora y el número proporcionado.

      
class Calculadora:
    def __init__(self, valor_inicial):
        self.valor = valor_inicial

    def sumar(self, otro_numero):
        return self.valor + otro_numero

# Crear un objeto de la clase Calculadora
mi_calculadora = Calculadora(10)

# Llamar al método sumar del objeto
resultado = mi_calculadora.sumar(5)
print(f"El resultado de la suma es: {resultado}")
# Output: El resultado de la suma es: 15
      
     

En este ejemplo, el método sumar utiliza self.valor para acceder al atributo valor del objeto mi_calculadora.

Métodos que Modifican Atributos:

Los métodos también pueden modificar los atributos de un objeto utilizando self.

      
class CuentaBancaria:
    def __init__(self, saldo_inicial):
        self.saldo = saldo_inicial

    def depositar(self, cantidad):
        self.saldo += cantidad
        print(f"Se depositaron {cantidad} unidades. Nuevo saldo: {self.saldo}")

    def retirar(self, cantidad):
        if cantidad <= self.saldo:
            self.saldo -= cantidad
            print(f"Se retiraron {cantidad} unidades. Nuevo saldo: {self.saldo}")
        else:
            print("Fondos insuficientes.")

# Crear un objeto de la clase CuentaBancaria
mi_cuenta = CuentaBancaria(100)

# Llamar a los métodos del objeto
mi_cuenta.depositar(50)
mi_cuenta.retirar(20)
mi_cuenta.retirar(200)
      
     

Aquí, los métodos depositar y retirar modifican el atributo self.saldo del objeto mi_cuenta.

La Importancia de self:

Es crucial entender que self es la convención para el primer parámetro de un método de instancia. Cuando llamas a un método en un objeto (ej: mi_objeto.mi_metodo()), Python automáticamente pasa el propio objeto (mi_objeto) como el primer argumento al método, que es capturado por el parámetro self dentro de la definición del método. Esto permite que el método acceda y manipule los atributos del objeto específico que lo llamó.

Los métodos son esenciales para definir el comportamiento y la funcionalidad de los objetos en la programación orientada a objetos.

El propio parámetro

🔑 El Parámetro self: La Clave para Acceder a los Objetos

Como hemos visto en los temas anteriores, el primer parámetro de los métodos de instancia en Python siempre es self. Este parámetro es fundamental para trabajar con los atributos y otros métodos del objeto dentro de la clase.

¿Qué es self?

self es una convención en Python (aunque podrías usar otro nombre, no se recomienda y va en contra de las buenas prácticas) que se refiere a la instancia del objeto que se está creando o utilizando. Cuando se llama a un método en un objeto, Python automáticamente pasa ese objeto como el primer argumento del método, y ese argumento se captura convencionalmente con el nombre self.

Uso de self para Acceder a Atributos:

Dentro de un método, utilizamos self seguido de un punto (.) y el nombre del atributo para acceder a los atributos específicos de ese objeto.

      
class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def saludar(self):
        print(f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años.")

persona1 = Persona("Elena", 28)
persona1.saludar()
# Output: Hola, mi nombre es Elena y tengo 28 años.
      
     

En el método saludar, self.nombre y self.edad nos permiten acceder al nombre y la edad del objeto persona1.

Uso de self para Llamar a Otros Métodos:

Dentro de un método, también podemos usar self para llamar a otros métodos del mismo objeto.

      
class Circulo:
    def __init__(self, radio):
        self.radio = radio

    def calcular_area(self):
        return 3.14159 * self.radio ** 2

    def describir(self):
        area = self.calcular_area()
        print(f"Este círculo tiene un radio de {self.radio} y un área de {area:.2f}.")

mi_circulo = Circulo(5)
mi_circulo.describir()
# Output: Este círculo tiene un radio de 5 y un área de 78.54.
      
     

En el método describir, self.calcular_area() llama al método calcular_area del mismo objeto mi_circulo.

self No es una Palabra Clave Reservada (pero se usa universalmente):

Técnicamente, podrías usar otro nombre en lugar de self como el primer parámetro de un método. Sin embargo, la convención de usar self es tan fuerte en la comunidad de Python que desviarse de ella se considera una mala práctica y haría que tu código fuera menos legible para otros desarrolladores (¡y para ti mismo en el futuro!).

En Resumen:

• self es el primer parámetro en los métodos de instancia.
• Representa la instancia del objeto que llama al método.
• Se utiliza para acceder a los atributos del objeto (ej: self.atributo).
• Se utiliza para llamar a otros métodos del mismo objeto (ej: self.otro_metodo()).
• Aunque no es una palabra clave reservada, usar self es una convención esencial.

Comprender el papel de self es fundamental para trabajar con clases y objetos en Python. Permite que los objetos interactúen con sus propios datos y comportamientos.

Modificar las propiedades de los objetos

✏️ Modificar las Propiedades (Atributos) de los Objetos

Una vez que se ha creado un objeto, podemos modificar sus atributos en cualquier momento. Esto se hace utilizando la notación de punto (.) para acceder al atributo del objeto y luego asignándole un nuevo valor.

Modificación Directa de Atributos:

Podemos cambiar el valor de un atributo de un objeto directamente desde fuera de la clase.

      
class Coche:
    def __init__(self, marca, modelo, color):
        self.marca = marca
        self.modelo = modelo
        self.color = color

mi_coche = Coche("Seat", "Ibiza", "Blanco")
print(f"Color inicial de mi coche: {mi_coche.color}")
# Output: Color inicial de mi coche: Blanco

# Modificando el atributo 'color' directamente
mi_coche.color = "Rojo"
print(f"Color modificado de mi coche: {mi_coche.color}")
# Output: Color modificado de mi coche: Rojo
      
     

Modificación de Atributos a Través de Métodos:

Es una práctica más encapsulada y a menudo más segura modificar los atributos de un objeto a través de métodos definidos en su clase. Esto permite controlar y validar los cambios que se realizan en los atributos.

      
class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def cumplir_anios(self):
        self.edad += 1
        print(f"{self.nombre} ha cumplido un año. Nueva edad: {self.edad}")

    def cambiar_nombre(self, nuevo_nombre):
        self.nombre = nuevo_nombre
        print(f"El nombre ha sido cambiado a: {self.nombre}")

persona1 = Persona("Sofía", 25)
persona1.cumplir_anios()
# Output: Sofía ha cumplido un año. Nueva edad: 26
persona1.cambiar_nombre("Sofía María")
# Output: El nombre ha sido cambiado a: Sofía María
      
     

En este ejemplo, los métodos cumplir_anios y cambiar_nombre son responsables de modificar los atributos edad y nombre respectivamente.

Consideraciones al Modificar Atributos:

• Encapsulamiento: Modificar atributos directamente puede romper el principio de encapsulamiento, donde se prefiere que los datos internos de un objeto se manipulen a través de sus métodos.
• Validación: Los métodos pueden incluir lógica para validar los nuevos valores antes de asignarlos a los atributos, lo que ayuda a mantener la integridad del estado del objeto.
• Control: Los métodos proporcionan un punto de control sobre cómo y cuándo se modifican los atributos, lo que puede ser importante para la lógica del programa.

Añadir Nuevos Atributos a Objetos Existentes (Dinámicamente):

En Python, es posible añadir nuevos atributos a un objeto existente incluso después de su creación. Sin embargo, esta práctica generalmente no se recomienda ya que puede hacer que los objetos de la misma clase tengan estructuras diferentes, lo que dificulta la comprensión y el mantenimiento del código.

      
mi_coche = Coche("Renault", "Megane", "Gris")
mi_coche.anio_fabricacion = 2020 # Añadiendo un nuevo atributo dinámicamente
print(f"Año de fabricación de mi coche: {mi_coche.anio_fabricacion}")
# Output: Año de fabricación de mi coche: 2020
      
     

En general, es mejor definir todos los atributos necesarios de una clase en su método __init__() para asegurar una estructura consistente para todos los objetos de esa clase.

Borrar Propiedades de objetos

🗑️ Borrar Propiedades (Atributos) de Objetos

En Python, es posible eliminar atributos de un objeto después de su creación utilizando la palabra clave del.

Uso de del para Borrar Atributos:

Para borrar un atributo de un objeto, utilizamos la siguiente sintaxis:

del objeto.nombre_del_atributo
    

Después de ejecutar esta instrucción, el atributo especificado dejará de existir en ese objeto.

Ejemplo: Borrando un Atributo de un Objeto Persona

Vamos a retomar nuestra clase Persona y crear un objeto. Luego, borraremos uno de sus atributos.

      
class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

persona1 = Persona("Ricardo", 35)
print(f"Nombre de persona1: {persona1.nombre}, Edad: {persona1.edad}")
# Output: Nombre de persona1: Ricardo, Edad: 35

# Borrando el atributo 'edad' del objeto persona1
del persona1.edad

# Intentar acceder al atributo borrado generará un AttributeError
try:
    print(f"Edad de persona1: {persona1.edad}")
except AttributeError as e:
    print(f"Error: {e}")
# Output: Error: 'Persona' object has no attribute 'edad'
      
     

Como se muestra en el ejemplo, después de usar del persona1.edad, intentar acceder a persona1.edad genera un error AttributeError, indicando que el atributo ya no existe en ese objeto.

Consideraciones al Borrar Atributos:

• Impacto en el objeto: Borrar un atributo puede alterar significativamente el estado y el comportamiento de un objeto. Los métodos que dependían de ese atributo podrían fallar.
• Consistencia de la clase: Al igual que añadir atributos dinámicamente, borrar atributos puede hacer que los objetos de la misma clase tengan estructuras inconsistentes, lo que puede dificultar el mantenimiento y la comprensión del código.
• Casos de uso: Aunque es posible borrar atributos, generalmente se reserva para casos muy específicos donde un atributo se vuelve completamente irrelevante para la vida útil de un objeto.

¿Es una práctica común?

Borrar atributos de objetos no es una práctica tan común como modificarlos. En la mayoría de los casos, es preferible establecer un atributo en None o en un valor que indique su ausencia o estado inactivo, en lugar de eliminarlo por completo de forma dinámica. Esto ayuda a mantener una estructura más predecible para los objetos de una clase.

En resumen, Python te da la flexibilidad de borrar atributos de objetos dinámicamente, pero es importante usar esta capacidad con precaución y entender sus posibles implicaciones en el comportamiento de los objetos y la consistencia de la clase.

Borrar los objetos

🗑️ Borrar los Objetos (Instancias)

En Python, la gestión de memoria es automática gracias al recolector de basura (garbage collector). Esto significa que generalmente no necesitas preocuparte por borrar objetos explícitamente. Cuando un objeto ya no está referenciado por ninguna variable en tu programa, el recolector de basura de Python eventualmente liberará la memoria que ocupaba.

Eliminar Referencias a Objetos:

La forma principal de hacer que un objeto sea elegible para la recolección de basura es eliminar todas las referencias a él. Esto se puede hacer de varias maneras:

• Reasignar la variable: Si una variable que referencia un objeto se reasigna a otro valor (o a None), la referencia al objeto original se pierde.
• Eliminar la variable: Utilizando la palabra clave del para eliminar la variable que referencia el objeto.
• Salir del scope: Cuando una variable definida dentro de un cierto alcance (como una función) sale de ese alcance, la referencia al objeto que contenía se pierde.

Uso de del para Eliminar Variables (y sus Referencias):

La palabra clave del no solo se usa para borrar atributos, sino también para eliminar variables. Cuando eliminas una variable que era la única referencia a un objeto, ese objeto se vuelve elegible para la recolección de basura.

      
class Ejemplo:
    def __init__(self, nombre):
        self.nombre = nombre

objeto1 = Ejemplo("Uno")
objeto2 = objeto1 # objeto2 ahora también referencia el mismo objeto

print(objeto1.nombre) # Output: Uno
print(objeto2.nombre) # Output: Uno

del objeto1 # Eliminamos la variable objeto1

# Intentar acceder a objeto1 generará un NameError
try:
    print(objeto1.nombre)
except NameError as e:
    print(f"Error: {e}")
# Output: Error: name 'objeto1' is not defined

# objeto2 sigue referenciando el objeto
print(objeto2.nombre) # Output: Uno

del objeto2 # Ahora no hay más referencias al objeto, será recolectado por la basura
      
     

En este ejemplo, al eliminar ambas variables (objeto1 y objeto2) que referenciaban el objeto Ejemplo, ese objeto se vuelve elegible para ser eliminado por el recolector de basura.

El Recolector de Basura (Garbage Collector):

Python utiliza un recolector de basura automático para gestionar la memoria. No puedes controlar directamente cuándo se ejecuta el recolector de basura, pero se activa periódicamente para liberar la memoria de los objetos que ya no están en uso (es decir, no tienen referencias activas).

¿Necesitas Borrar Objetos Explícitamente?

En la mayoría de los casos, no necesitas borrar objetos explícitamente en Python. El recolector de basura se encarga de esto automáticamente. La principal razón para usar del en una variable que referencia un objeto es si quieres asegurarte de que esa variable ya no esté disponible en tu scope, o si quieres romper una referencia explícitamente por alguna razón (por ejemplo, para liberar recursos que el objeto podría estar manteniendo, aunque esto suele manejarse mejor con métodos específicos o con el uso de contextos with).

En resumen, para "borrar" un objeto en Python, generalmente basta con asegurarse de que no haya más referencias a él. El recolector de basura se encargará del resto.

Declaración de aprobación

➡️ La Declaración pass: Un Marcador de Posición

La declaración pass en Python es una operación nula; cuando se ejecuta, no sucede nada. Sin embargo, es útil en situaciones donde la sintaxis de Python requiere una declaración, pero no quieres ejecutar ningún código todavía. En el contexto de clases y objetos, pass se utiliza a menudo para crear clases vacías o para indicar que un método se implementará más tarde.

Usos de pass en Clases:

A veces, quieres definir una clase como un simple contenedor para datos o como un marcador de posición para una funcionalidad futura. En estos casos, puedes usar pass como el cuerpo de la clase.

      
class MiClaseVacia:
    pass

# Se ha creado una clase vacía sin atributos ni métodos por el momento
objeto_vacio = MiClaseVacia()
print(objeto_vacio)
      
     

En este ejemplo, MiClaseVacia es una clase válida en Python, aunque no contenga ninguna funcionalidad. La declaración pass permite que la definición de la clase sea sintácticamente correcta.

Usos de pass en Métodos:

De manera similar, puedes usar pass dentro de la definición de un método si quieres declarar el método pero aún no tienes la implementación.

      
class ClaseConMetodoSinImplementar:
    def __init__(self, nombre):
        self.nombre = nombre

    def metodo_futuro(self):
        pass # Este método se implementará más tarde

objeto_con_metodo = ClaseConMetodoSinImplementar("Ejemplo")
objeto_con_metodo.metodo_futuro() # No sucede nada al llamar a este método
      
     

Aquí, metodo_futuro está definido sintácticamente gracias a pass, pero no realiza ninguna acción cuando se llama.

¿Por qué usar pass?

• Evitar errores de sintaxis: Python requiere un bloque de código indentado después de ciertas declaraciones (como class y def). Si no tienes código para poner allí inmediatamente, puedes usar pass para evitar errores de sintaxis.
• Planificación y diseño: pass te permite esbozar la estructura de tus clases y métodos sin tener que escribir la implementación completa de inmediato. Esto es útil durante las fases de diseño y planificación de un proyecto.
• Código comentado vs. pass: Aunque podrías usar comentarios para indicar secciones de código futuras, pass es una declaración ejecutable (aunque no haga nada), lo que a veces puede ser útil en ciertos contextos.

En resumen, pass es una herramienta simple pero útil en Python para crear clases y métodos como marcadores de posición que se implementarán en el futuro, o para definir clases vacías sin funcionalidad inicial.

---

Ir al indice