Ajuste o comportamento de suas classes com o mecanismo de substituição flexível do Python.
Em Python, as classes fornecem um meio limpo de agrupar dados e funcionalidades em elementos reutilizáveis. A criação de classes personalizadas permite modelar entidades do mundo real, como usuários, produtos e funcionários.
As classes Python definem métodos mágicos que você pode personalizar para permitir moldar o comportamento de suas classes para situações únicas.
Compreendendo os métodos mágicos
Imagine métodos mágicos, também chamados de métodos dunder, como feitiços secretos ou cantos ocultos que o Python chama automaticamente quando você executa determinadas ações em um objeto.
Python fornece muitos comportamentos integrados para classes por meio de métodos de instância, estáticos e de classe. Você pode criar classes Pythone personalize-os ainda mais usando métodos mágicos.
Métodos mágicos são métodos de instância em Python que possuem dois sublinhados (__método__) antes e depois do nome do método.
Esses métodos especiais fornecem instruções ao Python sobre como lidar com objetos de uma classe. Aqui estão alguns métodos mágicos comumente usados em classes Python:
- __gt__: Este método verifica se um objeto é maior que outro.
- __iniciar__: Este método é executado quando você cria uma instância de uma classe e é principalmente para inicialização de atributos.
- __str__: retorna uma representação em string da classe que descreve o objeto.
- __repr__: Este método fornece uma saída que permite recriar o objeto usando avaliação().
- __len__: Quando você usa o len() função em um objeto, este método retorna o comprimento do objeto.
- __eq__: Este método permite a comparação entre objetos usando o duplo igual a (==) operador.
- __lt__: implementa comparação menor que (
- __adicionar__: Quando você usa a adição (+) operador em objetos, esse método executa e executa operações de adição.
- __getitem__: permite recuperar itens de um objeto usando sintaxe de índice, como objeto[chave].
Implementando Métodos Mágicos
A melhor maneira de entender os métodos mágicos é usá-los.
Representação de String de um Objeto
Você pode personalizar a representação de string de um objeto para facilitar a leitura ou processamento adicional.
classPerson:
def__init__(self, name, age):
self.name = name
self.age = age
p1 = Person('John', 25)
print(p1)
Aqui você tem um simples Pessoa aula com um __iniciar__ método mágico para inicializá-lo. Ao imprimir o p1 objeto, ele usa a representação de string padrão fornecida pelo Python.
Para personalizar a representação de string, defina o __str__ e __repr__ métodos mágicos:
classPerson:
def__init__(self, name, age, height):
self.name = name
self.age = age
self.height = heightdef__str__(self):
returnf'{self.name} is {self.age} years old'def__repr__(self):
returnf'{self.name} is {self.age} years old'
p1 = Person('John', 25, 78)
print(p1)
Agora você tem uma representação de string mais legível e abrangente do p1 objeto:
Propriedade de comprimento de um objeto
Imagine que, quando você liga para o len() método de um objeto Person, você deseja sua altura. Implementar o __len__ método mágico para o Pessoa aula:
classPerson:
def__init__(self, name, age, height):
self.name = name
self.age = age
self.height = heightdef__str__(self):
returnf'{self.name} is {self.age} years old'def__repr__(self):
returnf'{self.name} is {self.age} years old'def__len__(self):
return self.height
p2 = Person('Issac', 25, 89)
print(len(p2))
O __len__ método mágico retorna o atributo de altura de um Pessoa instância. Quando Você ligar lento (p2), ele chamará o __len__ método mágico automaticamente que retorna a altura do p2 objeto.
Lidando com comparação entre objetos
Se você precisar comparar objetos de uma classe com base em determinadas propriedades da classe. Você pode definir __eq__ método mágico e implemente sua lógica de comparação.
classPerson:def__init__(self, name, age, height):
self.name = name
self.age = age
self.height = heightdef__str__(self):
returnf'{self.name} is {self.age} years old'def__repr__(self):
returnf'{self.name} is {self.age} years old'def__len__(self):
return self.heightdef__eq__(self, other):
return self.name == other.name and self.age == other.agep1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)
O __eq__ método compara o nome e idade atributos dos dois Pessoas objetos para determinar a igualdade.
O duplo igual a (==) o operador usa esse método para verificar a igualdade em vez de comparar identidades. Então dois Pessoa as instâncias serão iguais se tiverem atributos de nome e idade correspondentes. Isso permite substituir o comportamento padrão de verificação de igualdade para sua classe personalizada.
Ao implementar esses métodos mágicos, você pode definir um comportamento personalizado que será consistente com os recursos integrados do Python.
Métodos Mágicos Avançados
Aqui estão alguns exemplos avançados de uso de métodos mágicos para personalizar classes.
Fazendo as classes agirem como contêineres
Usando métodos mágicos você pode definir classes que se comportam como contêineres. Você pode usar contêineres, como tuplas, para armazenar coleções de elementos de dados. Eles fornecem vários métodos para manipular, acessar e iterar através dos elementos contidos.
classPerson:
def__init__(self):
self.data = []def__len__(self):
return len(self.data)def__getitem__(self, index):
return self.data[index]def__setitem__(self, index, value):
self.data[index] = valuedef__delitem__(self, index):
del self.data[index]p1 = Person()
p1.data = [10, 2, 7]
print(len(p1)) # 3
p1[0] = 5
print(p1[0]) # 5
Agora um objeto Person pode se comportar como um contêiner:
Personalizando o acesso a atributos
Usando o __getattr__ método mágico você pode personalizar a forma como os atributos do Pessoa classe estão sendo acessadas com base em certas condições.
classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40
O __getattr__ O método será executado quando você tentar acessar um atributo que não existe diretamente no objeto. Neste caso, verifica se o nome do atributo é idade e retorna 40.
Para qualquer outro nome de atributo, ele gera um AtributoError com uma mensagem correspondente.
Fazendo com que as classes se comportem como chamáveis
O __chamar__ O método permite tratar uma instância da classe como um objeto que pode ser chamado (ou seja, uma função).
classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5
Quando você cria uma instância de Adicionador e então chame-o com argumentos, o __chamar__ O método é executado e realiza a adição antes de retornar o resultado.
Sobrecarga do Operador
Usando métodos mágicos você pode realizar a sobrecarga do operador. A sobrecarga de operadores permite definir comportamentos personalizados para operadores integrados quando usados com instâncias de suas próprias classes. Aqui está um exemplo comum que explica a sobrecarga do operador.
classVector:
def__init__(self, x, y):
self.x = x
self.y = ydef__add__(self, other):
if isinstance(other, Vector):
new_x = self.x + other.x
new_y = self.y + other.y
return Vector(new_x, new_y)
else:
raise TypeError("Unsupported operand type for +")def__str__(self):
returnf"({self.x}, {self.y})"# Creating two Vector instances
v1 = Vector(2, 3)
v2 = Vector(1, 4)# Adding two Vector instances using the + operator
v3 = v1 + v2
# Printing the result
print(v3) # Output: (3, 7)
O resultado é um novo vetor:
O Vetor classe define o __adicionar__ método, que é executado quando você usa o método + operador entre duas instâncias da classe. O método adiciona os componentes correspondentes dos dois vetores e retorna um novo Vetor instância com o resultado.
Aqui você viu métodos mágicos fundamentais que podem ser implementados para personalizar o comportamento da sua classe. Python tem muito mais métodos mágicos que oferecem mais flexibilidade na criação de classes. Consulte o documentação oficial para obter uma lista completa.
Programação Orientada a Objetos em Python
Os métodos mágicos em Python fornecem maneiras poderosas de personalizar e aprimorar o comportamento das classes. Os métodos mágicos acompanham o conceito de programação orientada a objetos (OOP) em Python. Portanto, é importante entender o conceito de OOP ao tentar usar métodos mágicos.