diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index 568ca407..d91d9dc4 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -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 \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 ` 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 " "`." msgstr "" +"La création de classes peut être fortement personnalisée en utilisant les :" +"ref:`métaclasses `." #: ../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 "" "` 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 ` " +"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 ` est capable d'appeler " +"du code asynchrone dans l'implémentation de sa méthode *iter* ; un :term:" +"`itérateur asynchrone ` 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 ` est un :term:`gestionnaire de contexte ` 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." diff --git a/reference/datamodel.po b/reference/datamodel.po index 457135ee..e1f2833b 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.po @@ -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:"