espoir/python-docs-fr
Fork 0
forked from AFPy/python-docs-fr
Code Pull requests Activity

relecture de faq/design.po et fuzzy (#1594)

Browse source 
* relecture de faq/design.po et fuzzy * coquilles * relecture de faq/design.po et fuzzy * coquilles * Apply suggestions from code review Début de prise en compte des remarques de @awecx. Co-authored-by: Antoine <43954001+awecx@users.noreply.github.com> Co-authored-by: Antoine <43954001+awecx@users.noreply.github.com>
This commit is contained in:
Christophe Nanteuil 2021-07-17 16:40:14 +02:00 • committed by GitHub
commit 16fd567886
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 188 additions and 183 deletions
Download patch file Download diff file Expand all files Collapse all files

371
faq/design.po
View file

@ -5,19 +5,19 @@ msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-06-22 09:58+0200\n"
"PO-Revision-Date: 2020-11-07 16:24+0100\n"
"POT-Creation-Date: 2021-03-19 16:59+0100\n"
"PO-Revision-Date: 2021-06-25 22:49+0200\n"
"Last-Translator: Mindiell <mindiell@mindiell.net>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.2.1\n"
"X-Generator: Poedit 2.4.2\n"
#: faq/design.rst:3
msgid "Design and History FAQ"
msgstr "FAQ histoire et design"
msgstr "FAQ sur l'histoire et la conception"
#: faq/design.rst:6
msgid "Contents"
@ -35,8 +35,8 @@ msgid ""
"Most people learn to love this feature after a while."
msgstr ""
"Guido van Rossum considère que l'usage de l'indentation pour regrouper les "
"blocs d'instruction est élégant et contribue énormément à la clarté globale "
"du programme Python. La plupart des gens finissent par aimer cette "
"blocs d'instruction est élégant et contribue énormément à la clarté d'un "
"programme Python ordinaire. La plupart des gens finissent par aimer cette "
"particularité au bout d'un moment."
#: faq/design.rst:17
@ -45,7 +45,7 @@ msgid ""
"grouping perceived by the parser and the human reader. Occasionally C "
"programmers will encounter a fragment of code like this::"
msgstr ""
"Comme il n'y a pas d'accolades de début/fin, il ne peut y avoir de "
"Comme il n'y a pas d'accolades de début et fin, il ne peut y avoir de "
"différence entre le bloc perçu par l'analyseur syntaxique et le lecteur "
"humain. Parfois les programmeurs C pourront trouver un morceau de code comme "
"celui-ci ::"
@ -57,10 +57,10 @@ msgid ""
"will sometimes stare at it a long time wondering as to why ``y`` is being "
"decremented even for ``x > y``."
msgstr ""
"Seule l'instruction ``x++`` sera exécutée si la condition est vraie, mais "
"l'indentation pourrait faire penser le contraire à beaucoup de gens. Mêmes "
"des développeurs C expérimentés pourront parfois rester pendant un moment à "
"se demander pourquoi ``y`` est décrémenté même si ``x > y``."
"Seule l'instruction ``x++`` est exécutée si la condition est vraie, mais "
"l'indentation conduit beaucoup de gens à penser le contraire. Mêmes des "
"développeurs C expérimentés peuvent parfois rester pendant un moment à se "
"demander pourquoi ``y`` est décrémenté même si ``x > y``."
#: faq/design.rst:31
msgid ""
@ -70,7 +70,7 @@ msgid ""
"is normal to feel somewhat uneasy when reading (or being required to write) "
"in a different one."
msgstr ""
"Comme il n'y a pas d'accolades de début/fin, Python est moins sujet aux "
"Comme il n'y a pas d'accolades de début et fin, Python est moins sujet aux "
"conflits de style de code. En C, on peut placer les accolades de nombreuses "
"façons. Après s'être habitué à lire et écrire selon un style particulier, il "
"est normal de se sentir perturbé en lisant (ou en devant écrire) avec un "
@ -86,14 +86,14 @@ msgid ""
"brackets -- the lack of declarations and the high-level data types are also "
"responsible -- but the indentation-based syntax certainly helps."
msgstr ""
"Nombre de styles de programmation utilisent des accolades de début/fin sur "
"une ligne à part. Cela rend les programmes beaucoup plus longs et fait "
"Nombre de styles de programmation utilisent des accolades de début et fin "
"sur une ligne à part. Cela rend les programmes beaucoup plus longs et fait "
"perdre une bonne partie de l'espace visible sur l'écran, empêchant un peu "
"d'avoir une vue globale du programme. Idéalement, une fonction doit être "
"visible sur un écran (environ 20 ou 30 lignes). 20 lignes de Python peuvent "
"faire beaucoup plus que 20 lignes de C. Ce n'est pas seulement dû à "
"l'absence d'accolades de début/fin -- l'absence de déclarations et la "
"présence de types de haut-niveau en sont également responsables -- mais la "
"l'absence d'accolades de début et fin — l'absence de déclarations et la "
"présence de types de haut-niveau en sont également responsables — mais la "
"syntaxe basée sur l'indentation aide sûrement."
#: faq/design.rst:48
@ -120,7 +120,7 @@ msgid ""
"Python, and much more to do with how the underlying platform handles "
"floating-point numbers."
msgstr ""
"et pensent que c'est un bogue dans Python. Ça ne l'est pas. Ceci n'a "
"et pensent que c'est un bogue dans Python. Ça n'en est pas un. Ceci n'a "
"d'ailleurs que peu à voir avec Python, mais avec la manière dont la "
"plateforme sous-jacente gère les nombres à virgule flottante."
@ -138,7 +138,7 @@ msgstr ""
"format binaire à virgule flottante avec une précision fixe (généralement 53 "
"bits). Python utilise des opérations qui proviennent du langage C qui à leur "
"tour reposent sur l'implémentation au niveau du processeur afin d'effectuer "
"des opérations en virgule flottante. Cela signifie que dans le cadre des "
"des opérations en virgule flottante. Cela signifie que, dans le cadre des "
"opérations sur les nombres à virgule flottante, Python se comporte comme "
"beaucoup de langages populaires dont C et Java."
@ -171,15 +171,16 @@ msgid ""
"digits of accuracy."
msgstr ""
"La précision typique de 53 bits des *floats* Python permet une précision de "
"15--16 décimales."
"15–16 décimales."
#: faq/design.rst:90
msgid ""
"For a fuller explanation, please see the :ref:`floating point arithmetic "
"<tut-fp-issues>` chapter in the Python tutorial."
msgstr ""
"Veuillez vous référer au chapitre sur :ref:`floating point arithmetic <tut-"
"fp-issues>` du tutoriel python pour de plus amples informations."
"Veuillez vous référer au chapitre sur :ref:`l'arithmétique en nombres à "
"virgule flottante <tut-fp-issues>` du tutoriel Python pour de plus amples "
"informations."
#: faq/design.rst:95
msgid "Why are Python strings immutable?"
@ -196,7 +197,7 @@ msgid ""
"unchanging. This is also one of the reasons for the distinction between "
"tuples and lists."
msgstr ""
"La première concerne la performance : savoir qu'une chaîne de caractères est "
"La première concerne la performance : savoir qu'une chaîne de caractères est "
"immuable signifie que l'allocation mémoire allouée lors de la création de "
"cette chaîne est fixe et figée. C'est aussi l'une des raisons pour "
"lesquelles on fait la distinction entre les *n*-uplets et les listes."
@ -209,22 +210,22 @@ msgid ""
"anything else."
msgstr ""
"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."
"« élémentaires » que les nombres. Aucun processus ne changera la valeur du "
"nombre 8 en autre chose et, en Python, aucun processus ne changera la chaîne "
"de caractères \"huit\" en autre chose."
#: faq/design.rst:112
msgid "Why must 'self' be used explicitly in method definitions and calls?"
msgstr ""
"Pourquoi \"self\" doit-il être explicitement utilisé dans les définitions et "
"les appels de méthode ?"
"Pourquoi *self* doit-il être explicitement utilisé dans les définitions et "
"les appels de méthodes ?"
#: faq/design.rst:114
msgid ""
"The idea was borrowed from Modula-3. It turns out to be very useful, for a "
"variety of reasons."
msgstr ""
"L'idée a été empruntée à Modula-3. Il s'avère être très utile, pour diverses "
"L'idée a été empruntée à Modula-3. Cela s'avère très utile, pour diverses "
"raisons."
#: faq/design.rst:117
@ -240,14 +241,14 @@ msgid ""
"``m_`` prefix, so this explicitness is still useful in those languages, too."
msgstr ""
"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 "
"d'instance par exemple au lieu d'une variable locale. Lire ``self.x`` ou "
"``self.meth()`` est sans ambiguïté 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 reconnaître par "
"l'absence d'une déclaration de variable locale (en supposant que les "
"variables globales sont rares ou facilement reconnaissables) -- mais en "
"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 "
"devriez chercher la définition de classe pour être sûr. Certaines normes de "
"programmation C++ et Java préfixent les attributs d'instance par ``m_``. "
"Cette syntaxe explicite est ainsi utile également pour ces langages."
@ -266,11 +267,11 @@ msgstr ""
"souhaitez explicitement référencer ou appeler la méthode depuis une classe "
"en particulier. En C++, si vous utilisez la méthode d'une classe de base "
"elle-même surchargée par une classe dérivée, vous devez utiliser l'opérateur "
"``::`` -- en Python vous pouvez écrire ``baseclass.methodname(self, "
"``::`` — en Python vous pouvez écrire ``ClasseDeBase.nom_methode(self, "
"<argument list>)``. C'est particulièrement utile pour les méthodes :meth:"
"`__init__`, et de manière générale dans les cas où une classe dérivée veut "
"étendre la méthode du même nom de la classe de base, devant ainsi appeler la "
"méthode de la classe de base d'une certaine manière."
"`__init__` et, de manière générale, dans les cas où une classe dérivée veut "
"étendre la méthode du même nom de la classe de base, et doit donc se "
"débrouiller pour appeler la méthode de la classe de base."
#: faq/design.rst:136
msgid ""
@ -290,8 +291,8 @@ msgid ""
"Python which namespace to use."
msgstr ""
"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 "
"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 "
@ -346,7 +347,7 @@ msgid ""
"x*a + x*b to the clumsiness of doing the same thing using a raw OO notation."
msgstr ""
"(a) Pour certaines opérations, la notation préfixe se lit mieux que celle "
"suffixe -- les opérations préfixe (et infixe !) sont une longue tradition en "
"suffixe — les opérations préfixe (et infixe !) sont une longue tradition en "
"mathématique, où on apprécie les notations qui aident visuellement le "
"mathématicien à réfléchir sur un problème. Comparez la facilité avec "
"laquelle nous réécrivons une formule comme x*(a+b) en x*a + x*b à la "
@ -364,7 +365,7 @@ msgid ""
"write() method."
msgstr ""
"(b) Quand je lis du code qui dit ``len(x)`` *je sais* qu'il demande la "
"longueur de quelque chose. Cela me dit deux choses : le résultat est un "
"longueur de quelque chose. Cela me dit deux choses : le résultat est un "
"entier, et l'argument est une sorte de conteneur. Au contraire, quand je lis "
"``x.len()``, je dois déjà savoir que x est une sorte de conteneur "
"implémentant une interface ou héritant d'une classe qui a un ``len()`` "
@ -396,8 +397,8 @@ msgstr ""
"de Python 1.6, lorsque les méthodes ont été ajoutées fournissant ainsi les "
"mêmes fonctionnalités que celles qui étaient déjà disponibles en utilisant "
"les fonctions du module string. La plupart de ces nouvelles méthodes ont été "
"largement acceptées, mais celle qui semble rendre certains programmeurs "
"inconfortables est ::"
"largement acceptées, mais celle qui semble rendre certains programmeurs mal "
"à l'aise est ::"
#: faq/design.rst:203
msgid "which gives the result::"
@ -415,11 +416,11 @@ msgid ""
"on names bound to strings there is no logical reason to make them "
"unavailable on literals."
msgstr ""
"Le premier se caractérise par les lignes suivantes : \"C'est vraiment moche "
"d'utiliser une méthode de chaîne littérale (chaîne constante)\", à laquelle "
"la réponse est qu'il se peut, mais une chaîne littérale est juste une valeur "
"fixe. Si la méthode est autorisée sur des noms liés à des chaînes, il n'y a "
"pas de raison logique à les rendre indisponibles sur des chaînes littérales."
"Le premier argument peut se résumer à : « c'est vraiment moche d'utiliser "
"une méthode de chaîne littérale (c.-à-d. constante) ». La réponse est "
"« certes, mais une chaîne littérale est une valeur comme une autre, juste "
"fixe ». Si on utilise les méthodes sur des noms de variables, il n'y a pas "
"de raison à les interdire sur des chaînes littérales."
#: faq/design.rst:215
msgid ""
@ -428,11 +429,11 @@ msgid ""
"For some reason there seems to be much less difficulty with having :meth:"
"`~str.split` as a string method, since in that case it is easy to see that ::"
msgstr ""
"La deuxième objection se réfère typiquement à : \"Je suis réellement en "
"train de dire à une séquence de joindre ses membres avec une constante de "
"chaîne\". Malheureusement, vous ne l'êtes pas. Pour quelque raison, il "
"semble être bien moins difficile d'avoir :meth:`~str.split` en tant que "
"méthode de chaîne, puisque dans ce cas il est facile de voir que ::"
"Le second consiste à se demander : « suis-je réellement en train de dire à "
"une séquence de joindre ses membres avec une constante de chaîne ? ». "
"Malheureusement, ce n'est pas ça. Allez savoir, il semble être bien moins "
"difficile de comprendre ce qui se passe avec :meth:`~str.split` en tant que "
"méthode de chaîne, puisque dans ce cas il est facile de voir que ::"
#: faq/design.rst:222
msgid ""
@ -440,8 +441,8 @@ msgid ""
"the given separator (or, by default, arbitrary runs of white space)."
msgstr ""
"est une instruction à une chaîne littérale de renvoyer les sous-chaînes "
"délimitées par le séparateur fournit (ou, par défaut, les espaces, ou "
"groupes d'espaces)."
"délimitées par le séparateur fourni (ou, par défaut, les espaces ou groupes "
"d'espaces)."
#: faq/design.rst:225
msgid ""
@ -469,10 +470,9 @@ msgid ""
"Actually catching an exception is expensive. In versions of Python prior to "
"2.0 it was common to use this idiom::"
msgstr ""
"Un bloc ``try`` / ``except`` est extrêmement efficient tant qu'aucune "
"exception ne sont levée. En effet, intercepter une exception s'avère "
"coûteux. Dans les versions de précédant Python 2.0, il était courant "
"d'utiliser cette pratique ::"
"Un bloc ``try`` … ``except`` est extrêmement efficient tant qu'aucune "
"exception n'est levée. En effet, intercepter une exception s'avère coûteux. "
"Dans les versions antérieures à Python 2.0, il était courant d'écrire ceci ::"
#: faq/design.rst:245
msgid ""
@ -548,7 +548,7 @@ msgid ""
"specific thread implementation?"
msgstr ""
"Est-il possible d'émuler des fils d'exécution dans l'interpréteur plutôt que "
"se baser sur les implémentations spécifique aux OS ?"
"se baser sur les implémentations spécifiques aux systèmes d'exploitation ?"
#: faq/design.rst:300
msgid ""
@ -557,11 +557,11 @@ msgid ""
"almost random moments. Therefore, a complete threads implementation "
"requires thread support for C."
msgstr ""
"Réponse 1 : Malheureusement, l'interpréteur pousse au moins un bloc de pile "
"Réponse 1 : malheureusement, l'interpréteur pousse au moins un bloc de pile "
"C (*stack frame*) pour chaque bloc de pile de Python. Aussi, les extensions "
"peuvent rappeler dans Python à presque n'importe quel moment. Par "
"conséquent, une implémentation complète des fils d'exécution nécessiterai un "
"support complet en C."
"conséquent, une implémentation complète des fils d'exécution nécessiterait "
"une gestion complète pour le C."
#: faq/design.rst:305
msgid ""
@ -606,14 +606,14 @@ msgstr ""
"Les fonctions sont déjà des objets de première classe en Python et peuvent "
"être déclarées dans une portée locale. L'unique avantage d'utiliser une "
"fonction lambda au lieu d'une fonction définie localement est que vous "
"n'avez nullement besoin d'un nom pour la fonction -- Mais c'est juste une "
"n'avez nullement besoin d'un nom pour la fonction — mais c'est juste une "
"variable locale à laquelle est affecté l'objet fonction (qui est exactement "
"le même type d'objet qui donne une expression lambda) !"
"le même type d'objet que celui renvoyé par une expression lambda) !"
#: faq/design.rst:326
msgid "Can Python be compiled to machine code, C or some other language?"
msgstr ""
"Python peut-il être compilé en code machine, en C ou dans un autre langage ?"
"Python peut-il être compilé en code machine, en C ou dans un autre langage ?"
#: faq/design.rst:328
msgid ""
@ -662,16 +662,16 @@ msgid ""
msgstr ""
"Cependant, d'autres implémentations (par exemple `Jython <http://www.jython."
"org>`_ ou `PyPy <http://www.pypy.org>`_) peuvent compter sur un mécanisme "
"différent comme un véritable ramasse-miette. Cette différence peut causer de "
"subtils problèmes de portabilité si votre code Python dépend du comportement "
"de l'implémentation du compteur de références."
"différent comme un véritable ramasse-miettes. Cette différence peut causer "
"de subtils problèmes de portabilité si votre code Python dépend du "
"comportement de l'implémentation du compteur de références."
#: faq/design.rst:352
msgid ""
"In some Python implementations, the following code (which is fine in "
"CPython) will probably run out of file descriptors::"
msgstr ""
"Dans certaines implémentations de Python, le code suivant (qui marche "
"Dans certaines implémentations de Python, le code suivant (qui fonctionne "
"parfaitement avec *CPython*) aurait probablement manqué de descripteurs de "
"fichiers ::"
@ -683,10 +683,9 @@ msgid ""
"possibly long intervals."
msgstr ""
"En effet, à l'aide du comptage de références et du destructeur d'objets de "
"*CPython*, chaque nouvelle affectation à *f* ferme le fichier précédent. "
"Cependant, avec un *GC* classique, ces objets seront seulement recueillies "
"(et fermés) à intervalles variables et possiblement avec de longs "
"intervalles."
"*CPython*, chaque nouvelle affectation à *f* ferme le fichier précédent. "
"Cependant, avec un ramasse-miettes classique, ces objets sont collectés (et "
"fermés) à intervalles irréguliers, et potentiellement longs."
#: faq/design.rst:364
msgid ""
@ -696,13 +695,14 @@ msgid ""
msgstr ""
"Si vous souhaitez écrire du code qui fonctionne avec n'importe quelle "
"implémentation de Python, vous devez explicitement fermer le fichier ou "
"utiliser l'instruction :keyword:`with` ; ceci fonctionnera indépendamment du "
"utiliser l'instruction :keyword:`with` ; ceci fonctionne indépendamment du "
"système de gestion de la mémoire ::"
#: faq/design.rst:374
msgid "Why doesn't CPython use a more traditional garbage collection scheme?"
msgstr ""
"Pourquoi CPython n'utilise-il pas un ramasse-miette plus traditionnel ?"
"Pourquoi CPython n'utilise-t-il pas un modèle de ramasse-miettes plus "
"traditionnel ?"
#: faq/design.rst:376
msgid ""
@ -712,12 +712,12 @@ msgid ""
"transparent, it isn't completely transparent; patches are required to get "
"Python to work with it.)"
msgstr ""
"D'une part, ce n'est pas une caractéristique normalisé en C et par "
"conséquent ce n'est pas portable. (Oui, nous connaissons la bibliothèque *GC "
"Boehm*. Elle contient du code assembleur pour la plupart des plates-formes "
"D'une part, ce n'est pas une caractéristique normalisée en C et, par "
"conséquent, ce n'est pas portable. (Oui, nous connaissons la bibliothèque "
"*GC Boehm*. Elle contient du code assembleur pour la plupart des plateformes "
"classiques, mais pas toutes, et bien qu'elle soit le plus souvent "
"transparent, c'est loin d'être le cas, des correctifs sont nécessaires afin "
"que Python fonctionne correctement avec.)"
"transparente, elle ne l'est pas complètement ; des correctifs sont "
"nécessaires afin que Python fonctionne correctement avec.)"
#: faq/design.rst:382
msgid ""
@ -728,14 +728,14 @@ msgid ""
"malloc() and free(), and may not want Python's. Right now, CPython works "
"with anything that implements malloc() and free() properly."
msgstr ""
"Le *GC* classique devient également un problème lorsque Python est incorporé "
"dans d'autres applications. Bien que dans une application Python, il ne soit "
"pas gênant de remplacer les fonctions ``malloc()`` et ``free()` avec les "
"versions fournies par la bibliothèque *GC*, une application incluant Python "
"peut vouloir avoir ses propres implémentations de ``malloc()`` et ``free()`` "
"et peut ne pas vouloir celles de Python. À l'heure actuelle, CPython "
"fonctionne avec n'importe quelle implémentation correcte de ``malloc()`` et "
"``free()``."
"Un ramasse-miettes classique devient également un problème lorsque Python "
"est incorporé dans d'autres applications. Bien que dans une application "
"Python, il ne soit pas gênant de remplacer les fonctions ``malloc()`` et "
"``free()`` avec les versions fournies par la bibliothèque du ramasse-"
"miettes, une application incluant Python peut vouloir avoir ses propres "
"implémentations de ``malloc()`` et ``free()`` et peut ne pas vouloir celles "
"de Python. À l'heure actuelle, CPython fonctionne avec n'importe quelle "
"implémentation correcte de ``malloc()`` et ``free()``."
#: faq/design.rst:391
msgid "Why isn't all memory freed when CPython exits?"
@ -754,7 +754,7 @@ msgstr ""
"Les objets référencés depuis les espaces de nommage globaux des modules "
"Python ne sont pas toujours désalloués lorsque Python s'arrête. Cela peut se "
"produire s'il y a des références circulaires. Il y a aussi certaines parties "
"de mémoire qui sont alloués par la bibliothèque C qui sont impossibles à "
"de mémoire qui sont allouées par la bibliothèque C qui sont impossibles à "
"libérer (par exemple un outil comme *Purify* s'en plaindra). Python est, "
"cependant, agressif sur le nettoyage de la mémoire en quittant et cherche à "
"détruire chaque objet."
@ -765,8 +765,8 @@ msgid ""
"the :mod:`atexit` module to run a function that will force those deletions."
msgstr ""
"Si vous voulez forcer Python à désallouer certains objets en quittant, "
"utilisez le module :mod:`texit` pour exécuter une fonction qui va forcer ces "
"destructions."
"utilisez le module :mod:`atexit` pour exécuter une fonction qui va forcer "
"ces destructions."
#: faq/design.rst:405
msgid "Why are there separate tuple and list data types?"
@ -782,13 +782,13 @@ msgid ""
"Cartesian coordinate is appropriately represented as a tuple of two or three "
"numbers."
msgstr ""
"Les listes et les *n*-uplets, bien que semblable à bien des égards, sont "
"Les listes et les *n*-uplets, bien que semblables à bien des égards, sont "
"généralement utilisés de façons fondamentalement différentes. Les *n*-uplets "
"peuvent être considérés comme étant similaires aux dossiers en Pascal ou aux "
"structures en C; Ce sont de petites collections de données associées qui "
"peuvent être considérés comme étant similaires au *record* en Pascal ou aux "
"structures en C ; ce sont de petites collections de données associées qui "
"peuvent être de différents types qui sont utilisées ensemble. Par exemple, "
"un repère cartésien est correctement représenté comme un *n*-uplet de deux "
"ou trois nombres."
"des coordonnées cartésiennes sont correctement représentées par un *n*-uplet "
"de deux ou trois nombres."
#: faq/design.rst:414
msgid ""
@ -799,12 +799,12 @@ msgid ""
"Functions which operate on this output would generally not break if you "
"added another file or two to the directory."
msgstr ""
"Les listes, ressemblent davantage à des tableaux dans d'autres langues. "
"Les listes, ressemblent davantage à des tableaux dans d'autres langages. "
"Elles ont tendance à contenir un nombre variable d'objets de même type "
"manipulés individuellement. Par exemple, ``os.listdir('.')`` renvoie une "
"liste de chaînes représentant les fichiers dans le dossier courant. Les "
"fonctions travaillant sur cette sortie accepteraient généralement sans aucun "
"problème que vous ajoutiez un ou deux fichiers supplémentaire dans le "
"fonctions travaillant sur cette sortie acceptent généralement sans aucun "
"problème que vous ajoutiez un ou deux fichiers supplémentaires dans le "
"dossier."
#: faq/design.rst:421
@ -856,7 +856,7 @@ msgid ""
msgstr ""
"Lorsque des éléments sont ajoutés ou insérés, le tableau de références est "
"redimensionné. Un savoir-faire ingénieux permet l'amélioration des "
"performances lors de l'ajout fréquent d'éléments ; Lorsque le tableau doit "
"performances lors de l'ajout fréquent d'éléments ; lorsque le tableau doit "
"être étendu, un certain espace supplémentaire est alloué de sorte que pour "
"la prochaine fois, ceci ne nécessite plus un redimensionnement effectif."
@ -888,22 +888,21 @@ msgid ""
"dictionaries take constant time -- O(1), in Big-O notation -- to retrieve a "
"key."
msgstr ""
"Les dictionnaires fonctionnent en calculant un code de hachage pour chaque "
"clé stockée dans le dictionnaire en utilisant la fonction :func:`hash`. Le "
"code de hachage varie grandement selon la clé et du nombre de processus "
"utilisés ; Par exemple, la chaîne de caractère \"Python\" pourrait avoir "
"comme code de hachage une valeur allant jusqu'à-539294296 tandis que la "
"chaîne \"python\",qui se distingue de la première par un seul bit, pourrait "
"avoir comme code de hachage une valeur allant jusqu'à 1142331976. Le code "
"de hachage est ensuite utilisé pour calculer un emplacement dans un tableau "
"interne où la valeur est stockée. Dans l'hypothèse où vous stockez les clés "
"qui ont toutes des valeurs de hachage différentes, cela signifie que le "
"temps pour récupérer une clé est constant -- O(1), en notation grand O de "
"Landau."
"Les dictionnaires fonctionnent en calculant un condensat pour chaque clé "
"stockée dans le dictionnaire à l'aide de la fonction :func:`hash`. La valeur "
"du condensat varie grandement en fonction de la clé et de la graine utilisée "
"par le processus ; par exemple, la chaîne de caractère \"Python\" pourrait "
"avoir comme condensat la valeur – 539 294 296 tandis que la chaîne \"python"
"\",qui diffère de la première par un seul bit, pourrait avoir comme "
"condensat la valeur 1 142 331 976. Le condensat est ensuite utilisé pour "
"déterminer un emplacement dans le tableau interne où la valeur est stockée. "
"Dans l'hypothèse où vous stockez les clés qui ont toutes des condensats "
"différents, cela signifie que le temps pour récupérer une clé est constant — "
"O(1), en notation grand O de Landau."
#: faq/design.rst:461
msgid "Why must dictionary keys be immutable?"
msgstr "Pourquoi les clés du dictionnaire sont immuables ?"
msgstr "Pourquoi les clés du dictionnaire sont immuables ?"
#: faq/design.rst:463
msgid ""
@ -936,22 +935,22 @@ msgid ""
"dictionary keys."
msgstr ""
"Si vous voulez un dictionnaire indexé avec une liste, il faut simplement "
"convertir la liste en un *n*-uplet ; la fonction ``tuple(L)`` crée un *n*-"
"uplet avec les mêmes entrées que la liste ``L``. Les *n*-uplets sont "
"convertir la liste en un *n*-uplet ; la fonction ``tuple(L)`` crée un *n*-"
"uplet avec les mêmes entrées que la liste ``L``. Les *n*-uplets sont "
"immuables et peuvent donc être utilisés comme clés du dictionnaire."
#: faq/design.rst:476
msgid "Some unacceptable solutions that have been proposed:"
msgstr "Certaines solutions insatisfaisantes qui ont été proposées :"
msgstr "Certaines solutions insatisfaisantes ont été proposées :"
#: faq/design.rst:478
msgid ""
"Hash lists by their address (object ID). This doesn't work because if you "
"construct a new list with the same value it won't be found; e.g.::"
msgstr ""
"Les listes de hachage par leur adresse (*ID* de l'objet). Cela ne "
"fonctionne pas parce que si vous créez une nouvelle liste avec la même "
"valeur, elle ne sera pas retrouvée; par exemple ::"
"Hacher les listes par leur adresse (*ID* de l'objet). Cela ne fonctionne pas "
"parce que si vous créez une nouvelle liste avec la même valeur, elle ne sera "
"pas retrouvée ; par exemple ::"
#: faq/design.rst:484
msgid ""
@ -960,10 +959,10 @@ msgid ""
"words, dictionary keys should be compared using ``==``, not using :keyword:"
"`is`."
msgstr ""
"cela lèverait une exception :exc:`KeyError` car l'ID de ``[1, 2]`` utilisé "
"dans la deuxième ligne diffère de celle de la première ligne. En d'autres "
"termes, les clés de dictionnaire doivent être comparées à l'aide du "
"comparateur ``==`` et non à l'aide du mot clé :keyword:`is`."
"lèverait une exception :exc:`KeyError` car l'ID de ``[1, 2]`` utilisé dans "
"la deuxième ligne diffère de celui de la première ligne. En d'autres termes, "
"les clés de dictionnaire doivent être comparées à l'aide du comparateur "
"``==`` et non à l'aide du mot clé :keyword:`is`."
#: faq/design.rst:488
msgid ""
@ -1000,10 +999,10 @@ msgid ""
msgstr ""
"Marquer les listes comme étant en lecture seule une fois qu'elles sont "
"utilisées comme clé de dictionnaire. Le problème est que ce n'est pas "
"seulement l'objet de niveau supérieur qui pourrait changer sa valeur; vous "
"pourriez utiliser un *n*-uplet contenant une liste comme clé. Utiliser "
"seulement l'objet de niveau supérieur qui pourrait changer sa valeur ; vous "
"pourriez utiliser un *n*-uplet contenant une liste comme clé. Utiliser "
"n'importe quoi comme une clé dans un dictionnaire nécessiterait de marquer "
"tous les objets accessibles à partir de là comme en lecture seule -- et "
"tous les objets accessibles à partir de là comme en lecture seule — et "
"encore une fois, les objets se faisant référence pourraient provoquer une "
"boucle infinie."
@ -1031,8 +1030,8 @@ msgid ""
"arithmetic overflow."
msgstr ""
"Notez que le calcul de hachage peut être compliqué car il est possible que "
"certains membres de la liste peuvent être impossible à hacher et aussi par "
"la possibilité de débordement arithmétique."
"certains membres de la liste soient impossibles à hacher et aussi par la "
"possibilité de débordement arithmétique."
#: faq/design.rst:531
msgid ""
@ -1075,11 +1074,11 @@ msgid ""
"around."
msgstr ""
"Dans les situations où la performance est importante, faire une copie de la "
"liste juste pour la trier serait un gaspillage. Par conséquent, :meth:`list."
"sort` trie la liste en place. Afin de vous le rappeler, il ne retourne pas "
"la liste triée. De cette façon, vous ne serez pas dupés en écrasant "
"accidentellement une liste lorsque vous avez besoin d’une copie triée, mais "
"vous devrez également garder sous la main la version non triée."
"liste juste pour la classer serait un gaspillage. Par conséquent, :meth:"
"`list.sort` classe la liste en place. Afin de vous le rappeler, elle ne "
"renvoie pas la liste classée. De cette façon, vous ne serez pas dupés en "
"écrasant accidentellement une liste lorsque vous avez besoin d’une copie "
"triée tout en gardant sous la main la version non triée."
#: faq/design.rst:551
msgid ""
@ -1088,16 +1087,16 @@ msgid ""
"it and returns it. For example, here's how to iterate over the keys of a "
"dictionary in sorted order::"
msgstr ""
"Si vous souhaitez retourner une nouvelle liste, utilisez plutôt la fonction "
"native :func:`sorted`. Cette fonction crée une nouvelle liste à partir d’un "
"itérable fourni, la trie et la retourne. Par exemple, voici comment itérer "
"sur les clefs d’un dictionnaire dans l’ordre trié ::"
"Si vous souhaitez qu'une nouvelle liste soit renvoyée, utilisez plutôt la "
"fonction native :func:`sorted`. Cette fonction crée une nouvelle liste à "
"partir d’un itérable fourni, la classe et la renvoie. Par exemple, voici "
"comment itérer dans l’ordre sur les clés d’un dictionnaire ::"
#: faq/design.rst:561
msgid "How do you specify and enforce an interface spec in Python?"
msgstr ""
"Comment spécifiez-vous et appliquez-vous une spécification d’interface en "
"Python ?"
"Comment spécifier une interface et appliquer une spécification d’interface "
"en Python ?"
#: faq/design.rst:563
msgid ""
@ -1109,7 +1108,7 @@ msgstr ""
"Une spécification d'interface pour un module fourni par des langages tels "
"que C++ et Java décrit les prototypes pour les méthodes et les fonctions du "
"module. Beaucoup estiment que la vérification au moment de la compilation "
"des spécifications d'interface aide à la construction de grands programmes."
"des spécifications d'interface facilite la construction de grands programmes."
#: faq/design.rst:568
msgid ""
@ -1121,12 +1120,12 @@ msgid ""
"`~collections.abc.MutableMapping`."
msgstr ""
"Python 2.6 ajoute un module :mod:`abc` qui vous permet de définir des "
"classes de base abstraites (ABCs). Vous pouvez ensuite utiliser :func:"
"`isinstance` et :func:`issubclass` pour vérifier si une instance ou une "
"classe implémente une ABC particulière. Le module :mod:`collections.abc` "
"définit un ensemble d'ABCs utiles telles que :class:`~collections.abc."
"Iterable`, :class:`~collections.abc.Container` et :class:`collections.abc."
"MutableMapping`."
"classes de base abstraites (ABC pour *abstract base classes* en anglais). "
"Vous pouvez ensuite utiliser :func:`isinstance` et :func:`issubclass` pour "
"vérifier si une instance ou une classe implémente une ABC particulière. Le "
"module :mod:`collections.abc` définit un ensemble d'ABC utiles telles que :"
"class:`~collections.abc.Iterable`, :class:`~collections.abc.Container` et :"
"class:`collections.abc.MutableMapping`."
#: faq/design.rst:575
msgid ""
@ -1148,12 +1147,12 @@ msgid ""
"in a module."
msgstr ""
"Une bonne suite de tests pour un module peut à la fois fournir un test de "
"non régression et servir de spécification d'interface de module ainsi qu'un "
"non-régression et servir de spécification d'interface de module ainsi qu'un "
"ensemble d'exemples. De nombreux modules Python peuvent être exécutés en "
"tant que script pour fournir un simple « auto-test ». Même les modules qui "
"utilisent des interfaces externes complexes peuvent souvent être testés "
"isolément à l'aide d'émulations triviales embryonnaires de l'interface "
"externe. Les modules :mod:`doctest` et :mod:`UnitTest` ou des frameworks de "
"externe. Les modules :mod:`doctest` et :mod:`UnitTest` ou des cadriciels de "
"test tiers peuvent être utilisés pour construire des suites de tests "
"exhaustives qui éprouvent chaque ligne de code dans un module."
@ -1205,35 +1204,41 @@ msgid ""
"expressions) and loop (with ``while`` and ``for`` statements, possibly "
"containing ``continue`` and ``break``)."
msgstr ""
"Dans les années 1970, les gens se sont aperçus que le foisonnement de *goto* "
"conduisait à du code « spaghetti » difficile à comprendre et à modifier. "
"Dans les langages de haut niveau, c'est d'autant moins nécessaire qu'il "
"existe différentes manières de créer des branches (en Python, les "
"instructions ``if`` et les expressions ``or``, ``and`` et ``if-else``) et de "
"boucler (avec les instructions ``while`` et ``for``, qui peuvent contenir "
"des ``continue`` et ``break``)."
#: faq/design.rst:611
#, fuzzy
msgid ""
"One can also use exceptions to provide a \"structured goto\" that works even "
"across function calls. Many feel that exceptions can conveniently emulate "
"all reasonable uses of the \"go\" or \"goto\" constructs of C, Fortran, and "
"other languages. For example::"
msgstr ""
"Vous pouvez utiliser les exceptions afin de mettre en place un \"``goto`` "
"structuré\" qui fonctionne même avec les appels de fonctions. Beaucoup de "
"personnes estiment que les exceptions peuvent émuler idéalement tout "
"utilisation raisonnable des constructions ``go`` ou ``goto`` en C, en "
"Fortran ou autres langages de programmation. Par exemple ::"
"Vous pouvez utiliser les exceptions afin de mettre en place un « *goto* "
"structuré » qui fonctionne même à travers les appels de fonctions. Beaucoup "
"de personnes estiment que les exceptions sont une façon commode d'émuler "
"l'utilisation raisonnable des constructions *go* ou *goto* du C, du Fortran "
"ou d'autres langages de programmation. Par exemple ::"
#: faq/design.rst:627
msgid ""
"This doesn't allow you to jump into the middle of a loop, but that's usually "
"considered an abuse of goto anyway. Use sparingly."
msgstr ""
"Cela ne vous permet pas de sauter au milieu d'une boucle. Néanmoins, dans "
"tous les cas cela est généralement considéré comme un abus de ``goto``. À "
"Utiliser avec parcimonie."
"Cela ne vous permet pas de sauter au milieu d'une boucle mais, ceci est de "
"toute façon généralement considéré comme un abus de ``goto``. À Utiliser "
"avec parcimonie."
#: faq/design.rst:632
msgid "Why can't raw strings (r-strings) end with a backslash?"
msgstr ""
"Pourquoi les chaînes de caractères brutes (r-strings) ne peuvent-elles pas "
"se terminer par un *backslash* ?"
"se terminer par un *backslash* ?"
#: faq/design.rst:634
msgid ""
@ -1242,8 +1247,8 @@ msgid ""
"an unterminated string."
msgstr ""
"Plus précisément, elles ne peuvent pas se terminer par un nombre impair de "
"*backslashes* : le *backslash* non appairé à la fin échappe le caractère de "
"guillemet final, laissant une chaîne non terminée."
"*backslashes* : le *backslash* non appairé à la fin échappe le caractère de "
"guillemet final, laissant la chaîne non terminée."
#: faq/design.rst:638
msgid ""
@ -1269,15 +1274,15 @@ msgid ""
"calls accept forward slashes too::"
msgstr ""
"Si vous essayez de construire des chemins d'accès Windows, notez que tous "
"les appels système Windows acceptent également les *slashes* \"classiques"
"\" ::"
"les appels système Windows acceptent également les *slashes* "
"« classiques » ::"
#: faq/design.rst:650
msgid ""
"If you're trying to build a pathname for a DOS command, try e.g. one of ::"
msgstr ""
"Si vous essayez de construire un chemin d'accès pour une commande DOS, "
"essayez par exemple l'un de ceux-là ::"
"essayez par exemple l'un de ceux-ci ::"
#: faq/design.rst:658
msgid "Why doesn't Python have a \"with\" statement for attribute assignments?"
@ -1292,7 +1297,7 @@ msgid ""
"construct that looks like this::"
msgstr ""
"Python a une instruction ``with`` qui encapsule l'exécution d'un bloc, en "
"appelant le code sur l'entrée et la sortie du bloc. Certains langages "
"appelant du code à l'entrée et la sortie du bloc. Certains langages "
"possèdent une construction qui ressemble à ceci ::"
#: faq/design.rst:668
@ -1306,11 +1311,11 @@ msgid ""
"assigned to. This is the main point of static typing -- the compiler "
"*always* knows the scope of every variable at compile time."
msgstr ""
"Les autres langages, tels que le Pascal, le Delphi et le C++ utilisent des "
"types statiques, il est donc possible de savoir d'une manière claire et "
"directe ce à quoi est attribué un membre. C'est le point principal du typage "
"statique --le compilateur connaît *toujours* la portée de toutes les "
"variables au moment de la compilation."
"Les autres langages, tels que Pascal, Delphi et C++ utilisent des types "
"statiques, il est donc possible de savoir d'une manière claire et directe ce "
"à quoi est attribué un membre. C'est le point principal du typage statique — "
"le compilateur connaît *toujours* la portée de toutes les variables au "
"moment de la compilation."
#: faq/design.rst:675
msgid ""
@ -1321,10 +1326,10 @@ msgid ""
"one, or a member attribute?"
msgstr ""
"Python utilise le typage dynamique. Il est impossible de savoir à l'avance "
"quel attribut est utilisé comme référence lors de l'exécution. Les attributs "
"membres peuvent être ajoutés ou retirés des objets à la volée. Il est donc "
"impossible de savoir, d'une simple lecture, quel attribut est référencé : "
"s'il est local, global ou un attribut membre?"
"quel attribut sera référencé lors de l'exécution. Les attributs membres "
"peuvent être ajoutés ou retirés des objets à la volée. Il est donc "
"impossible de savoir, d'une simple lecture, quel attribut est référencé : "
"s'il est local, global ou un attribut membre ?"
#: faq/design.rst:681
msgid "For instance, take the following incomplete snippet::"
@ -1338,11 +1343,11 @@ msgid ""
"variable named \"x\", will it be used inside the with block? As you see, "
"the dynamic nature of Python makes such choices much harder."
msgstr ""
"L'extrait suppose que \"a\" doit avoir un attribut membre appelé \"x\". "
"L'extrait suppose que « a » doit avoir un attribut membre appelé « x ». "
"Néanmoins, il n'y a rien en Python qui en informe l'interpréteur. Que se "
"passe-t-il si \"a\" est, disons, un entier ? Si une variable globale nommée "
"\"x\" existe, sera-t-elle utilisée dans le bloc ``with`` ? Comme vous "
"voyez, la nature dynamique du Python rend ces choix beaucoup plus difficiles."
"passe-t-il si « a » est, disons, un entier ? Si une variable globale nommée "
"« x » existe, est-elle utilisée dans le bloc ``with`` ? Comme vous voyez, "
"la nature dynamique du Python rend ces choix beaucoup plus difficiles."
#: faq/design.rst:693
msgid ""
@ -1384,19 +1389,19 @@ msgstr ""
msgid "Why are colons required for the if/while/def/class statements?"
msgstr ""
"Pourquoi les deux-points sont-ils nécessaires pour les déclarations ``if/"
"while/def/class`` ?"
"while/def/class`` ?"
#: faq/design.rst:724
msgid ""
"The colon is required primarily to enhance readability (one of the results "
"of the experimental ABC language). Consider this::"
msgstr ""
"Le deux-points est principalement nécessaires pour améliorer la lisibilité "
"Le deux-points est principalement nécessaire pour améliorer la lisibilité "
"(l'un des résultats du langage expérimental ABC). Considérez ceci ::"
#: faq/design.rst:730
msgid "versus ::"
msgstr "versus ::"
msgstr "et cela ::"
#: faq/design.rst:735
msgid ""
@ -1406,7 +1411,7 @@ msgid ""
msgstr ""
"Remarquez comment le deuxième est un peu plus facile à lire. Remarquez "
"aussi comment un deux-points introduit l'exemple dans cette réponse à la "
"FAQ ; c'est un usage standard en anglais."
"FAQ ; c'est un usage standard en français (et en anglais)."
#: faq/design.rst:738
msgid ""
@ -1416,7 +1421,7 @@ msgid ""
"the program text."
msgstr ""
"Une autre raison mineure est que les deux-points facilitent la tâche des "
"éditeurs avec coloration syntaxique ; ils peuvent rechercher les deux-points "
"éditeurs avec coloration syntaxique ; ils peuvent rechercher les deux-points "
"pour décider quand l'indentation doit être augmentée au lieu d'avoir à faire "
"une analyse plus élaborée du texte du programme."
@ -1424,7 +1429,7 @@ msgstr ""
msgid "Why does Python allow commas at the end of lists and tuples?"
msgstr ""
"Pourquoi Python permet-il les virgules à la fin des listes et des *n*-"
"uplets ?"
"uplets ?"
#: faq/design.rst:746
msgid ""
@ -1466,7 +1471,7 @@ msgid ""
"of error."
msgstr ""
"Cette liste a l'air d'avoir quatre éléments, mais elle en contient en fait "
"trois : \"*fee*\", \"*fiefoo*\" et \"*fum*\". Toujours ajouter la virgule "
"trois : \"*fee*\", \"*fiefoo*\" et \"*fum*\". Toujours ajouter la virgule "
"permet d'éviter cette source d'erreur."
#: faq/design.rst:777