|
Original |
Translation |
|
87
|
|
|
|
88
|
Data attributes override method attributes with the same name; to avoid accidental name conflicts, which may cause hard-to-find bugs in large programs, it is wise to use some kind of convention that minimizes the chance of conflicts. Possible conventions include capitalizing method names, prefixing data attribute names with a small unique string (perhaps just an underscore), or using verbs for methods and nouns for data attributes.
|
Les attributs de données surchargent les méthodes avec le même nom; pour éviter des conflits de nommage, qui peuvent causer des bugs difficiles à trouver dans de grands programmes, il est sage d'adopter certaines conventions qui minimisent les risques de conflits. Les conventions possibles comprennent la mise en majuscule des noms de méthodes, le préfixe des noms d'attributs de données par une chaîne courte et unique (parfois juste la caractère souligné), ou l'utilisation de verbes pour les méthodes et de noms pour les attributs de données.
|
|
89
|
Data attributes may be referenced by methods as well as by ordinary users ("clients") of an object. In other words, classes are not usable to implement pure abstract data types. In fact, nothing in Python makes it possible to enforce data hiding --- it is all based upon convention. (On the other hand, the Python implementation, written in C, can completely hide implementation details and control access to an object if necessary; this can be used by extensions to Python written in C.)
|
Les attributs de données peuvent être référencés par des méthodes comme par des utilisateurs ordinaires ("clients") d'un objet. En d'autres termes, les classes ne sont pas utilisables pour implémenter des types de données purement abstraits. En fait, rien en Python ne rend possible d'imposer de masquer des données --- tout est basé sur des conventions. (D'un autre coté, l'implémentation Python, écrite en C, peut complètement masquer les détails d'implémentation et contrôler l'accès à un objet si nécessaire ; ceci peut être utilisé par des extensions de Python écrites en C.)
|
|
90
|
Clients should use data attributes with care --- clients may mess up invariants maintained by the methods by stamping on their data attributes. Note that clients may add data attributes of their own to an instance object without affecting the validity of the methods, as long as name conflicts are avoided --- again, a naming convention can save a lot of headaches here.
|
Les clients doivent utiliser les attributs de données avec précaution --- ils pourraient mettre le désordre dans les invariants gérés par les méthodes avec leurs propres valeurs d'attributs. Remarquez que les clients peuvent ajouter leurs propres attributs de données à une instance d'objet sans altérer la validité des méthodes, pour autant que les noms n'entrent pas en conflit --- aussi, adopter une convention de nommage peut éviter bien des problèmes.
|
|
91
|
|
92
|
Often, the first argument of a method is called ``self``. This is nothing more than a convention: the name ``self`` has absolutely no special meaning to Python. Note, however, that by not following the convention your code may be less readable to other Python programmers, and it is also conceivable that a *class browser* program might be written that relies upon such a convention.
|
Souvent, le premier argument d'une méthode est nommé ``self``. Ce n'est qu'une convention : le nom ``self`` n'a aucune signification particulière en Python. Notez cependant que si vous ne suivez pas cette convention, votre code risque d'être moins lisible pour d'autres programmeurs Python, et il est aussi possible qu'un programme qui fasse l'introspection de classes repose sur une telle convention.
|
|
93
|
Any function object that is a class attribute defines a method for instances of that class. It is not necessary that the function definition is textually enclosed in the class definition: assigning a function object to a local variable in the class is also ok. For example::
|
Tout objet fonction qui est un attribut de classe définit une méthode pour des instances de cette classe. Il n'est pas nécessaire que le texte de définition de la fonction soit dans la définition de la classe : il est possible d'affecter un objet fonction à une variable locale de la classe. Par exemple ::
|
|
94
|
# Function defined outside the class def f1(self, x, y): return min(x, x+y) class C: f = f1 def g(self): return 'hello world' h = g
|
# Function définie à l'extérieur d'une classe def f1(self, x, y): return min(x, x+y) class C: f = f1 def g(self): return 'bonjour tout le monde' h = g
|
|
95
|
Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer to function objects, and consequently they are all methods of instances of :class:`C` --- ``h`` being exactly equivalent to ``g``. Note that this practice usually only serves to confuse the reader of a program.
|
Maintenant, ``f``, ``g`` et ``h`` sont tous des attributs des classes :class:`C` faisant référence aux fonctions objets, et par conséquent sont toutes des méthodes des instances de :class:`C` --- ``h`` est exactement identique à ``g``. Remarquez qu'en pratique, ceci ne sert qu'à embrouiller le lecteur d'un programme.
|
|
96
|
Methods may call other methods by using method attributes of the ``self`` argument::
|
Les méthodes peuvent appeler d'autres méthodes en utilisant des méthodes qui sont des attributs de l'argument ``self`` ::
|