Creación de clases y objetos

3.1 Creación de una clase

Crear clases en Python es una parte importante de la programación orientada a objetos (OOP). Las clases permiten crear nuevos tipos de datos, que pueden tener sus propios atributos y métodos. Vamos a revisar los conceptos básicos y ejemplos de creación de clases en Python.

Conceptos básicos

• Clase: un esquema para crear objetos. La clase define los atributos y métodos que tendrán los objetos de esa clase.
• Objeto: un ejemplo de la clase. El objeto tiene todos los atributos y métodos definidos en la clase.
• Atributo: una variable asociada con la clase o el objeto.
• Método: una función asociada con la clase o el objeto.

Atributos son básicamente las variables internas de un objeto o clase. Métodos son las funciones definidas dentro de la clase. Estos términos vienen de OOP y se usan junto con funciones y variables.

Para declarar (crear) una nueva clase se utiliza la palabra clave class. La sintaxis general de esta operación es la siguiente:

class NombreDeClase:
    variable1 = valor1
    variableN = valorN
          
    def funcion1(self):
        código de la función
            
    def funcionM(self):
        código de la función

En principio, se puede decir que una clase es un pequeño programa (variables + funciones) ubicado en un área designada llamada NombreDeClase.

Después de crear una clase, puedes crear objetos (instancias) de esa clase. Este código se ve aún más sencillo:

variableX = NombreDeClase()

¡Importante! Los nombres de variables y métodos en Python se escriben en minúscula. Los nombres de las clases se escriben con mayúscula. Además, no se usan guiones bajos en los nombres de las clases. Si un nombre de clase tiene varias palabras, cada una de ellas se escribe con mayúscula.

Si quieres acceder a una variable de clase/objeto, normalmente se ve así:

variableX.variable1 = 10
variableX.funcionM()       

Pero hay algunos matices, de los que hablaremos a continuación…

3.2 Trabajando con el objeto

Tanto la clase como la instancia de la clase (objeto de la clase) son objetos, por lo que ambos pueden tener sus propias variables y métodos.

Existen dos tipos de variables:

• Atributo/Variable/Campo de la clase (class property)
• Atributo/Variable/Campo del objeto (object property)

Y hasta tres tipos de métodos:

• Método/Función de clase (class method)
• Método/Función de objeto (instance method)
• Método estático (static method)

Los métodos se diferencian por cómo se declaran y cómo se llaman.

Métodos de objeto

Al declarar un método de objeto, debes pasarle un primer parámetro obligatorio — self. Al llamar al método, este parámetro recibe una referencia al objeto (instance).

class MyClass:

    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
                   

my_object = MyClass()
my_object.instance_method()
        

En el ejemplo anterior, cuando se comenzó a ejecutar la función instance_method(), el parámetro self recibió una referencia al objeto my_object.

Métodos de clase

Al declarar un método de clase, también debes pasarle un primer parámetro obligatorio — cls. Al llamar al método, este parámetro recibe una referencia a la clase (class object). Además, el método de clase debe estar marcado con el decorador classmethod, como en el siguiente ejemplo:

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
                   

my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
        

En el ejemplo anterior, cuando se comenzó a ejecutar la función class_method(), el parámetro cls recibió una referencia a la clase MyClass.

Método estático

Al declarar un método estático, no necesitas pasarle nada, pero tampoco podrá acceder a los datos internos de la clase. Además, el método debe estar marcado con el decorador staticmethod, como en el siguiente ejemplo:

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
        
    @staticmethod
    def static_method():
        return "Este método no depende de la instancia o la clase"
                   
my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
MyClass.static_method() 
        

El método estático se llama de manera muy similar al método de clase, pero ni una referencia al objeto ni una referencia a la clase se le pasan.

3.3 Variables de clase

Variables de clase

Para declarar una variable (atributo) de clase, simplemente necesitas declararla en cualquier lugar dentro de la clase. Normalmente se hace al inicio, antes de declarar los métodos de la clase. Ejemplo:

class MyClass:
    attribute = "Soy un atributo de clase"
        
    @classmethod
    def class_method(cls):
        print(cls.attribute)  # Soy un atributo de clase
                  
my_object = MyClass()
MyClass.class_method()

Si quieres leer o escribir un valor en una variable de clase, usa el objeto cls.

En principio, puedes acceder a la variable de clase también a través del nombre de la clase:

class MyClass:
    attribute = "Soy un atributo de clase"
        
    @classmethod
    def class_method(cls):
        print(MyClass.attribute)  # Soy un atributo de clase
                  
my_object = MyClass()

print(MyClass.attribute)  # Soy un atributo de clase

Variables/campos del objeto

Las variables del objeto (instance) son los campos del objeto self. Simplemente trabajas con ellas a través de self.name. Es precisamente para esto que se pasa el objeto self en cada método del objeto.

Ejemplo:

class MyClass:
    attribute = "Soy un atributo de clase"
        
    def set_name(self, name):
        self.name = name
        
    def print_name(self):
        print(self.name)    
                 
my_object = MyClass()
my_object.set_name("Campo del objeto llamado name") 
my_object.print_name()  # "Campo del objeto llamado name"
        

Cada vez que llamas a un método del objeto, el primer parámetro (self) recibe una referencia al objeto en el cual se llama el método. Los diferentes métodos del objeto pueden acceder a datos comunes a través del uso del objeto self.