|
Original |
Translation |
|
43
|
There's an alternative way of spelling this that seems attractive but is generally less robust than the "while True" solution::
|
Il y a une manière alternative de faire ça qui semble attrayante mais elle est généralement moins robuste que la solution ``while True`` ::
|
|
44
|
line = f.readline() while line: ... # do something with line... line = f.readline()
|
line = f.readline() while line: ... # faire quelque chose avec line... line = f.readline()
|
|
45
|
The problem with this is that if you change your mind about exactly how you get the next line (e.g. you want to change it into ``sys.stdin.readline()``) you have to remember to change two places in your program -- the second occurrence is hidden at the bottom of the loop.
|
Le problème avec ceci est que si vous changez d'avis sur la manière dont vous allez récupérer la prochaine ligne (ex : vous voulez changer en ``sys.stdin.readline()``) vous devez vous souvenir de le changer à deux endroits dans votre programme -- la deuxième occurrence est cachée en bas de la boucle.
|
|
46
|
The best approach is to use iterators, making it possible to loop through objects using the ``for`` statement. For example, in the current version of Python file objects support the iterator protocol, so you can now write simply::
|
La meilleur approche est d'utiliser les itérateurs, rendant possible de boucler au travers d'objets en utilisant la déclaration ``for``. Par exemple, dans la version actuelle de Python, les fichiers objets supportent le protocole d'itérateur, vous pouvez alors simplement écrire ::
|
|
47
|
for line in f: ... # do something with line...
|
for line in f: ... # faire quelque chose avec line...
|
|
48
|
|
49
|
The major reason is history. Functions were used for those operations that were generic for a group of types and which were intended to work even for objects that didn't have methods at all (e.g. tuples). It is also convenient to have a function that can readily be applied to an amorphous collection of objects when you use the functional features of Python (``map()``, ``apply()`` et al).
|
La raison principale est historique. Les fonctions étaient utilisées pour ces opérations qui étaient génériques pour un groupe de types et qui étaient censés fonctionner même pour les objets qui n'avaient pas de méthodes du tout (ex : tuples). C'est aussi pratique d'avoir une fonction qui s'apprête bien à une collection amorphe d'objets lorsque vous utiliser les fonctionnalités fonctionnelles de Python (``map()``, ``apply()`` et autres).
|
|
50
|
In fact, implementing ``len()``, ``max()``, ``min()`` as a built-in function is actually less code than implementing them as methods for each type. One can quibble about individual cases but it's a part of Python, and it's too late to make such fundamental changes now. The functions have to remain to avoid massive code breakage.
|
En fait, implémenter ``len()``, ``max()``, ``min()`` en tant que fonction intégrée produit moins de code que de les implémenter en tant que méthode pour chaque type. Certains peuvent rouspéter pour des cas individuels mais ça fait partie de Python et il est trop tard pour faire des changements si fondamentaux maintenant. Ces fonctions doivent rester pour éviter la casse massive de code.
|
|
51
|
For string operations, Python has moved from external functions (the ``string`` module) to methods. However, ``len()`` is still a function.
|
Pour les opérations de chaînes, Python a déplacé les fonctions externes (le module ``string``) vers des méthodes. Cependant, ``len()`` est toujours une fonction.
|
|
52
|
Why is join() a string method instead of a list or tuple method?
|
Pourquoi join() est une méthode de chaîne plutôt qu'une de liste ou de tuple ?
|