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

'Reference Compound Statements' Translation completed

Browse source
This commit is contained in:
Christophe Nanteuil 2018-06-24 12:11:59 +02:00
commit 906c251e2e
2 changed files with 392 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

406
reference/compound_stmts.po
View file

@ -8,18 +8,18 @@ msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2017-12-01 07:43+0100\n"
"PO-Revision-Date: 2017-08-10 00:54+0200\n"
"PO-Revision-Date: 2018-06-24 11:38+0200\n"
"Last-Translator: Julien Palard <julien@palard.fr>\n"
"Language-Team: \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 1.8.11\n"
"X-Generator: Poedit 2.0.2\n"
#: ../Doc/reference/compound_stmts.rst:5
msgid "Compound statements"
msgstr ""
msgstr "Instructions composées"
#: ../Doc/reference/compound_stmts.rst:9
msgid ""
@ -28,6 +28,11 @@ msgid ""
"compound statements span multiple lines, although in simple incarnations a "
"whole compound statement may be contained in one line."
msgstr ""
"Les instructions composées contiennent d'autres (groupes d´) instructions ; "
"elles affectent ou contrôlent l'exécution de ces autres instructions d'une "
"manière ou d'une autre. En général, une instruction composée couvrent "
"plusieurs lignes bien que, dans sa forme la plus simple, une instruction "
"composée peut tenir sur une seule ligne."
#: ../Doc/reference/compound_stmts.rst:14
msgid ""
@ -38,6 +43,13 @@ msgid ""
"code around a block of code. Function and class definitions are also "
"syntactically compound statements."
msgstr ""
"Les instructions :keyword:`if`, :keyword:`while` et :keyword:`for` "
"implémentent les constructions classiques de contrôle de flux. :keyword:"
"`try` spécifie des gestionnaires d'exception et du code de nettoyage pour un "
"groupe d'instructions, tandis que l'instruction :keyword:`with` permet "
"l'exécution de code d'initialisation et de finalisation autour d'un bloc de "
"code. Les définitions de fonctions et de classes sont également, au sens "
"syntaxique, des instructions composées."
#: ../Doc/reference/compound_stmts.rst:25
msgid ""
@ -53,6 +65,19 @@ msgid ""
"clear to which :keyword:`if` clause a following :keyword:`else` clause would "
"belong::"
msgstr ""
"Une instruction composée comporte une ou plusieurs \"clauses\". Une clause "
"se compose d'un en-tête et d'une \"suite\". Les en-têtes des clauses d'une "
"instruction composée particulière sont toutes placées au même niveau "
"d'indentation. Chaque en-tête de clause commence par un mot-clé spécifique "
"et se termine par le caractère deux-points (`:`) ; une suite est un groupe "
"d'instructions contrôlées par une clause ; une suite se compose, après les "
"deux points de l'en-tête, soit d'une ou plusieurs instructions simples "
"séparées par des points-virgules si elles sont sur la même ligne que l'en-"
"tête, soit d'une ou plusieurs instructions en retrait sur les lignes "
"suivantes. Seule cette dernière forme d'une suite peut contenir des "
"instructions composées ; ce qui suit n'est pas licite, principalement parce "
"qu'il ne serait pas clair de savoir à quelle clause :keyword:`if` se "
"rapporterait une clause :keyword:`else` placée en fin de ligne :"
#: ../Doc/reference/compound_stmts.rst:38
msgid ""
@ -60,10 +85,13 @@ msgid ""
"so that in the following example, either all or none of the :func:`print` "
"calls are executed::"
msgstr ""
"Notez également que le point-virgule se lie plus étroitement que le deux-"
"points dans ce contexte, de sorte que dans l'exemple suivant, soit tous les "
"appels :func:`print` sont exécutés, soit aucun ne l'est :"
#: ../Doc/reference/compound_stmts.rst:44
msgid "Summarizing:"
msgstr ""
msgstr "En résumé :"
#: ../Doc/reference/compound_stmts.rst:66
msgid ""
@ -73,12 +101,21 @@ msgid ""
"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"
"keyword:`if` statements to be indented)."
msgstr ""
"Notez que ces instructions se terminent toujours par un lexème ``NEWLINE`` "
"suivi éventuellement d'un ``DEDENT``. Notez également que les clauses "
"facultatives qui suivent commencent toujours par un mot-clé qui ne peut pas "
"commencer une instruction. Ainsi, il n'y a pas d'ambiguïté (le problème du :"
"keyword:`else` dont on ne sait pas à quel ``if`` il est relié est résolu en "
"Python en exigeant que des instructions :keyword:`if` imbriquées soient "
"indentées les unes par rapport aux autres)."
#: ../Doc/reference/compound_stmts.rst:72
msgid ""
"The formatting of the grammar rules in the following sections places each "
"clause on a separate line for clarity."
msgstr ""
"L'agencement des règles de grammaire dans les sections qui suivent place "
"chaque clause sur une ligne séparée pour plus de clarté."
#: ../Doc/reference/compound_stmts.rst:81
msgid "The :keyword:`if` statement"
@ -87,6 +124,8 @@ msgstr "L'instruction :keyword:`if`"
#: ../Doc/reference/compound_stmts.rst:90
msgid "The :keyword:`if` statement is used for conditional execution:"
msgstr ""
"L'instruction :keyword:`if` est utilisée pour exécuter des instructions en "
"fonction d'une condition :"
#: ../Doc/reference/compound_stmts.rst:97
msgid ""
@ -97,6 +136,12 @@ msgid ""
"expressions are false, the suite of the :keyword:`else` clause, if present, "
"is executed."
msgstr ""
"Elle sélectionne exactement une des suites en évaluant les expressions une "
"par une jusqu'à ce qu'une soit vraie (voir la section :ref:`booleans` pour "
"la définition de vrai et faux) ; ensuite cette suite est exécutée (et aucune "
"autre partie de l'instruction :keyword:`if` n'est exécutée ou évaluée). Si "
"toutes les expressions sont fausses, la suite de la clause :keyword:`else`, "
"si elle existe, est exécutée."
#: ../Doc/reference/compound_stmts.rst:107
msgid "The :keyword:`while` statement"
@ -107,6 +152,8 @@ msgid ""
"The :keyword:`while` statement is used for repeated execution as long as an "
"expression is true:"
msgstr ""
"L'instruction :keyword:`while` est utilisée pour exécuter des instructions "
"de manière répétée tant qu'une expression est vraie :"
#: ../Doc/reference/compound_stmts.rst:122
msgid ""
@ -115,6 +162,10 @@ msgid ""
"the suite of the :keyword:`else` clause, if present, is executed and the "
"loop terminates."
msgstr ""
"Python évalue l'expression de manière répétée et, tant qu'elle est vraie, "
"exécute la première suite ; si l'expression est fausse (ce qui peut arriver "
"même lors du premier test), la suite de la clause :keyword:`else`, si elle "
"existe, est exécutée et la boucle se termine."
#: ../Doc/reference/compound_stmts.rst:131
msgid ""
@ -123,6 +174,10 @@ msgid ""
"statement executed in the first suite skips the rest of the suite and goes "
"back to testing the expression."
msgstr ""
"Une instruction :keyword:`break` exécutée dans la première suite termine la "
"boucle sans exécuter la suite de la clause :keyword:`else`. Une instruction :"
"keyword:`continue` exécutée dans la première suite saute le reste de la "
"suite et retourne au test de l'expression."
#: ../Doc/reference/compound_stmts.rst:140
msgid "The :keyword:`for` statement"
@ -133,6 +188,9 @@ msgid ""
"The :keyword:`for` statement is used to iterate over the elements of a "
"sequence (such as a string, tuple or list) or other iterable object:"
msgstr ""
"L'instruction :keyword:`for` est utilisée pour itérer sur les éléments d'une "
"séquence (par exemple une chaîne, un tuple ou une liste) ou un autre objet "
"itérable :"
#: ../Doc/reference/compound_stmts.rst:160
msgid ""
@ -146,6 +204,17 @@ msgid ""
"exception), the suite in the :keyword:`else` clause, if present, is "
"executed, and the loop terminates."
msgstr ""
"La liste des expressions (*expression_list* dans la grammaire ci-dessus) est "
"évaluée une seule fois ; elle doit produire un objet itérable. Un itérateur "
"est créé pour le résultat de cette liste d'expression. La suite est ensuite "
"exécutée une fois pour chaque élément fourni par l'itérateur, dans l'ordre "
"renvoyé par l'itérateur. Chaque élément est assigné, à tour de rôle, à la "
"liste cible (*target_list* dans la grammaire ci-dessus) en utilisant les "
"règles des assignations (voir :ref:`assignment`), et ensuite la suite est "
"exécutée. Lorsque les éléments sont épuisés (ce qui est immédiat lorsque la "
"séquence est vide ou si un itérateur lève une exception :exc:"
"`StopIteration`), la suite de la clause :keyword:`else`, si elle existe, est "
"exécutée et la boucle se termine."
#: ../Doc/reference/compound_stmts.rst:173
msgid ""
@ -155,6 +224,11 @@ msgid ""
"continues with the next item, or with the :keyword:`else` clause if there is "
"no next item."
msgstr ""
"Une instruction :keyword:`break` exécutée dans la première suite termine la "
"boucle sans exécuter la suite de la clause :keyword:`else`. Une instruction :"
"keyword:`continue` exécutée dans la première suite saute le reste de la "
"suite et continue avec l'élément suivant, ou avec la clause :keyword:`else` "
"s'il n'y a pas d'élément suivant."
#: ../Doc/reference/compound_stmts.rst:179
msgid ""
@ -162,6 +236,9 @@ msgid ""
"overwrites all previous assignments to those variables including those made "
"in the suite of the for-loop::"
msgstr ""
"La boucle for effectue des affectations aux variables de la liste cible, ce "
"qui écrase toutes les affectations antérieures de ces variables, y compris "
"celles effectuées dans la suite de la boucle for ::"
#: ../Doc/reference/compound_stmts.rst:193
msgid ""
@ -171,6 +248,12 @@ msgid ""
"integers suitable to emulate the effect of Pascal's ``for i := a to b do``; "
"e.g., ``list(range(3))`` returns the list ``[0, 1, 2]``."
msgstr ""
"Les noms dans la liste cible ne sont pas supprimés lorsque la boucle est "
"terminée mais, si la séquence est vide, ils n'auront pas du tout été "
"assignés par la boucle. Petite astuce : la fonction intégrée :func:`range` "
"renvoie un itérateur sur des entiers approprié pour émuler la boucle "
"classique en Pascal sur des entiers ``for i := a to b do`` ; par exemple, "
"``list(range(3))`` renvoie la liste ``[0, 1, 2]``."
#: ../Doc/reference/compound_stmts.rst:205
msgid ""
@ -186,6 +269,18 @@ msgid ""
"This can lead to nasty bugs that can be avoided by making a temporary copy "
"using a slice of the whole sequence, e.g., ::"
msgstr ""
"Il y a une subtilité lorsque la séquence est modifiée par la boucle (cela ne "
"peut se produire que pour les séquences mutables, c'est-à-dire les listes). "
"Un compteur interne est utilisé pour savoir quel est l'élément suivant, et "
"ce compteur est incrémenté à chaque itération. Lorsqu'il a atteint la "
"longueur de la séquence, la boucle se termine. Cela signifie que si la suite "
"supprime l'élément courant (ou un élément précédent) de la séquence, "
"l'élément suivant est sauté (puisqu'il reçoit l'indice de l'élément courant "
"qui a déjà été traité). De même, si la suite insère un élément avant "
"l'élément courant, l'élément courant est traité une deuxième fois à la "
"prochaine itération. Ceci peut conduire à de méchants bugs, que vous pouvez "
"éviter en effectuant une copie temporaire d'une tranche ou de la séquence "
"complète, par exemple ::"
#: ../Doc/reference/compound_stmts.rst:226
msgid "The :keyword:`try` statement"
@ -196,6 +291,8 @@ msgid ""
"The :keyword:`try` statement specifies exception handlers and/or cleanup "
"code for a group of statements:"
msgstr ""
"L'instruction :keyword:`try` spécifie les gestionnaires d'exception ou le "
"code de nettoyage pour un groupe d'instructions :"
#: ../Doc/reference/compound_stmts.rst:247
msgid ""
@ -211,12 +308,28 @@ msgid ""
"or a base class of the exception object or a tuple containing an item "
"compatible with the exception."
msgstr ""
"La ou les clauses :keyword:`except` spécifient un ou plusieurs gestionnaires "
"d'exceptions. Si aucune exception ne se produit dans la clause :keyword:"
"`try`, aucun gestionnaire d'exception n'est exécuté. Lorsqu'une exception se "
"produit dans la suite de :keyword:`try`, Python recherche un gestionnaire "
"d'exception. Cette recherche inspecte les clauses ``except``, l'une après "
"l'autre, jusqu'à trouver une correspondance. Une clause ``except`` vide "
"(c'est-à-dire sans expression), si elle est présente, doit être la "
"dernière ; elle correspond à toute exception. Pour une clause ``except`` "
"avec une expression, cette expression est évaluée et la clause correspond si "
"l'objet résultant est \"compatible\" avec l'exception. Un objet est réputé "
"compatible avec une exception s'il est la classe ou une classe de base de "
"l'objet exception ou si c'est un tuple contenant un élément qui est "
"compatible avec l'exception."
#: ../Doc/reference/compound_stmts.rst:258
msgid ""
"If no except clause matches the exception, the search for an exception "
"handler continues in the surrounding code and on the invocation stack. [#]_"
msgstr ""
"Si aucune clause ``except`` ne correspond à l'exception, la recherche d'un "
"gestionnaire d'exception se poursuit dans le code englobant et dans la pile "
"d'appels [#]_."
#: ../Doc/reference/compound_stmts.rst:261
msgid ""
@ -226,6 +339,11 @@ msgid ""
"(it is treated as if the entire :keyword:`try` statement raised the "
"exception)."
msgstr ""
"Si l'évaluation d'une expression dans l'en-tête d'une clause ``except`` lève "
"une exception, la recherche initiale d'un gestionnaire est annulée et une "
"recherche commence pour la nouvelle exception dans le code englobant et dans "
"la pile d'appels (c'est traité comme si l'instruction :keyword:`try` avait "
"levé l'exception)."
#: ../Doc/reference/compound_stmts.rst:266
msgid ""
@ -238,16 +356,27 @@ msgid ""
"the try clause of the inner handler, the outer handler will not handle the "
"exception.)"
msgstr ""
"Lorsqu'une clause d'exception correspond, l'exception est assignée à la "
"cible spécifiée après le mot-clé :keyword:`as` dans cette clause ``except``, "
"si cette cible existe, et la suite de clause ``except`` est exécutée. "
"Toutes les clauses ``except`` doivent avoir un bloc exécutable. Lorsque la "
"fin de ce bloc est atteinte, l'exécution continue normalement après "
"l'ensemble de l'instruction ``try`` (cela signifie que si deux gestionnaires "
"imbriqués existent pour la même exception, et que l'exception se produit "
"dans la clause ``try`` du gestionnaire interne, le gestionnaire externe ne "
"gère pas l'exception)."
#: ../Doc/reference/compound_stmts.rst:274
msgid ""
"When an exception has been assigned using ``as target``, it is cleared at "
"the end of the except clause. This is as if ::"
msgstr ""
"Lorsqu'une exception a été assignée en utilisant ``as cible``, elle est "
"effacée à la fin de la clause ``except``. C'est comme si ::"
#: ../Doc/reference/compound_stmts.rst:280
msgid "was translated to ::"
msgstr ""
msgstr "avait été traduit en ::"
#: ../Doc/reference/compound_stmts.rst:288
msgid ""
@ -257,6 +386,12 @@ msgid ""
"frame, keeping all locals in that frame alive until the next garbage "
"collection occurs."
msgstr ""
"Cela veut dire que l'exception doit être assignée à un nom différent pour "
"pouvoir s'y référer après la clause ``except``. Les exceptions sont effacées "
"parce qu'avec la trace de la pile d'appels qui leur est attachée, elles "
"créent un cycle dans les pointeurs de références (avec le cadre de la pile), "
"ce qui conduit à conserver tous les noms locaux de ce cadre en mémoire "
"jusqu'au passage du ramasse-miettes."
#: ../Doc/reference/compound_stmts.rst:297
msgid ""
@ -268,6 +403,14 @@ msgid ""
"occurred. :func:`sys.exc_info` values are restored to their previous values "
"(before the call) when returning from a function that handled an exception."
msgstr ""
"Avant l'exécution de la suite d'une clause ``except``, les détails de "
"l'exception sont stockés dans le module :mod:`sys` et sont accessibles "
"*via* :func:`sys.exc_info`. :func:`sys.exc_info` renvoie un 3-uplet composé "
"de la classe de l'exception, de l'instance d'exception et d'un objet trace "
"(voir la section :ref:`types`) identifiant le point du programme où "
"l'exception est survenue. Les valeurs de :func:`sys.exc_info` sont remises à "
"leurs anciennes valeurs (celles d'avant l'appel) au retour d'une fonction "
"qui a géré une exception."
#: ../Doc/reference/compound_stmts.rst:311
msgid ""
@ -275,6 +418,10 @@ msgid ""
"off the end of the :keyword:`try` clause. [#]_ Exceptions in the :keyword:"
"`else` clause are not handled by the preceding :keyword:`except` clauses."
msgstr ""
"La clause optionnelle :keyword:`else` n'est exécutée que si l'exécution "
"atteint la fin de la clause :keyword:`try` [#]_. Les exceptions dans la "
"clause :keyword:`else` ne sont pas gérées par les clauses :keyword:`except` "
"qui la précèdent."
#: ../Doc/reference/compound_stmts.rst:317
msgid ""
@ -288,12 +435,24 @@ msgid ""
"new exception. If the :keyword:`finally` clause executes a :keyword:`return` "
"or :keyword:`break` statement, the saved exception is discarded::"
msgstr ""
"Si :keyword:`finally` est présente, elle spécifie un gestionnaire de "
"\"nettoyage\". La clause :keyword:`try` est exécutée, y compris les clauses :"
"keyword:`except` et :keyword:`else`. Si une exception se produit dans l'une "
"des clauses et n'est pas traitée, l'exception est temporairement "
"sauvegardée. La clause :keyword:`finally` est exécutée. S'il y a une "
"exception sauvegardée, elle est re-levée à la fin de la clause :keyword:"
"`finally`. Si la clause :keyword:`finally` lève une autre exception, "
"l'exception sauvegardée est définie comme le contexte de la nouvelle "
"exception. Si la clause :keyword:`finally` exécute une instruction :keyword:"
"`return` ou :keyword:`break`, l'exception sauvegardée est jetée ::"
#: ../Doc/reference/compound_stmts.rst:336
msgid ""
"The exception information is not available to the program during execution "
"of the :keyword:`finally` clause."
msgstr ""
"L'information relative à l'exception n'est pas disponible pour le programme "
"pendant l'exécution de la clause :keyword:`finally`."
#: ../Doc/reference/compound_stmts.rst:344
msgid ""
@ -304,6 +463,13 @@ msgid ""
"`finally` clause. (The reason is a problem with the current implementation "
"--- this restriction may be lifted in the future)."
msgstr ""
"Lorsqu'une instruction :keyword:`return`, :keyword:`break` ou :keyword:"
"`continue` est exécutée dans la suite d'une instruction :keyword:`try` d'une "
"construction :keyword:`try`...\\ :keyword:`finally`, la clause :keyword:"
"`finally` est aussi exécutée à la sortie. Une instruction :keyword:"
"`continue` est illégale dans une clause :keyword:`finally` (la raison est "
"que l'implémentation actuelle pose problème --- il est possible que cette "
"restriction soit levée dans le futur)."
#: ../Doc/reference/compound_stmts.rst:351
msgid ""
@ -312,6 +478,10 @@ msgid ""
"keyword:`return` statement executed in the :keyword:`finally` clause will "
"always be the last one executed::"
msgstr ""
"La valeur de retour d'une fonction est déterminée par la dernière "
"instruction :keyword:`return` exécutée. Puisque la clause :keyword:"
"`finally` s'exécute toujours, une instruction :keyword:`return` exécutée "
"dans le :keyword:`finally` sera toujours la dernière clause exécutée ::"
#: ../Doc/reference/compound_stmts.rst:365
msgid ""
@ -319,6 +489,10 @@ msgid ""
"`exceptions`, and information on using the :keyword:`raise` statement to "
"generate exceptions may be found in section :ref:`raise`."
msgstr ""
"Vous trouvez des informations supplémentaires relatives aux exceptions dans "
"la section :ref:`exceptions` et, dans la section :ref:`raise`, des "
"informations relatives à l'utilisation de l'instruction :keyword:`raise` "
"pour produire des exceptions."
#: ../Doc/reference/compound_stmts.rst:374
msgid "The :keyword:`with` statement"
@ -331,32 +505,46 @@ msgid ""
"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"
"`finally` usage patterns to be encapsulated for convenient reuse."
msgstr ""
"L'instruction :keyword:`with` est utilisée pour encapsuler l'exécution d'un "
"bloc avec des méthodes définies par un gestionnaire de contexte (voir la "
"section :ref:`context-managers`). Cela permet d'utiliser de manière simple "
"le patron de conception classique :keyword:`try`....\\ :keyword:`except`..."
"\\ \\ :keyword:`finally`."
#: ../Doc/reference/compound_stmts.rst:389
msgid ""
"The execution of the :keyword:`with` statement with one \"item\" proceeds as "
"follows:"
msgstr ""
"L'exécution de l'instruction :keyword:`with` avec un seul \"élément"
"\" (*item* dans la grammaire) se déroule comme suit :"
#: ../Doc/reference/compound_stmts.rst:391
msgid ""
"The context expression (the expression given in the :token:`with_item`) is "
"evaluated to obtain a context manager."
msgstr ""
"L'expression de contexte (l'expression donnée dans le :token:`with_item`) "
"est évaluée pour obtenir un gestionnaire de contexte."
#: ../Doc/reference/compound_stmts.rst:394
msgid "The context manager's :meth:`__exit__` is loaded for later use."
msgstr ""
"La méthode :meth:`__exit__` du gestionnaire de contexte est chargée pour une "
"utilisation ultérieure."
#: ../Doc/reference/compound_stmts.rst:396
msgid "The context manager's :meth:`__enter__` method is invoked."
msgstr ""
msgstr "La méthode :meth:`__enter__` du gestionnaire de contexte est invoquée."
#: ../Doc/reference/compound_stmts.rst:398
msgid ""
"If a target was included in the :keyword:`with` statement, the return value "
"from :meth:`__enter__` is assigned to it."
msgstr ""
"Si une cible (*target* dans la grammaire ci-dessus) a été incluse dans "
"l'instruction :keyword:`with`, la valeur de retour de :meth:`__enter__` lui "
"est assignée."
#: ../Doc/reference/compound_stmts.rst:403
msgid ""
@ -366,10 +554,15 @@ msgid ""
"it will be treated the same as an error occurring within the suite would be. "
"See step 6 below."
msgstr ""
"L'instruction :keyword:`with` garantit que si la méthode :meth:`__enter__` "
"se termine sans erreur, alors la méthode :meth:`__exit__` est toujours "
"appelée. Ainsi, si une erreur se produit pendant l'assignation à la liste "
"cible, elle est traitée de la même façon qu'une erreur se produisant dans la "
"suite. Voir l'étape 6 ci-dessous."
#: ../Doc/reference/compound_stmts.rst:409
msgid "The suite is executed."
msgstr ""
msgstr "La suite est exécutée."
#: ../Doc/reference/compound_stmts.rst:411
msgid ""
@ -378,6 +571,10 @@ msgid ""
"arguments to :meth:`__exit__`. Otherwise, three :const:`None` arguments are "
"supplied."
msgstr ""
"La méthode :meth:`__exit__` du gestionnaire de contexte est invoquée. Si "
"une exception a causé la sortie de la suite, son type, sa valeur et sa pile "
"d'appels sont passés en arguments à :meth:`__exit__`. Sinon, trois "
"arguments :const:`None` sont fournis."
#: ../Doc/reference/compound_stmts.rst:416
msgid ""
@ -386,6 +583,11 @@ msgid ""
"value was true, the exception is suppressed, and execution continues with "
"the statement following the :keyword:`with` statement."
msgstr ""
"Si l'on est sorti de la suite en raison d'une exception et que la valeur de "
"retour de la méthode :meth:`__exit__` était fausse, l'exception est re-"
"levée. Si la valeur de retour était vraie, l'exception est supprimée et "
"l'exécution continue avec l'instruction qui suit l'instruction :keyword:"
"`with`."
#: ../Doc/reference/compound_stmts.rst:421
msgid ""
@ -393,12 +595,17 @@ msgid ""
"value from :meth:`__exit__` is ignored, and execution proceeds at the normal "
"location for the kind of exit that was taken."
msgstr ""
"Si l'on est sorti de la suite pour une raison autre qu'une exception, la "
"valeur de retour de :meth:`__exit__` est ignorée et l'exécution se poursuit "
"à l'endroit normal pour le type de sortie prise."
#: ../Doc/reference/compound_stmts.rst:425
msgid ""
"With more than one item, the context managers are processed as if multiple :"
"keyword:`with` statements were nested::"
msgstr ""
"Avec plus d'un élément, les gestionnaires de contexte sont traités comme si "
"plusieurs instructions :keyword:`with` étaient imbriquées ::"
#: ../Doc/reference/compound_stmts.rst:431
#: ../Doc/reference/compound_stmts.rst:622
@ -407,27 +614,31 @@ msgstr "est équivalente à : ::"
#: ../Doc/reference/compound_stmts.rst:437
msgid "Support for multiple context expressions."
msgstr ""
msgstr "Prise en charge de multiples expressions de contexte."
#: ../Doc/reference/compound_stmts.rst:443
msgid ":pep:`343` - The \"with\" statement"
msgstr ":pep:`343` - The \"with\" statement"
msgstr ":pep:`343` -- L'instruction \"with\""
#: ../Doc/reference/compound_stmts.rst:443
msgid ""
"The specification, background, and examples for the Python :keyword:`with` "
"statement."
msgstr ""
"Les spécifications, les motivations et des exemples pour l'instruction "
"Python :keyword:`with`."
#: ../Doc/reference/compound_stmts.rst:454
msgid "Function definitions"
msgstr ""
msgstr "Définition de fonctions"
#: ../Doc/reference/compound_stmts.rst:466
msgid ""
"A function definition defines a user-defined function object (see section :"
"ref:`types`):"
msgstr ""
"Une définition de fonction définit un objet fonction allogène (voir la "
"section :ref:`types`) :"
#: ../Doc/reference/compound_stmts.rst:483
msgid ""
@ -437,12 +648,20 @@ msgid ""
"a reference to the current global namespace as the global namespace to be "
"used when the function is called."
msgstr ""
"Une définition de fonction est une instruction qui est exécutée. Son "
"exécution lie le nom de la fonction, dans l'espace de noms local courant, à "
"un objet fonction (un objet qui encapsule le code exécutable de la "
"fonction). Cet objet fonction contient une référence à l'espace des noms "
"globaux courant comme espace des noms globaux à utiliser lorsque la fonction "
"est appelée."
#: ../Doc/reference/compound_stmts.rst:489
msgid ""
"The function definition does not execute the function body; this gets "
"executed only when the function is called. [#]_"
msgstr ""
"La définition de la fonction n'exécute pas le corps de la fonction ; elle "
"n'est exécutée que lorsque la fonction est appelée [#]_."
#: ../Doc/reference/compound_stmts.rst:495
msgid ""
@ -454,17 +673,26 @@ msgid ""
"function object. Multiple decorators are applied in nested fashion. For "
"example, the following code ::"
msgstr ""
"Une définition de fonction peut être encapsulée dans une ou plusieurs "
"expressions :term:`decorator` ; les décorateurs sont évalués lorsque la "
"fonction est définie, dans la portée qui contient la définition de "
"fonction ; le résultat doit être un appelable, qui est invoqué avec l'objet "
"fonction comme seul argument ; la valeur renvoyée est liée au nom de la "
"fonction en lieu et place de l'objet fonction. Lorsqu'il y a plusieurs "
"décorateurs, ils sont appliqués par imbrication ; par exemple, le code "
"suivant ::"
#: ../Doc/reference/compound_stmts.rst:506
#: ../Doc/reference/compound_stmts.rst:649
msgid "is roughly equivalent to ::"
msgstr ""
msgstr "est à peu près équivalent à ::"
#: ../Doc/reference/compound_stmts.rst:511
msgid ""
"except that the original function is not temporarily bound to the name "
"``func``."
msgstr ""
"sauf que la fonction originale n'est pas temporairement liée au nom ``func``."
#: ../Doc/reference/compound_stmts.rst:517
msgid ""
@ -476,6 +704,14 @@ msgid ""
"up until the \"``*``\" must also have a default value --- this is a "
"syntactic restriction that is not expressed by the grammar."
msgstr ""
"Lorsqu'un ou plusieurs :term:`paramètres <parameter>` sont de la forme "
"*parameter* ``=`` *expression*, on dit que la fonction a des \"valeurs de "
"paramètres par défaut\". Pour un paramètre avec une valeur par défaut, l´:"
"term:`argument` correspondant peut être omis lors de l'appel, la valeur par "
"défaut du paramètre est alors utilisée. Si un paramètre a une valeur par "
"défaut, tous les paramètres suivants jusqu'à \"``*``\" doivent aussi avoir "
"une valeur par défaut --- ceci est une restriction syntaxique qui n'est pas "
"exprimée dans la grammaire."
#: ../Doc/reference/compound_stmts.rst:525
msgid ""
@ -489,6 +725,16 @@ msgid ""
"what was intended. A way around this is to use ``None`` as the default, and "
"explicitly test for it in the body of the function, e.g.::"
msgstr ""
"**Les valeurs par défaut des paramètres sont évaluées de la gauche vers la "
"droite quand la définition de la fonction est exécutée**. Cela signifie que "
"l'expression est évaluée une fois, lorsque la fonction est définie, et que "
"c'est la même valeur \"pré-calculée\" qui est utilisée à chaque appel. C'est "
"particulièrement important à comprendre lorsqu'un paramètre par défaut est "
"un objet mutable, tel qu'une liste ou un dictionnaire : si la fonction "
"modifie l'objet (par exemple en ajoutant un élément à une liste), la valeur "
"par défaut est modifiée. En général, ce n'est pas l'effet voulu. Une façon "
"d'éviter cet écueil est d'utiliser ``None`` par défaut et de tester "
"explicitement la valeur dans le corps de la fonction. Par exemple ::"
#: ../Doc/reference/compound_stmts.rst:545
msgid ""
@ -503,6 +749,18 @@ msgid ""
"Parameters after \"``*``\" or \"``*identifier``\" are keyword-only "
"parameters and may only be passed used keyword arguments."
msgstr ""
"La sémantique de l'appel de fonction est décrite plus en détail dans la "
"section :ref:`calls`. Un appel de fonction assigne toujours des valeurs à "
"tous les paramètres mentionnés dans la liste des paramètres, soit à partir "
"d'arguments positionnels, d'arguments par mots-clés ou de valeurs par "
"défaut. S'il y a un paramètre de la forme \"``*identifier``\", il est "
"initialisé à un tuple recevant les paramètres positionnels en surplus, la "
"valeur par défaut étant le tuple vide. S'il y a un paramètre de la forme "
"\"``**identifier``\", il est initialisé à un nouveau tableau associatif "
"ordonné qui récupère tous les arguments par mot-clé en surplus, la valeur "
"par défaut étant un tableau associatif vide. Les paramètres après \"``*``\" "
"ou \"``*identifier``\" sont forcément des paramètres par mot-clé et ne "
"peuvent être passés qu'en utilisant des arguments par mot-clé."
#: ../Doc/reference/compound_stmts.rst:558
msgid ""
@ -517,6 +775,18 @@ msgid ""
"values are available as values of a dictionary keyed by the parameters' "
"names in the :attr:`__annotations__` attribute of the function object."
msgstr ""
"Les paramètres peuvent avoir des annotations sous la forme \"``: expression``"
"\" après le nom du paramètre. Tout paramètre peut avoir une annotation, "
"même ceux de la forme ``*identificateur`` ou ``**identificateur``. Les "
"fonctions peuvent avoir une annotation pour la valeur de retour, sous la "
"forme \"``-> expression``\" après la liste des paramètres. Ces annotations "
"peuvent être toute expression Python valide et sont évaluées lorsque la "
"définition de fonction est exécutée. Les annotations peuvent être évaluées "
"dans un ordre différent de celui où elles apparaissent dans le code source. "
"La présence d'annotations ne modifie la sémantique d'une fonction. Les "
"valeurs des annotations sont accessibles comme valeurs d'un dictionnaire "
"dont les clés sont les noms des paramètres et défini comme attribut :attr:"
"`__annotations__` de l'objet fonction."
#: ../Doc/reference/compound_stmts.rst:571
msgid ""
@ -529,6 +799,15 @@ msgid ""
"keyword:`def`\" form is actually more powerful since it allows the execution "
"of multiple statements and annotations."
msgstr ""
"Il est aussi possible de créer des fonctions anonymes (fonctions non liées à "
"un nom), pour une utilisation immédiate dans des expressions Utilisez des "
"expressions lambda, décrites dans la section :ref:`lambda`. Notez qu'une "
"expression lambda est simplement un raccourci pour définir une fonction "
"simple ; une fonction définie par une instruction \":keyword:`def`\" peut "
"être passée (en argument) ou assignée à un autre nom, tout comme une "
"fonction définie par une expression lambda. La forme \":keyword:`def`\" est "
"en fait plus puissante puisqu'elle permet l'exécution de plusieurs "
"instructions et les annotations."
#: ../Doc/reference/compound_stmts.rst:579
msgid ""
@ -538,22 +817,30 @@ msgid ""
"function can access the local variables of the function containing the def. "
"See section :ref:`naming` for details."
msgstr ""
"**Note pour les programmeurs :** les fonctions sont des objets de première "
"classe. Une instruction \"``def``\" exécutée à l'intérieur d'une définition "
"de fonction définit une fonction locale qui peut être renvoyée ou passée en "
"tant qu'argument. Les variables libres utilisées dans la fonction imbriquée "
"ont accès aux variables locales de la fonction contenant le \"``def``\". "
"Voir la section :ref:`naming` pour plus de détails."
#: ../Doc/reference/compound_stmts.rst:587
msgid ":pep:`3107` - Function Annotations"
msgstr ""
msgstr ":pep:`3107` -- Annotations de fonctions"
#: ../Doc/reference/compound_stmts.rst:588
msgid "The original specification for function annotations."
msgstr ""
msgstr "La spécification originale pour les annotations de fonctions."
#: ../Doc/reference/compound_stmts.rst:594
msgid "Class definitions"
msgstr ""
msgstr "Définition de classes"
#: ../Doc/reference/compound_stmts.rst:606
msgid "A class definition defines a class object (see section :ref:`types`):"
msgstr ""
"Une définition de classe définit un objet classe (voir la section :ref:"
"`types`) :"
#: ../Doc/reference/compound_stmts.rst:613
msgid ""
@ -563,6 +850,13 @@ msgid ""
"allows subclassing. Classes without an inheritance list inherit, by "
"default, from the base class :class:`object`; hence, ::"
msgstr ""
"Une définition de classe est une instruction qui est exécutée. La liste "
"d'héritage (*inheritance* entre crochets dans la grammaire ci-dessus) donne "
"habituellement une liste de classes de base (voir :ref:`metaclasses` pour "
"des utilisations plus avancées). Donc chaque élément de la liste doit "
"pouvoir être évalué comme un objet classe qui autorise les sous-classes. "
"Les classes sans liste d'héritage héritent, par défaut, de la classe de "
"base :class:`object` ; d'où ::"
#: ../Doc/reference/compound_stmts.rst:627
msgid ""
@ -575,6 +869,15 @@ msgid ""
"attribute dictionary. The class name is bound to this class object in the "
"original local namespace."
msgstr ""
"La suite de la classe est ensuite exécutée dans un nouveau cadre d'exécution "
"(voir :ref:`naming`), en utilisant un espace de noms local nouvellement créé "
"et l'espace de noms global d'origine (habituellement, la suite contient "
"principalement des définitions de fonctions). Lorsque la suite de la classe "
"termine son exécution, son cadre d'exécution est abandonné mais son espace "
"des noms locaux est sauvegardé [#]_. Un objet classe est alors créé en "
"utilisant la liste d'héritage pour les classes de base et l'espace de noms "
"sauvegardé comme dictionnaire des attributs. Le nom de classe est lié à "
"l'objet classe dans l'espace de noms local original."
#: ../Doc/reference/compound_stmts.rst:636
msgid ""
@ -583,22 +886,33 @@ msgid ""
"the class is created and only for classes that were defined using the "
"definition syntax."
msgstr ""
"L'ordre dans lequel les attributs sont définis dans le corps de la classe "
"est préservé dans le ``__dict__`` de la nouvelle classe. Notez que ceci "
"n'est fiable que juste après la création de la classe et seulement pour les "
"classes qui ont été définies en utilisant la syntaxe de définition."
#: ../Doc/reference/compound_stmts.rst:641
msgid ""
"Class creation can be customized heavily using :ref:`metaclasses "
"<metaclasses>`."
msgstr ""
"La création de classes peut être fortement personnalisée en utilisant les :"
"ref:`métaclasses <metaclasses>`."
#: ../Doc/reference/compound_stmts.rst:643
msgid "Classes can also be decorated: just like when decorating functions, ::"
msgstr ""
"Les classes peuvent aussi être décorées : comme pour les décorateurs de "
"fonctions ::"
#: ../Doc/reference/compound_stmts.rst:654
msgid ""
"The evaluation rules for the decorator expressions are the same as for "
"function decorators. The result is then bound to the class name."
msgstr ""
"Les règles d'évaluation pour les expressions de décorateurs sont les mêmes "
"que pour les décorateurs de fonctions. Le résultat est alors lié au nom de "
"la classe."
#: ../Doc/reference/compound_stmts.rst:657
msgid ""
@ -612,10 +926,22 @@ msgid ""
"<descriptors>` can be used to create instance variables with different "
"implementation details."
msgstr ""
"**Note pour les programmeurs :** les variables définies dans la définition "
"de classe sont des attributs de classe ; elles sont partagées par les "
"instances. Les attributs d'instance peuvent être définis dans une méthode en "
"utilisant ``self.name = value``. Les attributs de classe et d'instance sont "
"accessibles par la notation \"``self.name``\", et un attribut d'instance "
"masque un attribut de classe de même nom lorsqu'on y accède de cette façon. "
"Les attributs de classe peuvent être utilisés comme valeurs par défaut pour "
"les attributs d'instances, mais l'utilisation de valeurs mutables peut "
"conduire à des résultats inattendus. Les :ref:`descripteurs <descriptors>` "
"peuvent être utilisés pour créer des variables d'instances avec des détails "
"d'implémentation différents."
#: ../Doc/reference/compound_stmts.rst:669
msgid ":pep:`3115` - Metaclasses in Python 3 :pep:`3129` - Class Decorators"
msgstr ""
":pep:`3115` -- Métaclasses en Python 3 :pep:`3129` -- Décorateurs de classes"
#: ../Doc/reference/compound_stmts.rst:674
msgid "Coroutines"
@ -623,7 +949,7 @@ msgstr "Coroutines"
#: ../Doc/reference/compound_stmts.rst:682
msgid "Coroutine function definition"
msgstr ""
msgstr "Définition de fonctions coroutines"
#: ../Doc/reference/compound_stmts.rst:691
msgid ""
@ -633,26 +959,36 @@ msgid ""
"expressions, :keyword:`async for` and :keyword:`async with` can only be used "
"in coroutine bodies."
msgstr ""
"L'exécution de coroutines Python peut être suspendue et reprise à plusieurs "
"endroits (voir :term:`coroutine`). Dans le corps d'une coroutine, tout "
"identificateur ``await`` ou ``async`` devient un mots-clé réservé ; les "
"expressions :keyword:`await`, :keyword:`async for` et :keyword:`async with` "
"ne peuvent être utilisées que dans les corps de coroutines."
#: ../Doc/reference/compound_stmts.rst:697
msgid ""
"Functions defined with ``async def`` syntax are always coroutine functions, "
"even if they do not contain ``await`` or ``async`` keywords."
msgstr ""
"Les fonctions définies avec la syntaxe ``async def`` sont toujours des "
"fonctions coroutines, même si elles ne contiennent aucun mot-clé ``await`` "
"ou ``async``."
#: ../Doc/reference/compound_stmts.rst:700
msgid ""
"It is a :exc:`SyntaxError` to use ``yield from`` expressions in ``async "
"def`` coroutines."
msgstr ""
"C'est une :exc:`SyntaxError` d'utiliser une expression ``yield from`` dans "
"une coroutine ``async def``."
#: ../Doc/reference/compound_stmts.rst:703
msgid "An example of a coroutine function::"
msgstr ""
msgstr "Un exemple de fonction coroutine ::"
#: ../Doc/reference/compound_stmts.rst:714
msgid "The :keyword:`async for` statement"
msgstr ""
msgstr "L'instruction :keyword:`async for`"
#: ../Doc/reference/compound_stmts.rst:719
msgid ""
@ -660,56 +996,71 @@ msgid ""
"*iter* implementation, and :term:`asynchronous iterator` can call "
"asynchronous code in its *next* method."
msgstr ""
"Un :term:`itérable asynchrone <asynchronous iterable>` est capable d'appeler "
"du code asynchrone dans l'implémentation de sa méthode *iter* ; un :term:"
"`itérateur asynchrone <asynchronous iterator>` peut appeler du code "
"asynchrone dans sa méthode *next*."
#: ../Doc/reference/compound_stmts.rst:723
msgid ""
"The ``async for`` statement allows convenient iteration over asynchronous "
"iterators."
msgstr ""
"L'instruction ``async for`` permet d'itérer facilement sur des itérateurs "
"asynchrones."
#: ../Doc/reference/compound_stmts.rst:726
#: ../Doc/reference/compound_stmts.rst:766
msgid "The following code::"
msgstr ""
msgstr "Le code suivant ::"
#: ../Doc/reference/compound_stmts.rst:733
#: ../Doc/reference/compound_stmts.rst:771
msgid "Is semantically equivalent to::"
msgstr ""
msgstr "est sémantiquement équivalent à ::"
#: ../Doc/reference/compound_stmts.rst:748
msgid "See also :meth:`__aiter__` and :meth:`__anext__` for details."
msgstr ""
"Voir aussi :meth:`__aiter__` et :meth:`__anext__` pour plus de détails."
#: ../Doc/reference/compound_stmts.rst:750
msgid ""
"It is a :exc:`SyntaxError` to use ``async for`` statement outside of an :"
"keyword:`async def` function."
msgstr ""
"C'est une :exc:`SyntaxError` d'utiliser une instruction ``async for`` en "
"dehors d'une fonction :keyword:`async def`."
#: ../Doc/reference/compound_stmts.rst:758
msgid "The :keyword:`async with` statement"
msgstr ""
msgstr "L'instruction :keyword:`async with`"
#: ../Doc/reference/compound_stmts.rst:763
msgid ""
"An :term:`asynchronous context manager` is a :term:`context manager` that is "
"able to suspend execution in its *enter* and *exit* methods."
msgstr ""
"Un :term:`gestionnaire de contexte asynchrone <asynchronous context "
"manager>` est un :term:`gestionnaire de contexte <context manager>` qui est "
"capable de suspendre l'exécution dans ses méthodes *enter* et *exit*."
#: ../Doc/reference/compound_stmts.rst:786
msgid "See also :meth:`__aenter__` and :meth:`__aexit__` for details."
msgstr ""
"Voir aussi :meth:`__aenter__` et :meth:`__aexit__` pour plus de détails."
#: ../Doc/reference/compound_stmts.rst:788
msgid ""
"It is a :exc:`SyntaxError` to use ``async with`` statement outside of an :"
"keyword:`async def` function."
msgstr ""
"C'est une :exc:`SyntaxError` d'utiliser l'instruction ``async with`` en "
"dehors d'une fonction :keyword:`async def`."
#: ../Doc/reference/compound_stmts.rst:793
msgid ":pep:`492` - Coroutines with async and await syntax"
msgstr ""
msgstr ":pep:`492` -- Coroutines avec les syntaxes *async* et *await*"
#: ../Doc/reference/compound_stmts.rst:797
msgid "Footnotes"
@ -721,6 +1072,10 @@ msgid ""
"keyword:`finally` clause which happens to raise another exception. That new "
"exception causes the old one to be lost."
msgstr ""
"L'exception est propagée à la pile d'appels à moins qu'il n'y ait une "
"clause :keyword:`finally` qui lève une autre exception, ce qui entraîne la "
"perte de l'ancienne exception. Cette nouvelle exception entraîne la perte "
"pure et simple de l'ancienne."
#: ../Doc/reference/compound_stmts.rst:802
msgid ""
@ -728,6 +1083,9 @@ msgid ""
"or the execution of a :keyword:`return`, :keyword:`continue`, or :keyword:"
"`break` statement."
msgstr ""
"Actuellement, l'exécution \"atteint la fin\" sauf dans le cas d'une "
"exception, de l'exécution de l'instruction :keyword:`return`, :keyword:"
"`continue` ou :keyword:`break`."
#: ../Doc/reference/compound_stmts.rst:806
msgid ""
@ -735,6 +1093,9 @@ msgid ""
"transformed into the function's ``__doc__`` attribute and therefore the "
"function's :term:`docstring`."
msgstr ""
"Une chaîne littérale apparaissant comme première instruction dans le corps "
"de la fonction est transformée en attribut ``__doc__`` de la fonction et "
"donc en :term:`docstring` de la fonction."
#: ../Doc/reference/compound_stmts.rst:810
msgid ""
@ -742,3 +1103,6 @@ msgid ""
"transformed into the namespace's ``__doc__`` item and therefore the class's :"
"term:`docstring`."
msgstr ""
"Une chaîne littérale apparaissant comme première instruction dans le corps "
"de la classe est transformée en élément ``__doc__`` de l'espace de noms et "
"donc en :term:`docstring` de la classe."

