En Python, los métodos dentro de una clase se pueden clasificar en métodos de instancia, métodos de clase y métodos estáticos. Cada uno tiene un propósito único y proporciona diferentes niveles de acceso a la clase y sus instancias. En este blog, exploraremos métodos de clase y métodos estáticos, cómo usarlos y preguntas comunes en entrevistas que podría encontrar.

Métodos de instancia

Antes de profundizar en los métodos de clase y los métodos estáticos, recapitulemos brevemente los métodos de instancia:

• Métodos de instancia: Estos son los métodos más comunes en una clase y se utilizan para acceder o modificar el estado del objeto. Toman self como primer parámetro, que representa la instancia de la clase.

class Car:
    def __init__(self, model, year):
        self.model = model
        self.year = year

    def display_info(self):
        print(f"Car Model: {self.model}, Year: {self.year}")

# Usage
my_car = Car("Toyota", 2020)
my_car.display_info()  # Output: Car Model: Toyota, Year: 2020

Métodos de clase

Los métodos de clase son métodos que tienen acceso a la clase misma, no solo a instancias de la clase. Toman cls como primer parámetro, que representa la clase. Se definen utilizando el decorador @classmethod.

¿Por qué utilizar métodos de clase?

• Para crear constructores alternativos.

• Para acceder o modificar atributos de nivel de clase.

Ejemplo: constructor alternativo

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

    @classmethod
    def from_birth_year(cls, name, birth_year):
        current_year = 2024
        age = current_year - birth_year
        return cls(name, age)

# Usage
person1 = Person("Alice", 30)  # Using the primary constructor
person2 = Person.from_birth_year("Bob", 1990)  # Using the alternative constructor

print(person1.name, person1.age)  # Output: Alice 30
print(person2.name, person2.age)  # Output: Bob 34

En este ejemplo, from_birth_year es un constructor alternativo que calcula la edad a partir del año de nacimiento y crea una instancia de Persona.

Ejemplo: modificar atributos de clase

class Employee:
    company_name = "TechCorp"

    def __init__(self, name):
        self.name = name

    @classmethod
    def change_company(cls, new_name):
        cls.company_name = new_name

# Usage
Employee.change_company("NewTechCorp")
print(Employee.company_name)  # Output: NewTechCorp

En este ejemplo, change_company es un método de clase que cambia el atributo de clase company_name.

Métodos estáticos

Los métodos estáticos no acceden ni modifican datos específicos de clase o instancia. Son métodos de utilidad que pertenecen a la clase y se definen usando el decorador @staticmethod.

¿Por qué utilizar métodos estáticos?

• Para definir funciones de utilidad que operan independientemente de los datos de clase e instancia.

• Para mantener el código organizado dentro del espacio de nombres de la clase.

Ejemplo: función de utilidad

class MathUtils:
    @staticmethod
    def add(a, b):
        return a   b

# Usage
print(MathUtils.add(5, 7))  # Output: 12

En este ejemplo, agregar es un método estático que realiza una suma independientemente de cualquier dato de clase o instancia.

Comparación de métodos

• Métodos de instancia: Operar en una instancia de la clase (self).

• Métodos de clase: opera en la clase misma (cls).

• Métodos estáticos: No opere con datos específicos de clase o instancia.

Preguntas de la entrevista sobre métodos de clase y métodos estáticos

Pregunta 1: Explique la diferencia entre métodos de clase y métodos estáticos.

• Métodos de clase: opera en la clase misma, usando cls como primer parámetro. Pueden modificar datos a nivel de clase.

• Métodos estáticos: son independientes de los datos específicos de la clase y la instancia. No toman cls ni self como primer parámetro.

Pregunta 2: Implemente un libro de clases con métodos de clase y métodos estáticos.

class Book:
    def __init__(self, title, author, publication_year):
        self.title = title
        self.author = author
        self.publication_year = publication_year

    @classmethod
    def from_string(cls, book_str):
        title, author, publication_year = book_str.split(', ')
        return cls(title, author, int(publication_year))

    @staticmethod
    def is_valid_year(year):
        return year > 0

# Usage
book1 = Book("Python Basics", "John Doe", 2020)
book2 = Book.from_string("Advanced Python, Jane Smith, 2018")

print(book1.title, book1.author, book1.publication_year)  # Output: Python Basics John Doe 2020
print(book2.title, book2.author, book2.publication_year)  # Output: Advanced Python Jane Smith 2018
print(Book.is_valid_year(2024))  # Output: True

En este ejemplo, from_string es un constructor alternativo (método de clase) que crea un objeto Libro a partir de una cadena, e is_valid_year es un método estático que verifica si un año es válido.

Pregunta 3: ¿Por qué utilizarías un método de clase como constructor alternativo?

Los métodos de clase como constructores alternativos brindan flexibilidad para crear instancias a partir de diferentes tipos de entradas o escenarios, lo que hace que el código sea más legible y mantiene un lugar único para la lógica de creación de objetos.

Resumen

• Métodos de instancia: opera en instancias de clase y puede modificar datos específicos de la instancia.

• Métodos de clase: opera en la clase misma, usando cls como primer parámetro y puede modificar datos a nivel de clase.

• Métodos estáticos: no operan con datos específicos de clase o instancia y se utilizan para funciones de utilidad.

Al comprender y utilizar estos métodos de manera efectiva, puedes escribir código orientado a objetos más organizado y flexible en Python.