Métodos Mágicos Básicos

Introdução

Neste tutorial, exploraremos os métodos mágicos básicos em Python. Os métodos mágicos, também conhecidos como métodos "dunder" (métodos de sublinhado duplo), permitem que você defina como os objetos Python se comportam em determinadas situações, possibilitando a manipulação avançada e personalizada de objetos.

Inicialização e Representação de Objetos

Nesta seção, exploraremos os métodos mágicos de inicialização e representação de objetos em Python. Esses métodos permitem que você defina um comportamento personalizado para criar objetos e representá-los como strings legíveis e inequívocas para humanos.

__init__

O método __init__ é chamado quando um objeto é criado. Ele é usado para inicializar os atributos do objeto.

Vamos começar com um objeto simples. Em person.py, crie uma classe chamada Person que possui dois atributos.

class Person:
    def __init__(self, name: str, age: int):
        """
        Inicializa o objeto Person com um nome e idade.

        :param name: O nome da pessoa.
        :param age: A idade da pessoa.
        """
        self.name = name
        self.age = age

__str__

O método __str__ é chamado pela função embutida str() e pela função print() para obter uma representação de string legível do objeto.

    ## ... (código anterior em person.py)

    def __str__(self) -> str:
        """
        Retorna uma representação de string legível do objeto Person.

        :return: Uma string descrevendo a pessoa.
        """
        return f"{self.name} tem {self.age} anos de idade."

__repr__

O método __repr__ é chamado pela função embutida repr() e usado no interpretador interativo para obter uma representação de string que, se possível, pode ser usada para recriar o objeto.

    ## ... (código anterior em person.py)

    def __repr__(self) -> str:
        """
        Retorna uma representação de string do objeto Person que pode ser usada para recriar o objeto.

        :return: Uma string no formato 'Person(name, age)'.
        """
        return f"Person('{self.name}', {self.age})"

Exemplo: Usando os Métodos Mágicos Básicos

Agora que definimos os métodos mágicos básicos para nossa classe Person, vamos ver como eles funcionam em init_repr_example.py:

from person import Person

## Cria um novo objeto Person
p = Person("Alice", 30)

## Usa o método __str__ com a função print
print(p)  ## Output: Alice is 30 years old.

## Usa o método __repr__ no interpretador interativo
print(repr(p))  ## Output: Person('Alice', 30)

Em seguida, digite o seguinte comando no terminal para executar o script.

python init_repr_example.py

Comparação de Objetos

Nesta seção, exploraremos os métodos mágicos usados para comparação de objetos em Python. Esses métodos permitem que você defina uma lógica de comparação personalizada para objetos da sua classe.

__eq__

O método __eq__ é usado para determinar se dois objetos são iguais. Ele é chamado pelo operador ==.

    ## ... (código anterior em person.py)

    def __eq__(self, other: "Person") -> bool:
        """
        Compara dois objetos Person para igualdade.

        :param other: O outro objeto Person para comparar.
        :return: True se ambos os objetos tiverem o mesmo nome e idade, False caso contrário.
        """
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

__ne__

O método __ne__ é usado para determinar se dois objetos não são iguais. Ele é chamado pelo operador !=.

    ## ... (código anterior em person.py)

    def __ne__(self, other: "Person") -> bool:
        """
        Compara dois objetos Person para desigualdade.

        :param other: O outro objeto Person para comparar.
        :return: True se os objetos tiverem nomes ou idades diferentes, False caso contrário.
        """
        return not self.__eq__(other)

__lt__

O método __lt__ é usado para determinar se um objeto é menor que outro. Ele é chamado pelo operador <.

    ## ... (código anterior em person.py)

    def __lt__(self, other: "Person") -> bool:
        """
        Compara dois objetos Person para ver se um é menor que o outro com base na idade.

        :param other: O outro objeto Person para comparar.
        :return: True se a idade do objeto atual for menor que a idade do outro objeto, False caso contrário.
        """
        if isinstance(other, Person):
            return self.age < other.age
        return NotImplemented

__le__

