|
Original |
Translation |
|
74
|
*data attributes* correspond to "instance variables" in Smalltalk, and to "data members" in C++. Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to. For example, if ``x`` is the instance of :class:`MyClass` created above, the following piece of code will print the value ``16``, without leaving a trace::
|
Les *attributs données* correspondent à des "variables d'instance" en Smalltalk, et aux "membres de données" en C++. Les attributs données n'ont pas à être déclarés. Comme les variables locales, ils existent dès lors qu'ils sont attribués une première fois. Par exemple, si ``x`` est l'instance de :class:`MaClasse` créée ci-dessus, le code suivant affiche la valeur ``16 ``, sans laisser de traces ::
|
|
75
|
x.counter = 1 while x.counter < 10: x.counter = x.counter * 2 print(x.counter) del x.counter
|
x.compteur = 1 while x.compteur < 10: x.compteur = x.compteur * 2 print(x.compteur) del x.compteur
|
|
76
|
The other kind of instance attribute reference is a *method*. A method is a function that "belongs to" an object. (In Python, the term method is not unique to class instances: other object types can have methods as well. For example, list objects have methods called append, insert, remove, sort, and so on. However, in the following discussion, we'll use the term method exclusively to mean methods of class instance objects, unless explicitly stated otherwise.)
|
L'autre type de référence à un attribut d'instance est une *méthode*. Une méthode est une fonction qui "appartient à" un objet. (En Python, le terme de méthode n'est pas unique aux instances de classe: d'autres types d'objets peuvent aussi avoir des méthodes. Par exemple, les objets liste ont des méthodes appelées append, insert, remove, sort, et ainsi de suite. Toutefois, dans la discussion qui suit, sauf indication contraire, nous allons utiliser le terme de méthode exclusivement en référence à des méthodes d'objets instance de classe.)
|
|
77
|
Valid method names of an instance object depend on its class. By definition, all attributes of a class that are function objects define corresponding methods of its instances. So in our example, ``x.f`` is a valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is not, since ``MyClass.i`` is not. But ``x.f`` is not the same thing as ``MyClass.f`` --- it is a *method object*, not a function object.
|
Les noms de méthodes valides d'un objet instance dépendent de sa classe. Par définition, tous les attributs d'une classe qui sont des objets fonction définissent les méthodes correspondantes de ses instances. Donc, dans notre exemple, ``x.f`` est une méthode de référence valide, car ``MaClasse.f`` est une fonction, mais pas ``x.i`` car ``MaClasse.i`` n'en est pas une. Attention cependant, ``x.f`` n'est pas la même chose que ``MaClasse.f`` --- Il s'agit d'un *objet méthode*, pas d'un objet fonction.
|
|
78
|
|
|
|
79
|
|
80
|
|
|
|
81
|
In the :class:`MyClass` example, this will return the string ``'hello world'``. However, it is not necessary to call a method right away: ``x.f`` is a method object, and can be stored away and called at a later time. For example::
|
Dans l'exemple de la class :class! `MaClass`, cela va retourner la chaine de caractère ``hello world``. Toutefois, il n'est pas nécessaire d'appeler la méthode directement: ``x.f`` est un objet methode, il peut être gardé de coté et être appelé plus tard. Par exemple::
|
|
82
|
xf = x.f while True: print(xf())
|
xf = x.f while True: print(xf())
|
|
83
|
will continue to print ``hello world`` until the end of time.
|
va afficher ``hello world`` jusqu'à la fin des temps.
|