# Copyright (C) 2001-2018, Python Software Foundation

# For licence information, see README file.

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-10-17 09:58+0200\n"

"PO-Revision-Date: 2023-03-26 17:18+0200\n"

"Last-Translator: Mathieu Dupuy\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 3.2.2\n"

#: faq/design.rst:3

msgid "Design and History FAQ"

msgstr "FAQ sur l'histoire et la conception"

#: faq/design.rst:6

msgid "Contents"

msgstr "Sommaire"

#: faq/design.rst:11

msgid "Why does Python use indentation for grouping of statements?"

msgstr ""

"Pourquoi Python utilise-t-il l'indentation pour grouper les instructions ?"

#: faq/design.rst:13

msgid ""

"Guido van Rossum believes that using indentation for grouping is extremely "

"elegant and contributes a lot to the clarity of the average Python program. "

"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é d'un "

"programme Python ordinaire. La plupart des gens finissent par aimer cette "

"particularité au bout d'un moment."

#: faq/design.rst:17

msgid ""

"Since there are no begin/end brackets there cannot be a disagreement between "

"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 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 ::"

#: faq/design.rst:26

msgid ""

"Only the ``x++`` statement is executed if the condition is true, but the "

"indentation leads many to believe otherwise. Even experienced C programmers "

"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++`` 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 ""

"Because there are no begin/end brackets, Python is much less prone to coding-"

"style conflicts. In C there are many different ways to place the braces. "

"After becoming used to reading and writing code using a particular style, it "

"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 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 "

"autre style."

#: faq/design.rst:38

msgid ""

"Many coding styles place begin/end brackets on a line by themselves. This "

"makes programs considerably longer and wastes valuable screen space, making "

"it harder to get a good overview of a program. Ideally, a function should "

"fit on one screen (say, 20--30 lines). 20 lines of Python can do a lot more "

"work than 20 lines of C. This is not solely due to the lack of begin/end "

"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 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 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

msgid "Why am I getting strange results with simple arithmetic operations?"

msgstr ""

"Pourquoi ai-je d'étranges résultats suite à de simples opérations "

"arithmétiques ?"

#: faq/design.rst:50

msgid "See the next question."

msgstr "Voir la question suivante."

#: faq/design.rst:54

msgid "Why are floating-point calculations so inaccurate?"

msgstr "Pourquoi les calculs à virgules flottantes sont si imprécis ?"

#: faq/design.rst:56

msgid "Users are often surprised by results like this::"

msgstr "Les gens sont très souvent surpris par des résultats comme celui-ci ::"

#: faq/design.rst:61

msgid ""

"and think it is a bug in Python. It's not. This has little to do with "

"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 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."

#: faq/design.rst:65

msgid ""

"The :class:`float` type in CPython uses a C ``double`` for storage. "

"A :class:`float` object's value is stored in binary floating-point with a "

"fixed precision (typically 53 bits) and Python uses C operations, which in "

"turn rely on the hardware implementation in the processor, to perform "

"floating-point operations. This means that as far as floating-point "

"operations are concerned, Python behaves like many popular languages "

"including C and Java."

msgstr ""

"La classe :class:`float` dans CPython utilise le type double du langage C "

"comme stockage. La valeur d'un objet :class:`float` est stockée dans un "

"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 "

"opérations sur les nombres à virgule flottante, Python se comporte comme "

"beaucoup de langages populaires dont C et Java."

#: faq/design.rst:72

#, fuzzy

msgid ""

"Many numbers that can be written easily in decimal notation cannot be "

"expressed exactly in binary floating point. For example, after::"

msgstr ""

"Beaucoup de nombres pouvant être écrits facilement en notation décimale ne "

"peuvent pas s'exprimer de manière exacte en binaire à virgule flottante. Par "

"exemple, après ::"

#: faq/design.rst:77

msgid ""

"the value stored for ``x`` is a (very good) approximation to the decimal "

"value ``1.2``, but is not exactly equal to it. On a typical machine, the "

"actual stored value is::"

msgstr ""

"la valeur stockée pour ``x`` est une (très bonne) approximation de la valeur "

"décimale ``1.2``, mais cette valeur n'est pas exacte. Sur une machine "

"typique, la valeur stockée est en fait ::"

#: faq/design.rst:83