13
reference/datamodel.po
View file

@ -8,7 +8,7 @@ msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-05-02 00:10+0200\n"
"PO-Revision-Date: 2018-05-01 18:54+0200\n"
"PO-Revision-Date: 2018-06-24 12:10+0200\n"
"Last-Translator: \n"
"Language-Team: \n"
"Language: fr\n"
@ -778,7 +778,7 @@ msgstr ""
#: ../Doc/reference/datamodel.rst:534
msgid "User-defined functions"
msgstr "Fonctions définies par l'utilisateur"
msgstr "Fonctions allogènes"
#: ../Doc/reference/datamodel.rst:448
msgid ""
@ -786,10 +786,11 @@ msgid ""
"section :ref:`function`). It should be called with an argument list "
"containing the same number of items as the function's formal parameter list."
msgstr ""
"Un objet fonction définie par l'utilisateur est créé par la définition d'une "
"fonction (voir la section :ref:`function`). Il doit être appelé avec une "
"liste d'arguments contenant le même nombre d'éléments que la liste des "
"paramètres formels de la fonction."
"Un objet fonction allogène (ou fonction définie par l'utilisateur, mais ce "
"n'est pas forcément l'utilisateur courant qui a défini cette fonction) est "
"créé par la définition d'une fonction (voir la section :ref:`function`). Il "
"doit être appelé avec une liste d'arguments contenant le même nombre "
"d'éléments que la liste des paramètres formels de la fonction."
#: ../Doc/reference/datamodel.rst:453
msgid "Special attributes:"