La substitution de nom est utile pour permettre aux sous-classes de remplacer les méthodes sans perturber les appels de méthode dans la classe. Par exemple :
Cartographie de classe :
def __init__(auto, itérable) :
self.items_list = []
auto.__update(iterable)
mise à jour différée (automatique, itérable) :
pour la voix en itérable :
auto-articles_list_appendix(entrée)
__update = update # copie privée de la méthode originale update()
class MappingSubclass(Mapping) :
def (auto, touches, valeurs) :
# créer la mise à jour () avec une nouvelle signature
# ? but doesn't break __init__(()
pour l'entrée zippée (clés, valeurs) :
auto-articles_list_appendix(item)
Notez que l'objectif principal des règles de remplacement est de prévenir les accidents ; il est toujours possible d'accéder et de changer un nom privé de l'extérieur. Cela peut également être utile dans certaines circonstances, comme dans le cas d'un débogueur.
Notez que le code exécuté par exec() ou eval() ne considère pas le nom de classe de la classe appelante comme la classe courante. Ceci est similaire à l'effet de la déclaration globale, qui est également très limitée au code qui est compilé en octets ensemble. La même limitation s'applique à getattr(), setattr() et delattr(), tout comme l'accès direct à __dict__.
Petits objets
Il est parfois utile d'avoir un type de données qui se comporte comme l'enregistrement en Pascal ou la "structure" en C et qui est un conteneur pour certaines données. Ici, vous pouvez utiliser une définition de classe vide :
employé de la catégorie :
laissez-passer
john = Employé() # Créer un fichier employé vide
# Fill out the file
john.name ='John Doe'.
john.dept ='Salle informatique'.
salaire du client = 1000
Un morceau de code Python qui attend un certain type de données abstraites peut souvent être remplacé par une classe qui émule les méthodes de ce type de données. Par exemple, si vous avez une fonction qui formate les données d'un objet fichier, vous pouvez définir une classe avec les méthodes read() et readline() qui reçoit les données d'un tampon de chaîne et les passe en argument.
Les objets de la méthode d'instance ont aussi des attributs : m.__self__ est l'objet instance avec la méthode m() et m.__func__ est l'objet fonction correspondant de la méthode.
Les classes suivantes constituent également des exceptions
Les exceptions définies par l'utilisateur sont également indiquées par les classes. Ce mécanisme vous permet de créer des hiérarchies d'exceptions extensibles.
Il existe deux nouvelles variantes (sémantiquement) valables de la déclaration d'augmentation :
élever la classe
citer l'exemple
Dans la première variante, Class doit être une instance de type ou une classe dérivée de celui-ci et est l'abréviation de :
augmenter la classe()
La classe spécifiée dans un enregistrement, à l'exception des exceptions de capture s'il s'agit d'un cas de la même classe ou s'il en est dérivé, mais pas l'inverse - l'enregistrement sauf s'il est spécifié avec une classe dérivée ne capture pas la classe de base. Par exemple, les sorties de code B, C, D suivantes dans cet ordre :
classe B (exception) :
laissez-passer
classe C(B) :
laissez-passer
classe D(C) :
laissez-passer
pour CLS dans[B, C, D] :
Essayez-le :
béton levant()
à l'exception de D :
impression ("D")
sauf C :
impression ("C")
sauf B :
Impression ("B")
Notez que B, B, B, B, B, B, B, B est émis lorsque l'ordonnance est renversée, c'est-à-dire la première sauf B, puisque la première phrase applicable est activée sauf pour la première phrase.
Si un message d'erreur est édité sur une exception non gérée, le nom de la classe, puis un deux-points et un espace, et enfin l'instance est convertie en chaîne à l'aide de la fonction intégrée str().
Itéérateurs
En attendant, vous avez probablement remarqué que vous pouvez itérer sur la plupart des objets de conteneur en utilisant to :
pour l'élément dans[1, 2, 3] :
imprimer (élément)
pour l'élément dans (1, 2, 3) :
imprimer (élément)
pour entrer {'un':1,'deux':2} :
imprimer (touche)
pour char dans "123" :
caractères d'imprimerie (char)
pour la ligne dans open("myfile.txt") :
impression (ligne)
Ce type d'accès est clair, précis et pratique. L'utilisation d'itérateurs pénètre et unifie Python. Dans les coulisses, l'instruction pour l'instruction appelle iter() pour l'objet conteneur. La fonction retourne un objet itérateur qui définit la méthode __next__(), qui accède ensuite aux éléments du conteneur. S'il n'y a plus d'éléments, __next__(() provoque une exception StopIteration qui indique la boucle d'arrêt. Vous pouvez aussi appeler la méthode __next__((() en utilisant la fonction intégrée next(). L'exemple suivant montre comment tout fonctionne.
>>> s ='abc
>>>> iter(s) = iter(s)
# ? ? It ? ? ? It ? ? It ? ? It ?
<Générateur d'objets à 0x00A1DB50>>> 0x00A1DB50
suivant >>> suivant
'a'
suivant >>> suivant
'b'
suivant >>> suivant
'c'
suivant >>> suivant
Traceback (dernier appel du dernier appel) :
Fichier "<stdin>", ligne 1, dans ?
Suivant
StopIteration