msgid "which is exactly::"

msgstr "qui est, exactement ::"

#: faq/design.rst:87

msgid ""

"The typical precision of 53 bits provides Python floats with 15--16 decimal "

"digits of accuracy."

msgstr ""

"La précision typique de 53 bits des *floats* Python permet une précision de "

"15–16 décimales."

#: faq/design.rst:90

#, fuzzy

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:`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?"

msgstr "Pourquoi les chaînes de caractères Python sont-elles immuables ?"

#: faq/design.rst:97

msgid "There are several advantages."

msgstr "Il y a plusieurs avantages."

#: faq/design.rst:99

msgid ""

"One is performance: knowing that a string is immutable means we can allocate "

"space for it at creation time, and the storage requirements are fixed and "

"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 "

"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."

#: faq/design.rst:104

msgid ""

"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."

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 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é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. Cela s'avère très utile, pour diverses "

"raisons."

#: faq/design.rst:117

msgid ""

"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."

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 "

"``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 "

"Python, il n'y a pas de déclarations de variables locales, de sorte que vous "

"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."

#: faq/design.rst:127

#, fuzzy

msgid ""

"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:`~object.__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."

msgstr ""

"Ensuite, ça veut dire qu'aucune syntaxe spéciale n'est nécessaire si vous "

"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 mère elle-"

"même surchargée par une classe dérivée, vous devez utiliser l'opérateur "

"``::`` — 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 mère, et "

"doit donc se débrouiller pour appeler la méthode de la classe mère."

#: faq/design.rst:136

msgid ""

"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."

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 "

"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 "

"nommage, et vous devez dire à Python quel espace de nommage utiliser."

#: faq/design.rst:154

msgid "Why can't I use an assignment in an expression?"

msgstr "Pourquoi ne puis-je pas utiliser d'assignation dans une expression ?"

#: faq/design.rst:156

msgid "Starting in Python 3.8, you can!"

msgstr "Depuis Python 3.8, c'est possible !"

#: faq/design.rst:158

msgid ""

"Assignment expressions using the walrus operator ``:=`` assign a variable in "

"an expression::"

msgstr ""

"Les expressions d'affectation qui utilisent l'opérateur morse ``:=`` "

"affectent une variable dans une expression ::"

#: faq/design.rst:164

msgid "See :pep:`572` for more information."

msgstr "Voir la :pep:`572` pour plus d'informations."

#: faq/design.rst:169

msgid ""

"Why does Python use methods for some functionality (e.g. list.index()) but "

"functions for other (e.g. len(list))?"

msgstr ""

"Pourquoi Python utilise des méthodes pour certaines fonctionnalités (ex : "

"``list.index()``) mais des fonctions pour d'autres (ex : ``len(list)``) ?"

#: faq/design.rst:171

msgid "As Guido said:"

msgstr "Comme l'a dit Guido :"

#: faq/design.rst:173

msgid ""

"(a) For some operations, prefix notation just reads better than postfix -- "

"prefix (and infix!) operations have a long tradition in mathematics which "

"likes notations where the visuals help the mathematician thinking about a "

"problem. Compare the easy with which we rewrite a formula like x*(a+b) into "

"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 "

"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 "

"lourdeur de faire la même chose avec une notation orientée objet brute."

#: faq/design.rst:180

msgid ""

"(b) When I read code that says len(x) I *know* that it is asking for the "

"length of something. This tells me two things: the result is an integer, and "

"the argument is some kind of container. To the contrary, when I read "

"x.len(), I have to already know that x is some kind of container "

"implementing an interface or inheriting from a class that has a standard "

"len(). Witness the confusion we occasionally have when a class that is not "

"implementing a mapping has a get() or keys() method, or something that isn't "

"a file has a 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 "

"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()`` "

"standard. Voyez la confusion qui arrive parfois quand une classe qui "

"n'implémente pas une interface de dictionnaire a une méthode ``get()`` ou "

"``key()``, ou quand un objet qui n'est pas un fichier implémente une méthode "

"``write()``."

#: faq/design.rst:189

msgid "https://mail.python.org/pipermail/python-3000/2006-November/004643.html"

msgstr ""

"https://mail.python.org/pipermail/python-3000/2006-November/004643.html"

#: faq/design.rst:193

