|
Original |
Translation |
|
57
|
When a class definition is entered, a new namespace is created, and used as the local scope --- thus, all assignments to local variables go into this new namespace. In particular, function definitions bind the name of the new function here.
|
Quand une classe est définie, un nouvel espace de noms est créé et utilisé comme portée locale --- Ainsi, toutes les affectations de variables locales entrent dans ce nouvel espace de noms. En particulier, les définitions de fonctions y lient le nom de la nouvelle fonction.
|
|
58
|
When a class definition is left normally (via the end), a *class object* is created. This is basically a wrapper around the contents of the namespace created by the class definition; we'll learn more about class objects in the next section. The original local scope (the one in effect just before the class definition was entered) is reinstated, and the class object is bound here to the class name given in the class definition header (:class:`ClassName` in the example).
|
A la fin de la définition d'une classe, un *objet classe* est créé. C'est, pour simplifier, une encapsulation du contenu de de l'espace de nom créé par la définition de classe. Nous reparlerons des objets classes dans la prochaine section. La portée locale initiale (celle qui prévaut avant le début de la définition de la classe) est réinstanciée, et l'objet de classe est lié ici au nom de classe donné dans l'en-tête de définition de classe (:class:`NomDeLaClasse` dans l'exemple).
|
|
59
|
|
|
|
60
|
Class objects support two kinds of operations: attribute references and instantiation.
|
Les objets classe prennent en charge deux types d'opérations: des références à des attributs et l'instanciation.
|
|
61
|
|
62
|
class MyClass: """A simple example class""" i = 12345 def f(self): return 'hello world'
|
class MaClasse: """Une simple classe d'exemple""" i = 12345 def f(self): return 'hello world'
|
|
63
|
then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, returning an integer and a function object, respectively. Class attributes can also be assigned to, so you can change the value of ``MyClass.i`` by assignment. :attr:`__doc__` is also a valid attribute, returning the docstring belonging to the class: ``"A simple example class"``.
|
alors ``MaClasse.i`` et ``MaClasse.f`` sont des références valides à des attributs, renvoyant respectivement un entier et un objet fonction. Les attributs de classes peuvent également être affectés, de sorte que vous pouvez modifier la valeur de ``MaClasse.i`` par affectation. :attr:`__doc__` est aussi un attribut valide, renvoyant la docstring appartenant à la classe : ``"Une simple classe d'exemple"``.
|
|
64
|
Class *instantiation* uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example (assuming the above class)::
|
L'*instanciation* de classes utilise la notation des fonctions. Considérez simplement que l'objet classe est une fonction sans paramètre qui renvoie une nouvelle instance de la classe. Par exemple (en considérant la classe définie ci-dessus) ::
|
|
65
|
|
|
|
66
|
creates a new *instance* of the class and assigns this object to the local variable ``x``.
|
crée une nouvelle *instance* de la classe et affecte cet objet à la variable locale ``x``.
|
checking