Em Python, os métodos dentro de uma classe podem ser categorizados em métodos de instância, métodos de classe e métodos estáticos. Cada um serve a um propósito exclusivo e fornece diferentes níveis de acesso à classe e suas instâncias. Neste blog, exploraremos métodos de classe e métodos estáticos, como usá-los e perguntas comuns em entrevistas que você pode encontrar.

Métodos de instância

Antes de mergulhar nos métodos de classe e nos métodos estáticos, vamos recapitular brevemente os métodos de instância:

• Métodos de instância: Esses são os métodos mais comuns em uma classe e são usados ​​para acessar ou modificar o estado do objeto. Eles tomam self como primeiro parâmetro, que representa a instância da classe.

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 classe

Métodos de classe são métodos que têm acesso à própria classe, não apenas às instâncias da classe. Eles tomam cls como primeiro parâmetro, que representa a classe. Eles são definidos usando o decorador @classmethod.

Por que usar métodos de classe?

• Para criar construtores alternativos.

• Para acessar ou modificar atributos de nível de classe.

Exemplo: Construtor 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

Neste exemplo, from_birth_year é um construtor alternativo que calcula a idade a partir do ano de nascimento e cria uma instância Person.

Exemplo: Modificando Atributos de Classe

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

Neste exemplo, change_company é um método de classe que altera o atributo de classe company_name.

Métodos estáticos

Métodos estáticos não acessam ou modificam dados específicos de classe ou instância. Eles são métodos utilitários que pertencem à classe e são definidos usando o decorador @staticmethod.

Por que usar métodos estáticos?

• Para definir funções utilitárias que operam independentemente dos dados de classe e instância.

• Para manter o código organizado dentro do namespace da classe.

Exemplo: Função Utilitária

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

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

Neste exemplo, add é um método estático que realiza adição independentemente de qualquer classe ou dados de instância.

Comparação de Métodos

• Métodos de instância: Opera em uma instância da classe (self).

• Métodos de classe: operam na própria classe (cls).

• Métodos estáticos: não opere em dados específicos de classe ou instância.

Perguntas da entrevista sobre métodos de classe e métodos estáticos

Questão 1: Explique a diferença entre métodos de classe e métodos estáticos.

• Métodos de classe: Opera na própria classe, usando cls como primeiro parâmetro. Eles podem modificar dados em nível de classe.

• Métodos estáticos: são independentes de dados específicos de classe e instância. Eles não usam cls ou self como primeiro parâmetro.

Questão 2: Implemente uma classe Book com métodos de classe e 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

Neste exemplo, from_string é um construtor alternativo (método de classe) que cria um objeto Book a partir de uma string, e is_valid_year é um método estático que verifica se um ano é válido.

Pergunta 3: Por que você usaria um método de classe como construtor alternativo?

Os métodos de classe como construtores alternativos fornecem flexibilidade na criação de instâncias a partir de diferentes tipos de entrada ou cenários, tornando o código mais legível e mantendo um único local para a lógica de criação de objetos.

Resumo

• Métodos de instância: operam em instâncias de classe e podem modificar dados específicos da instância.

• Métodos de classe: operam na própria classe, usando cls como o primeiro parâmetro, e podem modificar dados em nível de classe.

• Métodos estáticos: não operam em dados específicos de classe ou instância e são usados ​​para funções utilitárias.

Ao compreender e utilizar esses métodos de forma eficaz, você pode escrever código orientado a objetos mais organizado e flexível em Python.