msgid "Why is join() a string method instead of a list or tuple method?"

msgstr ""

"Pourquoi ``join()`` est une méthode de chaîne plutôt qu'une méthode de liste "

"ou de *n*-uplet ?"

#: faq/design.rst:195

msgid ""

"Strings became much more like other standard types starting in Python 1.6, "

"when methods were added which give the same functionality that has always "

"been available using the functions of the string module. Most of these new "

"methods have been widely accepted, but the one which appears to make some "

"programmers feel uncomfortable is::"

msgstr ""

"Les chaînes sont devenues bien plus comme d'autres types standards à partir "

"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 mal "

"à l'aise est ::"

#: faq/design.rst:203

msgid "which gives the result::"

msgstr "qui donne le résultat ::"

#: faq/design.rst:207

msgid "There are two common arguments against this usage."

msgstr "Il y a deux arguments fréquents contre cet usage."

#: faq/design.rst:209

msgid ""

"The first runs along the lines of: \"It looks really ugly using a method of "

"a string literal (string constant)\", to which the answer is that it might, "

"but a string literal is just a fixed value. If the methods are to be allowed "

"on names bound to strings there is no logical reason to make them "

"unavailable on literals."

msgstr ""

"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 ""

"The second objection is typically cast as: \"I am really telling a sequence "

"to join its members together with a string constant\". Sadly, you aren't. "

"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 ""

"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 ""

"is an instruction to a string literal to return the substrings delimited by "

"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 fourni (ou, par défaut, les espaces ou groupes "

"d'espaces)."

#: faq/design.rst:225

msgid ""

":meth:`~str.join` is a string method because in using it you are telling the "

"separator string to iterate over a sequence of strings and insert itself "

"between adjacent elements. This method can be used with any argument which "

"obeys the rules for sequence objects, including any new classes you might "

"define yourself. Similar methods exist for bytes and bytearray objects."

msgstr ""

":meth:`~str.join` est une méthode de chaîne parce qu'en l'utilisant vous "

"dites au séparateur de chaîne d'itérer une séquence de chaînes et de "

"s'insérer entre les éléments adjacents. Cette méthode peut être utilisée "

"avec n'importe quel argument qui obéit aux règles d'objets séquence, "

"incluant n'importe quelles nouvelles classes que vous pourriez définir vous-"

"même. Des méthodes similaires existent pour des objets ``bytes`` et "

"``bytearray``."

#: faq/design.rst:233

msgid "How fast are exceptions?"

msgstr "À quel point les exceptions sont-elles rapides ?"

#: faq/design.rst:235

#, fuzzy

msgid ""

"A :keyword:`try`/:keyword:`except` block is extremely efficient if no "

"exceptions are raised. 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 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:246

msgid ""

"This only made sense when you expected the dict to have the key almost all "

"the time. If that wasn't the case, you coded it like this::"

msgstr ""

"Cela n'a de sens que si vous vous attendez à ce que le dictionnaire ait la "

"clé presque tout le temps. Si ce n'était pas le cas, vous l'auriez codé "

"comme suit ::"

#: faq/design.rst:254

msgid ""

"For this specific case, you could also use ``value = dict.setdefault(key, "

"getvalue(key))``, but only if the ``getvalue()`` call is cheap enough "

"because it is evaluated in all cases."

msgstr ""

"Pour ce cas, vous pouvez également utiliser ``value = dict.setdefault(key, "

"getvalue(key))``, mais seulement si l'appel à ``getvalue()`` est "

"suffisamment peu coûteux car il est évalué dans tous les cas."

#: faq/design.rst:260

msgid "Why isn't there a switch or case statement in Python?"

msgstr ""

"Pourquoi n'y a-t-il pas une instruction *switch* ou une structure similaire "

"à *switch / case* en Python ?"

#: faq/design.rst:262

msgid ""

"In general, structured switch statements execute one block of code when an "

"expression has a particular value or set of values. Since Python 3.10 one "

"can easily match literal values, or constants within a namespace, with a "

"``match ... case`` statement. An older alternative is a sequence of ``if... "

"elif... elif... else``."

msgstr ""

#: faq/design.rst:268

msgid ""

"For cases where you need to choose from a very large number of "

"possibilities, you can create a dictionary mapping case values to functions "

"to call. For example::"

msgstr ""

