Introdução
Neste tutorial, abordaremos os métodos mágicos de sequência em Python. Esses métodos permitem que você personalize o comportamento de suas próprias classes quando usadas em diferentes operações, como obter o comprimento de um objeto, acessar itens, fatiar (slicing) e iteração.
Comprimento e Contenção
Os métodos de comprimento e contenção são métodos especiais em Python que permitem que objetos definam seu comportamento quando usados com funções ou operadores embutidos, como len(), in e not in.
Vamos começar com um objeto simples. Em sequence.py, crie uma classe chamada MySequence que possui um atributo data.
class MySequence:
def __init__(self, data: list):
"""Inicializa um novo objeto MySequence com os dados fornecidos."""
self.data = data
__len__
O método mágico __len__ é usado para definir o comportamento da função len() quando aplicada a instâncias da sua classe.
## ... (código anterior em sequence.py)
def __len__(self) -> int:
"""Retorna o comprimento da sequência."""
return len(self.data)
__contains__
O método mágico __contains__ é usado para definir o comportamento dos operadores in e not in quando aplicados a instâncias da sua classe.
## ... (código anterior em sequence.py)
def __contains__(self, item: object) -> bool:
"""Verifica se a sequência contém o item fornecido."""
return item in self.data
Exemplo: Usando os Métodos de Comprimento e Contenção
Agora que definimos os métodos de comprimento e contenção para nossa classe MySequence, vamos ver como eles funcionam em length_containment_example.py:
from sequence import MySequence
## Cria um objeto MySequence
my_seq = MySequence([1, 2, 3, 4, 5])
## Testa o método mágico __len__
print(len(my_seq)) ## Saída: 5
## Testa o método mágico __contains__
print(3 in my_seq) ## Saída: True
print(3 not in my_seq) ## Saída: False
print(10 in my_seq) ## Saída: False
Em seguida, digite o seguinte comando no terminal para executar o script.
python length_containment_example.py
Acesso a Itens
Os métodos de acesso a itens são métodos especiais em Python que permitem que objetos definam seu comportamento quando acessados usando a notação de colchetes [].
__getitem__
O método mágico __getitem__ é usado para definir o comportamento da notação de colchetes para acessar itens em instâncias da sua classe.
## ... (código anterior em sequence.py)
def __getitem__(self, index: int) -> object:
"""Retorna o item no índice fornecido."""
return self.data[index]
__setitem__
O método mágico __setitem__ é usado para definir o comportamento da notação de colchetes para definir itens em instâncias da sua classe.
## ... (código anterior em sequence.py)
def __setitem__(self, index: int, value: object) -> None:
"""Define o item no índice fornecido para o valor fornecido."""
self.data[index] = value
__delitem__
O método mágico __delitem__ é usado para definir o comportamento da palavra-chave del quando aplicada a instâncias da sua classe.
## ... (código anterior em sequence.py)
def __delitem__(self, index: int) -> None:
"""Remove o item no índice fornecido."""
del self.data[index]
Exemplo: Usando os Métodos de Acesso a Itens
Agora que definimos os métodos de acesso a itens para nossa classe MySequence, vamos ver como eles funcionam em item_access_example.py:
from sequence import MySequence
## Cria um objeto MySequence
my_seq = MySequence([1, 2, 3, 4, 5])
## Testa o método mágico __getitem__
print(my_seq[2]) ## Saída: 3
## Testa o método mágico __setitem__
my_seq[2] = 9
print(my_seq[2]) ## Saída: 9
## Testa o método mágico __delitem__
del my_seq[2]
print(len(my_seq)) ## Saída: 4
print(my_seq.data) ## Saída: [1, 2, 4, 5]
Em seguida, digite o seguinte comando no terminal para executar o script.
python item_access_example.py
Iteração
Os métodos de iteração são métodos especiais em Python que permitem que objetos definam seu comportamento quando usados com protocolos de iteração.
__iter__
O método mágico __iter__ é usado para definir o comportamento da função iter() e do loop for ... in ... quando aplicados a instâncias da sua classe.
## ... (código anterior em sequence.py)
def __iter__(self):
"""Retorna um iterador para a sequência."""
for item in self.data:
yield item
__reversed__
O método mágico __reversed__ é usado para definir o comportamento da função reversed() quando aplicada a instâncias da sua classe.
## ... (código anterior em sequence.py)
def __reversed__(self):
"""Retorna um iterador invertido para a sequência."""
return reversed(self.data)
Exemplo: Usando os Métodos de Iteração
Agora que definimos os métodos de iteração para nossa classe MySequence, vamos ver como eles funcionam em iteration_example.py:
from sequence import MySequence
## Cria um objeto MySequence
my_seq = MySequence([1, 2, 3, 4, 5])
## Testa o método mágico __iter__
for item in my_seq:
print(item, end=" ") ## Saída: 1 2 4 5
## Testa o método mágico __reversed__
for item in reversed(my_seq):
print(item, end=" ") ## Saída: 5 4 2 1
Em seguida, digite o seguinte comando no terminal para executar o script.
python iteration_example.py
Resumo
Com os métodos mágicos implementados, nossa classe MySequence personalizada agora se comporta de maneira semelhante aos tipos de sequência embutidos, como listas e tuplas. Agora você pode usá-la como se fosse uma sequência nativa do Python.
