Definir Clases y Objetos en Python

Introducción

En este laboratorio, aprenderá los conceptos fundamentales de la Programación Orientada a Objetos (POO) en Python. Exploraremos cómo definir clases, que sirven como planos (blueprints) para crear objetos, y comprenderemos la relación entre clases y objetos.

Obtendrá experiencia práctica creando y utilizando instancias de las clases que defina. El laboratorio le guiará a través de la inicialización de objetos con el método __init__ para establecer su estado inicial y la personalización de su representación en cadena (string representation) utilizando el método __repr__ para una mejor depuración y legibilidad.

Definir una Clase y Crear una Instancia

En este paso, aprenderá cómo definir una clase básica y crear un objeto, o instancia, a partir de ella.

En la Programación Orientada a Objetos, una clase es un plano (blueprint) para crear objetos. Define un conjunto de atributos (datos) y métodos (funciones) que tendrán los objetos creados. Un objeto es una instancia de una clase, una entidad concreta construida a partir del plano de la clase.

Comencemos creando una clase simple llamada Dog.

Primero, abra el archivo dog.py desde el explorador de archivos en el lado izquierdo del WebIDE. Este archivo está actualmente vacío.

Ahora, añada el siguiente código a dog.py para definir la clase Dog, crear una instancia y utilizarla:

## Define a simple Dog class
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Method
    def bark(self):
        print("Woof!")

## Create an instance (object) of the Dog class
my_dog = Dog()

## Access the class attribute using the instance
print(f"The species is: {my_dog.species}")

## Call the instance's method
print("The dog says:")
my_dog.bark()

Analicemos el código:

• class Dog:: Esta línea define una nueva clase llamada Dog.
• species = "Canis familiaris": Este es un atributo de clase (class attribute). Su valor se comparte entre todas las instancias de la clase Dog.
• def bark(self):: Esto define un método, que es una función dentro de una clase. El parámetro self es una referencia a la instancia actual de la clase y se utiliza para acceder a las variables que pertenecen a la clase.
• my_dog = Dog(): Esta línea crea una nueva instancia de la clase Dog y la asigna a la variable my_dog.
• my_dog.species: Accedemos al atributo species del objeto my_dog usando la notación de punto.
• my_dog.bark(): Llamamos al método bark en el objeto my_dog. Python pasa automáticamente el objeto my_dog como el argumento self al método.

Guarde el archivo. Para ejecutar su script, abra una terminal en el WebIDE y ejecute el siguiente comando:

python dog.py

Debería ver la siguiente salida, confirmando que su objeto fue creado y que su atributo y método fueron accedidos correctamente.

The species is: Canis familiaris
The dog says:
Woof!

Inicializar Objetos con el Método __init__

Mientras que los atributos de clase son compartidos por todas las instancias, a menudo se desea que cada instancia tenga sus propios datos únicos. El método __init__ es un método especial en las clases de Python que actúa como constructor. Se llama automáticamente cuando se crea una nueva instancia, lo que permite inicializar sus atributos únicos.

Modifiquemos la clase Dog para darle a cada perro un nombre y una raza únicos.

Abra el archivo dog.py nuevamente y reemplace su contenido con el siguiente código:

## Define a Dog class with an __init__ method
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## The __init__ method (constructor)
    def __init__(self, name, breed):
        ## Instance attributes
        self.name = name
        self.breed = breed

    ## Method
    def bark(self):
        print("Woof!")

## Create instances with unique attributes
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Lucy", "Labrador")

## Access the instance attributes
print(f"{dog1.name} is a {dog1.breed}.")
print(f"{dog2.name} is a {dog2.breed}.")

## The class attribute is still shared
print(f"Both are of the species: {dog1.species}")

Esto es lo que cambió:

• def __init__(self, name, breed):: Definimos el método __init__. Acepta self, name y breed como argumentos.
• self.name = name y self.breed = breed: Estas líneas crean atributos de instancia (instance attributes). Son únicos para cada objeto Dog. La palabra clave self adjunta estos atributos a la instancia específica que se está creando.
• dog1 = Dog("Buddy", "Golden Retriever"): Al crear una instancia, ahora pasamos argumentos para name y breed. Estos se pasan automáticamente al método __init__.

Guarde el archivo y ejecútelo desde la terminal:

python dog.py

La salida muestra que cada objeto perro tiene su propio nombre y raza, mientras que todavía comparte el atributo de clase species.

Buddy is a Golden Retriever.
Lucy is a Labrador.
Both are of the species: Canis familiaris

Personalizar la Representación del Objeto con __repr__

Cuando intenta imprimir un objeto directamente, Python muestra una representación predeterminada que incluye la clase del objeto y su dirección de memoria, lo cual no es muy útil. Puede proporcionar una representación en cadena (string) más descriptiva y amigable para el desarrollador definiendo el método especial __repr__.

Añadamos un método __repr__ a nuestra clase Dog.

Abra dog.py y reemplace su contenido con la versión final de nuestro código:

## Define a Dog class with __init__ and __repr__ methods
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## The __init__ method (constructor)
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    ## The __repr__ method for a developer-friendly representation
    def __repr__(self):
        return f"Dog(name='{self.name}', breed='{self.breed}')"

    ## Method
    def bark(self):
        print("Woof!")

## Create an instance
my_dog = Dog("Buddy", "Golden Retriever")

## Print the object directly
print(my_dog)

La adición clave es:

• def __repr__(self):: Esto define el método de representación.
• return f"Dog(name='{self.name}', breed='{self.breed}')": Este método debe devolver una cadena (string). Una buena práctica es hacer que la cadena parezca una expresión válida de Python que podría usarse para recrear el objeto con el mismo estado.

Guarde el archivo y ejecute el script por última vez:

python dog.py

En lugar de una dirección de memoria, la salida es ahora la cadena clara e informativa devuelta por su método __repr__. Esto es extremadamente útil para la depuración (debugging).

Dog(name='Buddy', breed='Golden Retriever')

Resumen

En este laboratorio, ha aprendido los conceptos básicos de la Programación Orientada a Objetos (POO) en Python. Comenzó definiendo una clase simple y creando una instancia de ella, aprendiendo a usar atributos y métodos de clase. Luego mejoró su clase añadiendo el método __init__ para inicializar cada objeto con atributos de instancia únicos. Finalmente, personalizó la representación en cadena (string representation) de sus objetos implementando el método __repr__, lo que mejora enormemente la claridad y la capacidad de depuración (debuggability) de su código. Estos conceptos son la base para construir aplicaciones más complejas y organizadas en Python.