Méthodes magiques de séquence

Introduction

Dans ce tutoriel, nous allons aborder les méthodes magiques de séquence en Python. Ces méthodes vous permettent de personnaliser le comportement de vos propres classes lorsqu'elles sont utilisées dans différentes opérations, telles que la récupération de la longueur d'un objet, l'accès aux éléments, le découpage et l'itération.

Skills Graph

Longueur et appartenance

Les méthodes de longueur et d'appartenance sont des méthodes spéciales en Python qui permettent aux objets de définir leur comportement lorsqu'ils sont utilisés avec des fonctions ou des opérateurs intégrés tels que len(), in et not in.

Commencez par un objet simple. Dans sequence.py, créez une classe nommée MySequence qui a un attribut data.

class MySequence:
    def __init__(self, data: list):
        """Initialise un nouvel objet MySequence avec les données données."""
        self.data = data

__len__

La méthode magique __len__ est utilisée pour définir le comportement de la fonction len() lorsqu'elle est appliquée à des instances de votre classe.

    #... (code précédent dans sequence.py)

    def __len__(self) -> int:
        """Renvoie la longueur de la séquence."""
        return len(self.data)

__contains__

La méthode magique __contains__ est utilisée pour définir le comportement des opérateurs in et not in lorsqu'ils sont appliqués à des instances de votre classe.

    #... (code précédent dans sequence.py)

    def __contains__(self, item: object) -> bool:
        """Vérifie si la séquence contient l'élément donné."""
        return item in self.data

Exemple : Utilisation des méthodes de longueur et d'appartenance

Maintenant que nous avons défini les méthodes de longueur et d'appartenance pour notre classe MySequence, voyons comment elles fonctionnent dans length_containment_example.py :

from sequence import MySequence

## Crée un objet MySequence
my_seq = MySequence([1, 2, 3, 4, 5])

## Teste la méthode magique __len__
print(len(my_seq))  ## Sortie : 5

## Teste la méthode magique __contains__
print(3 in my_seq)  ## Sortie : True
print(3 not in my_seq)  ## Sortie : False
print(10 in my_seq)  ## Sortie : False

Ensuite, tapez la commande suivante dans le terminal pour exécuter le script.

python length_containment_example.py

Accès aux éléments

Les méthodes d'accès aux éléments sont des méthodes spéciales en Python qui permettent aux objets de définir leur comportement lorsqu'ils sont accessibles à l'aide de la notation entre crochets [].

__getitem__

La méthode magique __getitem__ est utilisée pour définir le comportement de la notation entre crochets pour accéder aux éléments dans les instances de votre classe.

    #... (code précédent dans sequence.py)

    def __getitem__(self, index: int) -> object:
        """Renvoie l'élément à l'index donné."""
        return self.data[index]

__setitem__

La méthode magique __setitem__ est utilisée pour définir le comportement de la notation entre crochets pour définir des éléments dans les instances de votre classe.

    #... (code précédent dans sequence.py)

    def __setitem__(self, index: int, value: object) -> None:
        """Définit l'élément à l'index donné sur la valeur donnée."""
        self.data[index] = value

__delitem__

La méthode magique __delitem__ est utilisée pour définir le comportement du mot clé del lorsqu'il est appliqué à des instances de votre classe.

    #... (code précédent dans sequence.py)

    def __delitem__(self, index: int) -> None:
        """Supprime l'élément à l'index donné."""
        del self.data[index]

Exemple : Utilisation des méthodes d'accès aux éléments

Maintenant que nous avons défini les méthodes d'accès aux éléments pour notre classe MySequence, voyons comment elles fonctionnent dans item_access_example.py :

from sequence import MySequence

## Crée un objet MySequence
my_seq = MySequence([1, 2, 3, 4, 5])

## Teste la méthode magique __getitem__
print(my_seq[2])  ## Sortie : 3

## Teste la méthode magique __setitem__
my_seq[2] = 9
print(my_seq[2])  ## Sortie : 9

## Teste la méthode magique __delitem__
del my_seq[2]
print(len(my_seq))  ## Sortie : 4
print(my_seq.data)  ## Sortie : [1, 2, 4, 5]

Ensuite, tapez la commande suivante dans le terminal pour exécuter le script.

python item_access_example.py

Itération

Les méthodes d'itération sont des méthodes spéciales en Python qui permettent aux objets de définir leur comportement lorsqu'ils sont utilisés avec les protocoles d'itération.

__iter__

La méthode magique __iter__ est utilisée pour définir le comportement de la fonction iter() et de la boucle for... in... lorsqu'elles sont appliquées à des instances de votre classe.

    #... (code précédent dans sequence.py)

    def __iter__(self):
        """Renvoie un itérateur pour la séquence."""
        for item in self.data:
            yield item

__reversed__

La méthode magique __reversed__ est utilisée pour définir le comportement de la fonction reversed() lorsqu'elle est appliquée à des instances de votre classe.

    #... (code précédent dans sequence.py)

    def __reversed__(self):
        """Renvoie un itérateur inversé pour la séquence."""
        return reversed(self.data)

Exemple : Utilisation des méthodes d'itération

Maintenant que nous avons défini les méthodes d'itération pour notre classe MySequence, voyons comment elles fonctionnent dans iteration_example.py :

from sequence import MySequence

## Crée un objet MySequence
my_seq = MySequence([1, 2, 3, 4, 5])

## Teste la méthode magique __iter__
for item in my_seq:
    print(item, end=" ")  ## Sortie : 1 2 4 5

## Teste la méthode magique __reversed__
for item in reversed(my_seq):
    print(item, end=" ")  ## Sortie : 5 4 2 1

Ensuite, tapez la commande suivante dans le terminal pour exécuter le script.

python iteration_example.py

Sommaire

Avec les méthodes magiques implémentées, notre classe personnalisée MySequence se comporte désormais de manière similaire aux types de séquence intégrés tels que les listes et les tuples. Vous pouvez désormais l'utiliser comme si c'était une séquence Python native.