Métodos Mágicos de Secuencia

Introducción

En este tutorial, cubriremos los métodos mágicos de secuencia en Python. Estos métodos te permiten personalizar el comportamiento de tus propias clases cuando se usan en diferentes operaciones, como obtener la longitud de un objeto, acceder a elementos, hacer rebanadas y iterar.

Longitud y Contención

Los métodos de longitud y contención son métodos especiales en Python que permiten a los objetos definir su comportamiento cuando se usan con funciones o operadores integrados como len(), in y not in.

Comencemos con un objeto simple. En sequence.py, cree una clase llamada MySequence que tenga un atributo data.

class MySequence:
    def __init__(self, data: list):
        """Inicialice un nuevo objeto MySequence con los datos dados."""
        self.data = data

__len__

El método mágico __len__ se utiliza para definir el comportamiento de la función len() cuando se aplica a instancias de su clase.

    #... (código anterior en sequence.py)

    def __len__(self) -> int:
        """Devuelve la longitud de la secuencia."""
        return len(self.data)

__contains__

El método mágico __contains__ se utiliza para definir el comportamiento de los operadores in y not in cuando se aplican a instancias de su clase.

    #... (código anterior en sequence.py)

    def __contains__(self, item: object) -> bool:
        """Comprueba si la secuencia contiene el elemento dado."""
        return item in self.data

Ejemplo: Usando los Métodos de Longitud y Contención

Ahora que hemos definido los métodos de longitud y contención para nuestra clase MySequence, veamos cómo funcionan en length_containment_example.py:

from sequence import MySequence

## Crea un objeto MySequence
my_seq = MySequence([1, 2, 3, 4, 5])

## Prueba el método mágico __len__
print(len(my_seq))  ## Salida: 5

## Prueba el método mágico __contains__
print(3 in my_seq)  ## Salida: True
print(3 not in my_seq)  ## Salida: False
print(10 in my_seq)  ## Salida: False

Luego escriba el siguiente comando en la terminal para ejecutar el script.

python length_containment_example.py

Acceso a Elementos

Los métodos de acceso a elementos son métodos especiales en Python que permiten a los objetos definir su comportamiento cuando se accede a ellos utilizando la notación de corchetes [].

__getitem__

El método mágico __getitem__ se utiliza para definir el comportamiento de la notación de corchetes para acceder a elementos en instancias de su clase.

    #... (código anterior en sequence.py)

    def __getitem__(self, index: int) -> object:
        """Devuelve el elemento en el índice dado."""
        return self.data[index]

__setitem__

El método mágico __setitem__ se utiliza para definir el comportamiento de la notación de corchetes para establecer elementos en instancias de su clase.

    #... (código anterior en sequence.py)

    def __setitem__(self, index: int, value: object) -> None:
        """Establece el elemento en el índice dado con el valor dado."""
        self.data[index] = value

__delitem__

El método mágico __delitem__ se utiliza para definir el comportamiento de la palabra clave del cuando se aplica a instancias de su clase.

    #... (código anterior en sequence.py)

    def __delitem__(self, index: int) -> None:
        """Elimina el elemento en el índice dado."""
        del self.data[index]

Ejemplo: Usando los Métodos de Acceso a Elementos

Ahora que hemos definido los métodos de acceso a elementos para nuestra clase MySequence, veamos cómo funcionan en item_access_example.py:

from sequence import MySequence

## Crea un objeto MySequence
my_seq = MySequence([1, 2, 3, 4, 5])

## Prueba el método mágico __getitem__
print(my_seq[2])  ## Salida: 3

## Prueba el método mágico __setitem__
my_seq[2] = 9
print(my_seq[2])  ## Salida: 9

## Prueba el método mágico __delitem__
del my_seq[2]
print(len(my_seq))  ## Salida: 4
print(my_seq.data)  ## Salida: [1, 2, 4, 5]

Luego escriba el siguiente comando en la terminal para ejecutar el script.

python item_access_example.py

Iteración

Los métodos de iteración son métodos especiales en Python que permiten a los objetos definir su comportamiento cuando se usan con protocolos de iteración.

__iter__

El método mágico __iter__ se utiliza para definir el comportamiento de la función iter() y el bucle for... in... cuando se aplican a instancias de su clase.

    #... (código anterior en sequence.py)

    def __iter__(self):
        """Devuelve un iterador para la secuencia."""
        for item in self.data:
            yield item

__reversed__

El método mágico __reversed__ se utiliza para definir el comportamiento de la función reversed() cuando se aplica a instancias de su clase.

    #... (código anterior en sequence.py)

    def __reversed__(self):
        """Devuelve un iterador invertido para la secuencia."""
        return reversed(self.data)

Ejemplo: Usando los Métodos de Iteración

Ahora que hemos definido los métodos de iteración para nuestra clase MySequence, veamos cómo funcionan en iteration_example.py:

from sequence import MySequence

## Crea un objeto MySequence
my_seq = MySequence([1, 2, 3, 4, 5])

## Prueba el método mágico __iter__
for item in my_seq:
    print(item, end=" ")  ## Salida: 1 2 4 5

## Prueba el método mágico __reversed__
for item in reversed(my_seq):
    print(item, end=" ")  ## Salida: 5 4 2 1

Luego escriba el siguiente comando en la terminal para ejecutar el script.

python iteration_example.py

Resumen

Con los métodos mágicos implementados, nuestra clase personalizada MySequence ahora se comporta de manera similar a los tipos de secuencia integrados como listas y tuplas. Ahora puedes usarlo como si fuera una secuencia nativa de Python.