Original Translation
27
Another advantage is that strings in Python are considered as "elemental" as numbers. No amount of activity will change the value 8 to anything else, and in Python, no amount of activity will change the string "eight" to anything else.
Un autre avantage est que les chaînes en Python sont considérées aussi "élémentaires" que les nombres. Aucun processus ne changera la valeur du nombre 8 en autre chose, et en Python, aucun processus changera la chaîne de caractère "huit" en autre chose.
28
Why must 'self' be used explicitly in method definitions and calls?
Pourquoi "self" doit-il être explicitement utilisé dans les définitions et les appels de méthode ?
29
The idea was borrowed from Modula-3. It turns out to be very useful, for a variety of reasons.
L'idée a été empruntée à Modula-3. Il s'avère être très utile, pour diverses raisons.
30
First, it's more obvious that you are using a method or instance attribute instead of a local variable. Reading ``self.x`` or ``self.meth()`` makes it absolutely clear that an instance variable or method is used even if you don't know the class definition by heart. In C++, you can sort of tell by the lack of a local variable declaration (assuming globals are rare or easily recognizable) -- but in Python, there are no local variable declarations, so you'd have to look up the class definition to be sure. Some C++ and Java coding standards call for instance attributes to have an ``m_`` prefix, so this explicitness is still useful in those languages, too.
Tout d'abord, il est plus évident d'utiliser une méthode ou un attribut d'instance par exemple au lieu d'une variable locale. Lire ``self.x`` ou ``self.meth()`` est sans ambiguité sur le fait que c'est une variable d'instance ou une méthode qui est utilisée, même si vous ne connaissez pas la définition de classe par cœur. En C++, vous pouvez les reconnaitre par l'absence d'une déclaration de variable locale (en supposant que les variables globales sont rares ou facilement reconnaissables) - mais en Python, il n'y a pas de déclarations de variables locales, de sorte que vous devez chercher la définition de classe pour être sûr. Certaines normes de codages C++ et Java préfixent les attributs d'instance par ``m_``. Cette syntaxe explicite est ainsi utile également pour ces langages.
31
Second, it means that no special syntax is necessary if you want to explicitly reference or call the method from a particular class. In C++, if you want to use a method from a base class which is overridden in a derived class, you have to use the ``::`` operator -- in Python you can write ``baseclass.methodname(self, <argument list>)``. This is particularly useful for :meth:`__init__` methods, and in general in cases where a derived class method wants to extend the base class method of the same name and thus has to call the base class method somehow.
é à è ù â ê î ô û ë ï ü ÿ ä ö ü ç ñ
32
Finally, for instance variables it solves a syntactic problem with assignment: since local variables in Python are (by definition!) those variables to which a value is assigned in a function body (and that aren't explicitly declared global), there has to be some way to tell the interpreter that an assignment was meant to assign to an instance variable instead of to a local variable, and it should preferably be syntactic (for efficiency reasons). C++ does this through declarations, but Python doesn't have declarations and it would be a pity having to introduce them just for this purpose. Using the explicit ``self.var`` solves this nicely. Similarly, for using instance variables, having to write ``self.var`` means that references to unqualified names inside a method don't have to search the instance's directories. To put it another way, local variables and instance variables live in two different namespaces, and you need to tell Python which namespace to use.
Enfin, pour des variables d'instance, ça résout un problème syntactique pour l'assignation : puisque les variables locales en Python sont (par définition !) ces variables auxquelles les valeurs sont assignées dans le corps d'une fonction (et n'étant pas déclarées explicitement globales), il doit y avoir un moyen de dire à l'interpréteur qu'une assignation est censée assigner une variable d'instance plutôt qu'une variable locale, et doit de préférence être syntactique (pour des raisons d'efficacité). C++ fait ça au travers de déclarations, mais Python n'a pas de déclarations et ça serait dommage d'avoir à les introduire juste pour cette raison. Utiliser explicitement ``self.var`` résout ça avec élégance. Pareillement, pour utiliser des variables d'instance, avoir à écrire ``self.var`` signifie que les références vers des noms non-qualifiés au sein d'une méthode n'ont pas à être cherchés dans l'annuaire d'instances. En d'autres termes, les variables locales et les variables d'instance vivent dans deux différents espaces de noms, et vous devez dire à Python quel espace de noms utiliser.
33
Why can't I use an assignment in an expression?
Pourquoi ne puis-je pas utiliser d'assignation dans une expression ?
34
Many people used to C or Perl complain that they want to use this C idiom:
De nombreuses personnes habituées à C ou Perl se plaignent de vouloir utiliser cet idiome C :
35
while (line = readline(f)) { // do something with line }
while (line = readline(f)) { // faire quelque chose avec line }
36
where in Python you're forced to write this::
où en Python vous êtes forcé à écrire ceci ::