"Dans les cas où vous devez choisir parmi un très grand nombre de "

"possibilités, vous pouvez créer un dictionnaire faisant correspondre des "

"valeurs à des fonctions à appeler. Par exemple ::"

#: faq/design.rst:279

msgid ""

"For calling methods on objects, you can simplify yet further by using "

"the :func:`getattr` built-in to retrieve methods with a particular name::"

msgstr ""

"Pour appeler les méthodes sur des objets, vous pouvez simplifier davantage "

"en utilisant la fonction native :func:`getattr` pour récupérer les méthodes "

"avec un nom donné ::"

#: faq/design.rst:291

msgid ""

"It's suggested that you use a prefix for the method names, such as "

"``visit_`` in this example. Without such a prefix, if values are coming "

"from an untrusted source, an attacker would be able to call any method on "

"your object."

msgstr ""

"Il est suggéré que vous utilisiez un préfixe pour les noms de méthodes, "

"telles que ``visit_`` dans cet exemple. Sans ce préfixe, si les valeurs "

"proviennent d'une source non fiable, un attaquant serait en mesure d'appeler "

"n'importe quelle méthode sur votre objet."

#: faq/design.rst:295

msgid ""

"Imitating switch with fallthrough, as with C's switch-case-default, is "

"possible, much harder, and less needed."

msgstr ""

#: faq/design.rst:300

msgid ""

"Can't you emulate threads in the interpreter instead of relying on an OS-"

"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écifiques aux systèmes d'exploitation ?"

#: faq/design.rst:302

msgid ""

"Answer 1: Unfortunately, the interpreter pushes at least one C stack frame "

"for each Python stack frame. Also, extensions can call back into Python at "

"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 "

"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écessiterait "

"une gestion complète pour le C."

#: faq/design.rst:307

msgid ""

"Answer 2: Fortunately, there is `Stackless Python <https://github.com/"

"stackless-dev/stackless/wiki>`_, which has a completely redesigned "

"interpreter loop that avoids the C stack."

msgstr ""

"Réponse 2 : heureusement, il existe `Stackless Python <https://github.com/"

"stackless-dev/stackless/wiki>`_, qui a complètement ré-architecturé la "

"boucle principale de l'interpréteur afin de ne pas utiliser la pile C."

#: faq/design.rst:312

msgid "Why can't lambda expressions contain statements?"

msgstr ""

"Pourquoi les expressions lambda ne peuvent pas contenir d'instructions ?"

#: faq/design.rst:314

msgid ""

"Python lambda expressions cannot contain statements because Python's "

"syntactic framework can't handle statements nested inside expressions. "

"However, in Python, this is not a serious problem. Unlike lambda forms in "

"other languages, where they add functionality, Python lambdas are only a "

"shorthand notation if you're too lazy to define a function."

msgstr ""

"Les expressions lambda de Python ne peuvent pas contenir d'instructions "

"parce que le cadre syntaxique de Python ne peut pas gérer les instructions "

"imbriquées à l'intérieur d'expressions. Cependant, en Python, ce n'est pas "

"vraiment un problème. Contrairement aux formes lambda dans d'autres "

"langages, où elles ajoutent des fonctionnalités, les expressions lambda de "

"Python sont seulement une notation concise si vous êtes trop paresseux pour "

"définir une fonction."

#: faq/design.rst:320

msgid ""

"Functions are already first class objects in Python, and can be declared in "

"a local scope. Therefore the only advantage of using a lambda instead of a "

"locally defined function is that you don't need to invent a name for the "

"function -- but that's just a local variable to which the function object "

"(which is exactly the same type of object that a lambda expression yields) "

"is assigned!"

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 "

"variable locale à laquelle est affecté l'objet fonction (qui est exactement "

"le même type d'objet que celui renvoyé par une expression lambda) !"

#: faq/design.rst:328

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 ?"

#: faq/design.rst:330

#, fuzzy

msgid ""

"`Cython <https://cython.org/>`_ compiles a modified version of Python with "

"optional annotations into C extensions. `Nuitka <https://nuitka.net/>`_ is "

"an up-and-coming compiler of Python into C++ code, aiming to support the "

"full Python language."

msgstr ""

"`Cython <https://cython.org/>`_ compile une version modifiée de Python avec "

