Introduction aux objets personnalisés Python pour implémenter la fonction de découpage (exemple de code)

Le contenu de cet article est une introduction à la fonction de découpage des objets personnalisés Python (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Méthode magique : __getitem__()

Il n'est pas difficile de créer un objet personnalisé prenant en charge la syntaxe de découpage. méthode magique __getitem__(). Alors, commençons par présenter cette méthode.

Syntaxe : object.__getitem__(self, key)

Explication du document officiel : appelé pour implémenter l'évaluation de self[key]. Pour les types de séquence, le accepté les clés doivent être des entiers et des objets slice. Notez que le spécial. interprétation des indices négatifs (si la classe souhaite émuler un type de séquence) dépend de la méthode __getitem__() Si la clé est. d'un type inapproprié, TypeError peut être déclenché s'il s'agit d'une valeur ; en dehors de l'ensemble des index de la séquence (après tout événement spécial interprétation des valeurs négatives), IndexError doit être déclenché pour. types de mappage, si la clé est manquante (pas dans le conteneur), KeyError devrait être soulevé.

Une traduction résumée : La méthode __getitem__() est utilisée pour renvoyer la clé du paramètre La valeur correspondante, cette clé peut être une valeur entière ou un objet slice, et prend en charge les index négatifs si la clé n'est pas des deux types ci-dessus, elle sera lancée ; TypeError ; si l'index est hors limites, IndexError sera généré ; si un type de mappage est défini, lorsque le paramètre clé n'est pas la valeur clé de son objet, il sera généré. Erreur de clé.

2. Personnalisez la séquence pour implémenter la fonction de découpage

Ensuite, nous définissons une simple MyList et y ajoutons la fonction de découpage. (PS : à titre de démonstration uniquement, l'intégralité des autres fonctions n'est pas garantie).

class MyList():
    def __init__(self):
        self.data = []
    def append(self, item):
        self.data.append(item)
    def __getitem__(self, key):
        print("key is : " + str(key))
        return self.data[key]

l = MyList()
l.append("My")
l.append("name")
l.append("is")
l.append("Python猫")

print(l[3])
print(l[:2])
print(l['hi'])

### 输出结果：
key is : 3
Python猫
key is : slice(None, 2, None)
['My', 'name']
key is : hi
Traceback (most recent call last):
...
TypeError: list indices must be integers or slices, not str

À en juger par les résultats de sortie, la MyList personnalisée prend en charge à la fois les opérations de recherche par index et de découpage, ce qui est exactement notre objectif.

Ce qu'il faut noter en particulier, c'est que __getitem__() dans cet exemple La méthode implémentera différentes fonctions (obtiendra la valeur du bit d'index ou la valeur de la tranche) en fonction de différents types de paramètres, et gérera également les exceptions de manière appropriée, nous n'avons donc pas besoin d'écrire une logique de traitement lourde. Il existe de nombreux supports d'apprentissage sur Internet qui sont complètement trompeurs. Ils vous apprendront à distinguer différents types de paramètres, puis à écrire un gros morceau de code pour implémenter la syntaxe de recherche d'index et de découpage. Ce qui suit est un exemple d'erreur représentatif :

###略去其它代码####
def __getitem__(self, index):
    cls = type(self)
    if isinstance(index, slice):  # 如果index是个切片类型，则构造新实例
       return cls(self._components[index])
    elif isinstance(index, numbers.Integral):  # 如果index是个数，则直接返回
        return self._components[index]
    else:
        msg = "{cls.__name__} indices must be integers"
        raise TypeError(msg.format(cls=cls))

3. Dictionnaire personnalisé pour implémenter la fonction de découpage

Le découpage est une fonctionnalité du type séquence, donc dans ce qui précède. Par exemple, nous n'avons pas besoin d'écrire la logique d'implémentation spécifique du découpage. Cependant, pour les autres types d’objets personnalisés non séquentiels, vous devez implémenter vous-même la logique de découpage. Prenons l'exemple d'un dictionnaire personnalisé (PS : ceci est uniquement à titre de démonstration, et l'exhaustivité des autres fonctions n'est pas garantie) :

class MyDict():
    def __init__(self):
        self.data = {}
    def __len__(self):
        return len(self.data)
    def append(self, item):
        self.data[len(self)] = item
    def __getitem__(self, key):
        if isinstance(key, int):
            return self.data[key]
        if isinstance(key, slice):
            slicedkeys = list(self.data.keys())[key]
            return {k: self.data[k] for k in slicedkeys}
        else:
            raise TypeError

d = MyDict()
d.append("My")
d.append("name")
d.append("is")
d.append("Python猫")
print(d[2])
print(d[:2])
print(d[-4:-2])
print(d['hi'])

### 输出结果：
is
{0: 'My', 1: 'name'}
{0: 'My', 1: 'name'}
Traceback (most recent call last):
...
TypeError

Le point clé de l'exemple ci-dessus est de supprimer les valeurs clés ​​​​du dictionnaire et compiler la liste des valeurs clés​​La beauté du traitement de découpage est que vous n'avez pas à vous soucier des index hors limites et des index négatifs. Vous pouvez convertir les tranches du dictionnaire en tranches. des valeurs clés du dictionnaire, et finalement atteindre votre objectif.

4. Résumé

Résumé final : cet article présente la méthode magique __getitem__() et est utilisée pour implémenter des objets personnalisés (en prenant les types de liste et les types de dictionnaire comme exemples) de la fonction de découpage, j'espère qu'elle vous sera utile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!