forked from AFPy/python-docs-fr
'Reference Compound Statements' Translation completed
This commit is contained in:
parent
31c80b4bb1
commit
906c251e2e
|
@ -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."
|
||||
|
|
|
@ -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:"
|
||||
|
|
Loading…
Reference in New Issue
Block a user