"des annotations optionnelles en extensions C. `Nuitka <https://"

"www.nuitka.net/>`_ est un compilateur en devenir de Python vers C++, visant "

"à supporter le langage Python dans son entièreté."

#: faq/design.rst:337

msgid "How does Python manage memory?"

msgstr "Comment Python gère la mémoire ?"

#: faq/design.rst:339

msgid ""

"The details of Python memory management depend on the implementation. The "

"standard implementation of Python, :term:`CPython`, uses reference counting "

"to detect inaccessible objects, and another mechanism to collect reference "

"cycles, periodically executing a cycle detection algorithm which looks for "

"inaccessible cycles and deletes the objects involved. The :mod:`gc` module "

"provides functions to perform a garbage collection, obtain debugging "

"statistics, and tune the collector's parameters."

msgstr ""

"Les détails de la gestion de la mémoire en Python dépendent de "

"l'implémentation. En effet, l'implémentation standard de "

"Python, :term:`CPython`, utilise des compteurs de références afin de "

"détecter des objets inaccessibles et un autre mécanisme pour collecter les "

"références circulaires, exécutant périodiquement un algorithme de détection "

"de cycles qui recherche les cycles inaccessibles et supprime les objets "

"impliqués. Le module :mod:`gc` fournit des fonctions pour lancer le ramasse-"

"miettes, d'obtenir des statistiques de débogage et ajuster ses paramètres."

#: faq/design.rst:347

#, fuzzy

msgid ""

"Other implementations (such as `Jython <https://www.jython.org>`_ or `PyPy "

"<https://pypy.org>`_), however, can rely on a different mechanism such as a "

"full-blown garbage collector. This difference can cause some subtle porting "

"problems if your Python code depends on the behavior of the reference "

"counting implementation."

msgstr ""

"Cependant, d'autres implémentations (par exemple `Jython <https://"

"www.jython.org>`_ ou `PyPy <https://www.pypy.org>`_) peuvent compter sur un "

"mécanisme 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:353

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 fonctionne "

"parfaitement avec *CPython*) aurait probablement manqué de descripteurs de "

"fichiers ::"

#: faq/design.rst:360

#, fuzzy

msgid ""

"Indeed, using CPython's reference counting and destructor scheme, each new "

"assignment to ``f`` closes the previous file. With a traditional GC, "

"however, those file objects will only get collected (and closed) at varying "

"and 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 ramasse-miettes classique, ces objets sont collectés (et "

"fermés) à intervalles irréguliers, et potentiellement longs."

#: faq/design.rst:365

msgid ""

"If you want to write code that will work with any Python implementation, you "

"should explicitly close the file or use the :keyword:`with` statement; this "

"will work regardless of memory management scheme::"

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 fonctionne indépendamment du "

"système de gestion de la mémoire ::"

#: faq/design.rst:375

msgid "Why doesn't CPython use a more traditional garbage collection scheme?"

msgstr ""

"Pourquoi CPython n'utilise-t-il pas un modèle de ramasse-miettes plus "

"traditionnel ?"

#: faq/design.rst:377

msgid ""

"For one thing, this is not a C standard feature and hence it's not portable. "

"(Yes, we know about the Boehm GC library. It has bits of assembler code for "

"*most* common platforms, not for all of them, and although it is mostly "

"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é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 "

"transparente, elle ne l'est pas complètement ; des correctifs sont "

"nécessaires afin que Python fonctionne correctement avec.)"

#: faq/design.rst:383

#, fuzzy

msgid ""

"Traditional GC also becomes a problem when Python is embedded into other "

"applications. While in a standalone Python it's fine to replace the "

"standard ``malloc()`` and ``free()`` with versions provided by the GC "

"library, an application embedding Python may want to have its *own* "

"substitute for ``malloc()`` and ``free()``, and may not want Python's. "

"Right now, CPython works with anything that implements ``malloc()`` and "

"``free()`` properly."

msgstr ""

"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:392

msgid "Why isn't all memory freed when CPython exits?"

msgstr ""

"Pourquoi toute la mémoire n'est pas libérée lorsque *CPython* s'arrête ?"

#: faq/design.rst:394

msgid ""

"Objects referenced from the global namespaces of Python modules are not "

"always deallocated when Python exits. This may happen if there are circular "

