DifficileChoix unique

Question d'entraînement PCAP

Un développeur Python implémente une classe qui doit se comporter comme une séquence et prendre en charge l'indexation. Quelle paire de méthodes spéciales doit être définie pour y parvenir ?

Choisissez la meilleure réponse.

Bonne réponse

  • D__getitem__ et __len__

Explication

Pour qu'une classe se comporte comme une séquence et prenne en charge l'indexation (par exemple, obj[0]), Python requiert la méthode __getitem__ pour récupérer les éléments par clé. De plus, la méthode __len__ est nécessaire pour définir la longueur de la séquence, qui est utilisée par les fonctions intégrées telles que len() et fait partie du protocole de séquence. Ensemble, ces deux méthodes satisfont les exigences minimales pour un objet de type séquence prenant en charge l'indexation.

Pourquoi chaque option est juste ou fausse

A

Fausse

__getitem__ et __contains__

L'ajout de `__contains__` active l'opérateur `in` mais ne fournit pas d'accès positionnel ; le protocole de séquence requiert au minimum `__len__` pour `len()` et `__getitem__` pour l'indexation. Un conteneur peut se comporter entièrement comme une séquence en lecture sans aucune surcharge de appartenance, car `__contains__` est optionnel et se rabat sur un parcours linéaire en son absence. Remplacer `__len__` par `__contains__` empêche l'objet de signaler sa taille ou de prendre en charge l'accès basé sur les indices, ce qui le fait échouer au contrat de séquence principal.

B

Fausse

__setitem__ et __delitem__

`__setitem__` et `__delitem__` gèrent uniquement les opérations de mutation (`obj[i] = value` et `del obj[i]`), ils appartiennent donc à l'interface de séquence mutable, et non au protocole de séquence en lecture seule. Sans `__getitem__` et `__len__`, l'objet n'a aucun moyen de récupérer une valeur par position ou de signaler une longueur, rendant même l'indexation de base impossible. L'ajout de méthodes de mutation ne peut pas se substituer aux deux dunders d'accès en lecture requis pour le comportement de séquence.

C

Fausse

__iter__ et __next__

`__iter__` et `__next__` créent un protocole d'itérateur qui prend en charge les boucles `for` et `next()`, mais ils ne font pas fonctionner la souscription par entiers ; `obj[i]` est géré par `__getitem__`, et non par l'itération. En fait, si `__getitem__` est présent, Python peut itérer en l'appelant avec des indices croissants jusqu'à `IndexError`, de sorte que `__iter__` n'est même pas requis pour l'itération. L'absence de `__len__` et `__getitem__` signifie que l'objet ne peut pas être mesuré avec `len()` ni indexé positionnellement, ce n'est donc pas une séquence.

D

Juste

__getitem__ et __len__

Selon le modèle de données de Python, une séquence est définie principalement par la présence d'une méthode `__len__` et d'une méthode `__getitem__` qui accepte des indices entiers (et éventuellement des tranches). Ensemble, elles confèrent à l'objet une longueur finie, prennent en charge l'indexation `obj[i]` et activent implicitement l'itération via le repli `__getitem__` de style ancien. En plus de ces deux méthodes, l'ABC `collections.abc.Sequence` intègre automatiquement `__contains__`, `__iter__`, `__reversed__`, `index` et `count`, ce qui montre à quel point le comportement est dérivé de ces deux seules méthodes.

Pour aller plus loin

Le protocole de séquence est un exemple pratique du typage implicite (duck-typing) de Python : un objet est « de type séquence » s'il implémente les bons crochets, indépendamment de l'héritage. Les crochets minimaux sont `__len__` et `__getitem__`, car `len()` appelle le premier et l'opérateur d'indice `obj[i]` appelle le second. Un détail d'implémentation subtil est que l'itération de style ancien utilise `__getitem__` en l'appelant aux indices 0, 1, 2, ... jusqu'à ce que `IndexError` soit levé, ce qui signifie qu'un `__getitem__` défectueux qui ne lève jamais d'exception peut provoquer une boucle infinie. Ce mécanisme de repli est la raison pour laquelle `__iter__` et `__next__` sont préférables pour les itérations réelles, mais ils ne font pas partie du contrat de séquence. De manière réaliste, tout conteneur personnalisé qui s'intègre à des outils comme `random.choice`, `reversed` ou `enumerate` doit fournir `__getitem__` et `__len__` afin que le reste de la bibliothèque standard puisse déduire le comportement de séquence.

À propos de ces questions d'entraînement

Cette question fait partie des questions d'entraînement PCAP originales de Courseiva, rédigées pour apprendre et jamais copiées d'examens réels ou de dumps.

Traduite de l'original anglais avec l'IA et vérifiée pour le sens. Les codes d'examen, les commandes et les noms de produits sont conservés tels qu'ils apparaissent à l'examen.