O método __le__ é usado para determinar se um objeto é menor ou igual a outro. Ele é chamado pelo operador <=.

    ## ... (código anterior em person.py)

    def __le__(self, other: "Person") -> bool:
        """
        Compara dois objetos Person para ver se um é menor ou igual ao outro com base na idade.

        :param other: O outro objeto Person para comparar.
        :return: True se a idade do objeto atual for menor ou igual à idade do outro objeto, False caso contrário.
        """
        if isinstance(other, Person):
            return self.age <= other.age
        return NotImplemented

__gt__

O método __gt__ é usado para determinar se um objeto é maior que outro. Ele é chamado pelo operador >.

    ## ... (código anterior em person.py)

    def __gt__(self, other: "Person") -> bool:
        """
        Compara dois objetos Person para ver se um é maior que o outro com base na idade.

        :param other: O outro objeto Person para comparar.
        :return: True se a idade do objeto atual for maior que a idade do outro objeto, False caso contrário.
        """
        if isinstance(other, Person):
            return self.age > other.age
        return NotImplemented

__ge__

O método __ge__ é usado para determinar se um objeto é maior ou igual a outro. Ele é chamado pelo operador >=.

    ## ... (código anterior em person.py)

    def __ge__(self, other: "Person") -> bool:
        """
        Compara dois objetos Person para ver se um é maior ou igual ao outro com base na idade.

        :param other: O outro objeto Person para comparar.
        :return: True se a idade do objeto atual for maior ou igual à idade do outro objeto, False caso contrário.
        """
        if isinstance(other, Person):
            return self.age >= other.age
        return NotImplemented

Exemplo: Usando os Métodos Mágicos de Comparação de Objetos

Agora que definimos os métodos mágicos de comparação de objetos para nossa classe Person, vamos ver como eles funcionam em compare_example.py:

from person import Person

## Cria dois objetos Person
p1 = Person("Alice", 30)
p2 = Person("Bob", 35)

## Usa os métodos __eq__ e __ne__
print(p1 == p2)  ## Output: False
print(p1 != p2)  ## Output: True

## Usa os métodos __lt__, __le__, __gt__ e __ge__
print(p1 < p2)  ## Output: True
print(p1 <= p2)  ## Output: True
print(p1 > p2)  ## Output: False
print(p1 >= p2)  ## Output: False

Em seguida, digite o seguinte comando no terminal para executar o script.

python compare_example.py

Destruição de Objetos

Nesta seção, exploraremos o método mágico de destruição de objetos em Python. O método permite que você defina um comportamento personalizado quando um objeto está prestes a ser destruído.

__del__

O método __del__ é chamado quando um objeto está prestes a ser destruído. Ele permite que você execute tarefas de limpeza, como fechar manipuladores de arquivos ou liberar recursos, antes que o objeto seja coletado pelo coletor de lixo (garbage collected).

    ## ... (código anterior em person.py)

    def __del__(self):
        """
        Limpa o objeto Person antes que ele seja destruído.
        """
        print(f"Pessoa '{self.name}' está sendo excluída.")

Exemplo: Usando o Método Mágico de Destruição de Objetos

Agora que definimos o método mágico de destruição de objetos para nossa classe Person, vamos ver como ele funciona em del_example.py:

from person import Person

## Cria um objeto Person e, em seguida, exclui-o
p = Person("Alice", 30)
del p  ## Output: Person 'Alice' is being deleted.

Em seguida, digite o seguinte comando no terminal para executar o script.

python del_example.py

É importante notar que não há garantia de que o método __del__ seja chamado imediatamente quando um objeto não for mais necessário. A exclusão real do objeto depende do mecanismo de coleta de lixo (garbage collection) do interpretador Python. O método __del__ é chamado quando o coletor de lixo decide remover o objeto da memória.

Resumo

Nesta série de tutoriais, exploramos os métodos mágicos do Python, também conhecidos como métodos "dunder" (métodos de sublinhado duplo), que permitem definir comportamentos personalizados para seus objetos em várias situações.

Ao dominar esses métodos mágicos, você pode criar classes e objetos Python mais poderosos e personalizáveis. Compreender e implementar esses métodos permitirá que você escreva um código mais eficiente, limpo e "Pythonic", tornando seus programas mais robustos e fáceis de manter.