"references. There are also certain bits of memory that are allocated by the "

"C library that are impossible to free (e.g. a tool like Purify will complain "

"about these). Python is, however, aggressive about cleaning up memory on "

"exit and does try to destroy every single object."

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é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."

#: faq/design.rst:401

msgid ""

"If you want to force Python to delete certain things on deallocation use "

"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:`atexit` pour exécuter une fonction qui va forcer "

"ces destructions."

#: faq/design.rst:406

msgid "Why are there separate tuple and list data types?"

msgstr ""

"Pourquoi les *n*-uplets et les *list* sont deux types de données séparés ?"

#: faq/design.rst:408

#, fuzzy

msgid ""

"Lists and tuples, while similar in many respects, are generally used in "

"fundamentally different ways. Tuples can be thought of as being similar to "

"Pascal ``records`` or C ``structs``; they're small collections of related "

"data which may be of different types which are operated on as a group. For "

"example, a Cartesian coordinate is appropriately represented as a tuple of "

"two or three numbers."

msgstr ""

"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 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, "

"des coordonnées cartésiennes sont correctement représentées par un *n*-uplet "

"de deux ou trois nombres."

#: faq/design.rst:415

#, fuzzy

msgid ""

"Lists, on the other hand, are more like arrays in other languages. They "

"tend to hold a varying number of objects all of which have the same type and "

"which are operated on one-by-one. For example, :func:`os.listdir('.') "

"<os.listdir>` returns a list of strings representing the files in the "

"current directory. 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 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 acceptent généralement sans aucun "

"problème que vous ajoutiez un ou deux fichiers supplémentaires dans le "

"dossier."

#: faq/design.rst:423

msgid ""

"Tuples are immutable, meaning that once a tuple has been created, you can't "

"replace any of its elements with a new value. Lists are mutable, meaning "

"that you can always change a list's elements. Only immutable elements can "

"be used as dictionary keys, and hence only tuples and not lists can be used "

"as keys."

msgstr ""

"Les *n*-uplets sont immuables, ce qui signifie que lorsqu'un *n*-uplet a été "

"créé, vous ne pouvez remplacer aucun de ses éléments par une nouvelle "

"valeur. Les listes sont mutables, ce qui signifie que vous pouvez toujours "

"modifier les éléments d'une liste. Seuls des éléments immuables peuvent être "

"utilisés comme clés de dictionnaires, et donc de ``tuple`` et ``list`` seul "

"des *n*-uplets peuvent être utilisés comme clés."

#: faq/design.rst:430

msgid "How are lists implemented in CPython?"

msgstr "Comment les listes sont-elles implémentées dans CPython ?"

#: faq/design.rst:432

msgid ""

"CPython's lists are really variable-length arrays, not Lisp-style linked "

"lists. The implementation uses a contiguous array of references to other "

"objects, and keeps a pointer to this array and the array's length in a list "

"head structure."

msgstr ""

"Les listes en CPython sont de vrais tableaux de longueur variable "

"contrairement à des listes orientées *Lisp* (c.-à-d. des listes chaînées). "

"L'implémentation utilise un tableau contigu de références à d'autres objets. "

"Elle conserve également un pointeur vers ce tableau et la longueur du "

"tableau dans une structure de tête de liste."

#: faq/design.rst:436

msgid ""

"This makes indexing a list ``a[i]`` an operation whose cost is independent "

"of the size of the list or the value of the index."

msgstr ""

"Cela rend l'indexation d'une liste ``a[i]`` une opération dont le coût est "

"indépendant de la taille de la liste ou de la valeur de l'indice."

#: faq/design.rst:439

msgid ""

"When items are appended or inserted, the array of references is resized. "

"Some cleverness is applied to improve the performance of appending items "

"repeatedly; when the array must be grown, some extra space is allocated so "

"the next few times don't require an actual resize."

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 "

"être étendu, un certain espace supplémentaire est alloué de sorte que pour "

"la prochaine fois, ceci ne nécessite plus un redimensionnement effectif."

#: faq/design.rst:446

msgid "How are dictionaries implemented in CPython?"

msgstr "Comment les dictionnaires sont-ils implémentés dans CPython ?"

#: faq/design.rst:448

msgid ""

"CPython's dictionaries are implemented as resizable hash tables. Compared "

