'Reference Compound Statements' Translation completed

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

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