|
Original |
Translation |
|
69
|
When a class defines an :meth:`__init__` method, class instantiation automatically invokes :meth:`__init__` for the newly-created class instance. So in this example, a new, initialized instance can be obtained by::
|
Quand une classe définit une méthode :meth:`__init__`, l'instanciation de la classe appelle automatiquement :meth:`__init__` pour la nouvelle instance de la classe. Donc, dans cet exemple, l'initialisation d'une nouvelle instance peut être obtenue par ::
|
|
70
|
Of course, the :meth:`__init__` method may have arguments for greater flexibility. In that case, arguments given to the class instantiation operator are passed on to :meth:`__init__`. For example, ::
|
Bien sûr, la méthode meth::`__init__` peut avoir des arguments pour une plus grande flexibilité. Dans ce cas, les arguments donnés à l'opérateur d'instanciation de classe sont transmis à :meth:`__init__`. Par exemple, ::
|
|
71
|
>>> class Complex: ... def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
|
>>> class Complexe: ... def __init__(self, partie_reelle, partie_imaginaire): ... self.r = partie_reelle ... self.i = partie_imaginaire ... >>> x = Complexe(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
|
|
72
|
|
|
|
73
|
|
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
|
|
|