"to B-trees, this gives better performance for lookup (the most common "

"operation by far) under most circumstances, and the implementation is "

"simpler."

msgstr ""

"Les dictionnaires CPython sont implémentés sous forme de tables de hachage "

"redimensionnables. Par rapport aux *B-trees*, cela donne de meilleures "

"performances pour la recherche (l'opération la plus courante de loin) dans "

"la plupart des circonstances, et leur implémentation est plus simple."

#: faq/design.rst:452

#, fuzzy

msgid ""

"Dictionaries work by computing a hash code for each key stored in the "

"dictionary using the :func:`hash` built-in function. The hash code varies "

"widely depending on the key and a per-process seed; for example, "

"``'Python'`` could hash to ``-539294296`` while ``'python'``, a string that "

"differs by a single bit, could hash to ``1142331976``. The hash code is "

"then used to calculate a location in an internal array where the value will "

"be stored. Assuming that you're storing keys that all have different hash "

"values, this means that dictionaries take constant time -- *O*\\ (1), in Big-"

"O notation -- to retrieve a key."

msgstr ""

"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:463

msgid "Why must dictionary keys be immutable?"

msgstr "Pourquoi les clés du dictionnaire sont immuables ?"

#: faq/design.rst:465

msgid ""

"The hash table implementation of dictionaries uses a hash value calculated "

"from the key value to find the key. If the key were a mutable object, its "

"value could change, and thus its hash could also change. But since whoever "

"changes the key object can't tell that it was being used as a dictionary "

"key, it can't move the entry around in the dictionary. Then, when you try "

"to look up the same object in the dictionary it won't be found because its "

"hash value is different. If you tried to look up the old value it wouldn't "

"be found either, because the value of the object found in that hash bin "

"would be different."

msgstr ""

"L'implémentation de la table de hachage des dictionnaires utilise une valeur "

"de hachage calculée à partir de la valeur de la clé pour trouver la clé elle-"

"même. Si la clé était un objet mutable, sa valeur peut changer, et donc son "

"hachage pourrait également changer. Mais toute personne modifiant l'objet "

"clé ne peut pas dire qu'elle a été utilisée comme une clé de dictionnaire. "

"Il ne peut déplacer l'entrée dans le dictionnaire. Ainsi, lorsque vous "

"essayez de rechercher le même objet dans le dictionnaire, il ne sera pas "

"disponible parce que sa valeur de hachage est différente. Si vous essayez de "

"chercher l'ancienne valeur, elle serait également introuvable car la valeur "

"de l'objet trouvé dans cet emplacement de hachage serait différente."

#: faq/design.rst:474

msgid ""

"If you want a dictionary indexed with a list, simply convert the list to a "

"tuple first; the function ``tuple(L)`` creates a tuple with the same entries "

"as the list ``L``. Tuples are immutable and can therefore be used as "

"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 "

"immuables et peuvent donc être utilisés comme clés du dictionnaire."

#: faq/design.rst:478

msgid "Some unacceptable solutions that have been proposed:"

msgstr "Certaines solutions insatisfaisantes ont été proposées :"

#: faq/design.rst:480

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 ""

"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:486

msgid ""

"would raise a :exc:`KeyError` exception because the id of the ``[1, 2]`` "

"used in the second line differs from that in the first line. In other "

"words, dictionary keys should be compared using ``==``, not "

"using :keyword:`is`."

msgstr ""

"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:490

msgid ""

"Make a copy when using a list as a key. This doesn't work because the list, "

"being a mutable object, could contain a reference to itself, and then the "

"copying code would run into an infinite loop."

msgstr ""

"Faire une copie lors de l'utilisation d'une liste en tant que clé. Cela ne "

"fonctionne pas puisque la liste, étant un objet mutable, pourrait contenir "

"une référence à elle-même ou avoir une boucle infinie au niveau du code "

"copié."

#: faq/design.rst:494

msgid ""

"Allow lists as keys but tell the user not to modify them. This would allow "

"a class of hard-to-track bugs in programs when you forgot or modified a list "

"by accident. It also invalidates an important invariant of dictionaries: "

"every value in ``d.keys()`` is usable as a key of the dictionary."

msgstr ""

"Autoriser les listes en tant que clés, mais indiquer à l'utilisateur de ne "