From 27d2e50887f0f53d66c30056e2e7b66a1e2a0233 Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Fri, 8 Dec 2023 00:20:15 +0000 Subject: [PATCH] Fin des fuzzies pour reference (#202) closes #36 Reviewed-on: https://git.afpy.org/AFPy/python-docs-fr/pulls/202 Reviewed-by: Yannick Gingras Co-authored-by: Christophe Nanteuil Co-committed-by: Christophe Nanteuil --- reference/compound_stmts.po | 385 +++++++++++----------- reference/expressions.po | 528 ++++++++++++++----------------- reference/simple_stmts.po | 254 +++++++-------- reference/toplevel_components.po | 36 +-- 4 files changed, 565 insertions(+), 638 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index 46252926..b5c0fe71 100644 --- a/reference/compound_stmts.po +++ b/reference/compound_stmts.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-07-23 14:38+0200\n" -"PO-Revision-Date: 2023-02-15 11:51+0100\n" -"Last-Translator: Jean Abou Samra \n" +"PO-Revision-Date: 2023-12-05 22:58+0100\n" +"Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"X-Generator: Poedit 3.2.1\n" +"X-Generator: Poedit 3.2.2\n" #: reference/compound_stmts.rst:5 msgid "Compound statements" @@ -233,7 +233,6 @@ msgstr "" "compris celles effectuées dans la suite de la boucle ``for`` ::" #: reference/compound_stmts.rst:193 -#, fuzzy msgid "" "Names in the target list are not deleted when the loop is finished, but if " "the sequence is empty, they will not have been assigned to at all by the " @@ -243,27 +242,27 @@ msgid "" 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 native :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]``." +"assignés par la boucle. Petite astuce : le type natif :func:`range` " +"représente des suites arithmétiques immuables de nombres entiers ; par " +"exemple, itérer sur ``range(3)`` renvoie successivement les entiers 0, 1 et " +"2." +# suit un : #: reference/compound_stmts.rst:198 msgid "Starred elements are now allowed in the expression list." msgstr "" -"Les éléments étoilés sont maintenant autorisés dans l'expression liste." +"les éléments étoilés sont maintenant autorisés dans l'expression liste." #: reference/compound_stmts.rst:205 msgid "The :keyword:`!try` statement" msgstr "L'instruction :keyword:`!try`" #: reference/compound_stmts.rst:215 -#, fuzzy msgid "" "The :keyword:`!try` statement specifies exception handlers and/or cleanup " "code for a group of statements:" msgstr "" -"L'instruction :keyword:`try` définit les gestionnaires d'exception ou le " +"L'instruction :keyword:`!try` définit les gestionnaires d'exception ou le " "code de nettoyage pour un groupe d'instructions :" #: reference/compound_stmts.rst:231 @@ -279,10 +278,9 @@ msgstr "" #: reference/compound_stmts.rst:239 msgid ":keyword:`!except` clause" -msgstr "" +msgstr "clause :keyword:`!except`" #: reference/compound_stmts.rst:241 -#, fuzzy msgid "" "The :keyword:`!except` clause(s) specify one or more exception handlers. " "When no exception occurs in the :keyword:`try` clause, no exception handler " @@ -298,34 +296,32 @@ msgid "" "tuple containing an item that is the class or a non-virtual base class of " "the exception object." msgstr "" -"La ou les clauses :keyword:`except` précisent un ou plusieurs gestionnaires " +"La ou les clauses :keyword:`!except` précisent 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 mère (mais " -"pas une :term:`classe mère abstraite`) de l'objet exception ou si c'est un " -"*n*-uplet dont un élément est la classe ou une classe parente (non-" -"abstraite) de l'exception." +"d'exception. Cette recherche inspecte les clauses :keyword:`!except`, l'une " +"après l'autre, jusqu'à trouver une correspondance. Une clause :keyword:`!" +"except` vide (c'est-à-dire sans expression), si elle est présente, doit être " +"la dernière ; elle correspond à toute exception. Pour une clause :keyword:`!" +"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 mère (mais pas une :term:`classe mère abstraite`) de l'objet " +"exception ou si c'est un *n*-uplet dont un élément est la classe ou une " +"classe mère (non-abstraite) de l'exception." #: reference/compound_stmts.rst:256 -#, fuzzy msgid "" "If no :keyword:`!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. [#]_" +"Si aucune clause :keyword:`!except` ne correspond à l'exception, la " +"recherche d'un gestionnaire d'exception se poursuit dans le code englobant " +"et dans la pile d'appels. [#]_" #: reference/compound_stmts.rst:260 -#, fuzzy msgid "" "If the evaluation of an expression in the header of an :keyword:`!except` " "clause raises an exception, the original search for a handler is canceled " @@ -333,14 +329,13 @@ msgid "" "call stack (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)." +"Si l'évaluation d'une expression dans l'en-tête d'une clause :keyword:`!" +"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)." #: reference/compound_stmts.rst:268 -#, fuzzy msgid "" "When a matching :keyword:`!except` clause is found, the exception is " "assigned to the target specified after the :keyword:`!as` keyword in that :" @@ -352,31 +347,29 @@ msgid "" "keyword:`!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 précisé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)." +"Lorsqu'une clause :keyword:`!except` correspond, l'exception est affectée à " +"la cible précisée après le mot-clé :keyword:`!as` dans cette clause :keyword:" +"`!except`, si cette cible existe, et la suite de clause :keyword:`!except` " +"est exécutée. Toutes les clauses :keyword:`!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 :keyword:`try` (cela signifie " +"que si deux gestionnaires imbriqués existent pour la même exception, et que " +"l'exception se produit dans la clause :keyword:`!try` du gestionnaire " +"interne, le gestionnaire externe ne gère pas l'exception)." #: reference/compound_stmts.rst:279 -#, fuzzy msgid "" "When an exception has been assigned using ``as target``, it is cleared at " "the end of the :keyword:`!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 ::" +"Lorsqu'une exception a été affectée en utilisant ``as cible``, elle est " +"effacée à la fin de la clause :keyword:`!except`. C'est comme si ::" #: reference/compound_stmts.rst:285 msgid "was translated to ::" -msgstr "avait été traduit en ::" +msgstr "avait été traduit en \t::" #: reference/compound_stmts.rst:293 -#, fuzzy msgid "" "This means the exception must be assigned to a different name to be able to " "refer to it after the :keyword:`!except` clause. Exceptions are cleared " @@ -385,11 +378,11 @@ msgid "" "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." +"pouvoir s'y référer après la clause :keyword:`!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." #: reference/compound_stmts.rst:303 msgid "" @@ -399,13 +392,17 @@ msgid "" "leaving an exception handler, the exception stored in the :mod:`sys` module " "is reset to its previous value::" msgstr "" +"Avant qu'une suite de clauses :keyword:`!except` ne soit exécutée, " +"l'exception est stockée dans le module :mod:`sys`, où elle est accessible " +"depuis le corps de la clause :keyword:`!except` en appelant :func:`sys." +"exception`. Lorsque vous quittez un gestionnaire d'exceptions, l'exception " +"stockée dans le module :mod:`sys` est réinitialisée à sa valeur précédente ::" #: reference/compound_stmts.rst:334 msgid ":keyword:`!except*` clause" -msgstr "" +msgstr "clause :keyword:`!except*`" #: reference/compound_stmts.rst:336 -#, fuzzy msgid "" "The :keyword:`!except*` clause(s) are used for handling :exc:" "`ExceptionGroup`\\s. The exception type for matching is interpreted as in " @@ -417,17 +414,17 @@ msgid "" "in the group is handled by at most one :keyword:`!except*` clause, the first " "that matches it. ::" msgstr "" -"Les clauses :keyword:`except*` sont utilisées pour gérer des :" -"exc:`ExceptionGroup`. Le type de l'exception pour la correspondance est " +"Les clauses :keyword:`!except*` sont utilisées pour gérer des :exc:" +"`ExceptionGroup`. Le type de l'exception pour la correspondance est " "interprété de la même manière que dans le cas d'un :keyword:`except` mais, " "dans le cas d'un groupe d'exceptions, il est possible d'avoir une " "correspondance partielle quand le type correspond à une ou plusieurs " -"exception dans le groupe. Cela veut dire que plusieurs clauses *except\\** " -"peuvent être exécutées, chacune gérant une partie du groupe d'exceptions. " -"Chaque clause ne s'exécute qu'une fois et gère un groupe d'exception " -"constitué des exceptions qui correspondent. Chaque exception du groupe est " -"gérée par une clause *except\\** au plus, la première à laquelle elle " -"correspond. ::" +"exceptions dans le groupe. Cela veut dire que plusieurs clauses :keyword:`!" +"except*` peuvent être exécutées, chacune gérant une partie du groupe " +"d'exceptions. Chaque clause ne s'exécute (au maximum) qu'une fois et gère un " +"groupe d'exception constitué des exceptions qui correspondent. Chaque " +"exception du groupe est gérée par une clause :keyword:`!except*` au plus, la " +"première à laquelle elle correspond. ::" #: reference/compound_stmts.rst:364 msgid "" @@ -435,6 +432,10 @@ msgid "" "clause are re-raised at the end, combined into an exception group along with " "all exceptions that were raised from within :keyword:`!except*` clauses." msgstr "" +"Toutes les exceptions restantes qui n'ont été gérées par aucune clause :" +"keyword:`!except*` sont réactivées à la fin, combinées dans un groupe " +"d'exceptions avec toutes les exceptions qui ont été levées à partir des " +"clauses :keyword:`!except*`." #: reference/compound_stmts.rst:368 msgid "" @@ -442,6 +443,10 @@ msgid "" "only one exception is raised from an :keyword:`!except*` clause, this " "exception is no longer wrapped to form a new :exc:`ExceptionGroup`." msgstr "" +"À partir de la version 3.11.4, lorsque l'intégralité de :exc:" +"`ExceptionGroup` est gérée et qu'une seule exception est levée à partir " +"d'une clause :keyword:`!except*`, cette exception n'est plus encapsulée pour " +"former un nouveau :exc:`ExceptionGroup`." #: reference/compound_stmts.rst:372 msgid "" @@ -449,6 +454,9 @@ msgid "" "of the :keyword:`!except*` clauses, it is caught and wrapped by an exception " "group with an empty message string. ::" msgstr "" +"Si l'exception levée n'est pas un groupe d'exceptions et que son type " +"correspond à l'une des clauses :keyword:`!except*`, elle est interceptée et " +"encapsulée par un groupe d'exceptions avec une chaîne de message vide. ::" #: reference/compound_stmts.rst:383 msgid "" @@ -458,11 +466,15 @@ msgid "" "keyword:`break`, :keyword:`continue` and :keyword:`return` cannot appear in " "an :keyword:`!except*` clause." msgstr "" +"Une clause :keyword:`!except*` doit avoir un type correspondant, et ce type " +"ne peut pas être une sous-classe de :exc:`BaseExceptionGroup`. Il n'est pas " +"possible de combiner :keyword:`except` et :keyword:`!except*` dans un même :" +"keyword:`try`. Aucune clause :keyword:`break`, :keyword:`continue` ou :" +"keyword:`return` ne peut apparaître dans une clause :keyword:`!except*`." #: reference/compound_stmts.rst:400 -#, fuzzy msgid ":keyword:`!else` clause" -msgstr "L'instruction :keyword:`!while`" +msgstr "clause :keyword:`!else`" #: reference/compound_stmts.rst:402 msgid "" @@ -480,10 +492,9 @@ msgstr "" #: reference/compound_stmts.rst:414 msgid ":keyword:`!finally` clause" -msgstr "" +msgstr "clause :keyword:`!finally`" #: reference/compound_stmts.rst:416 -#, fuzzy msgid "" "If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The :" "keyword:`try` clause is executed, including any :keyword:`except` and :" @@ -496,9 +507,9 @@ msgid "" "`return`, :keyword:`break` or :keyword:`continue` statement, the saved " "exception is discarded::" msgstr "" -"Si :keyword:`finally` est présente, elle définit un gestionnaire de " +"Si :keyword:`!finally` est présente, elle définit 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 " +"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 levée à nouveau à la fin de la clause :" @@ -509,16 +520,14 @@ msgstr "" "l'exception sauvegardée est jetée ::" #: reference/compound_stmts.rst:435 -#, fuzzy 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`." +"pendant l'exécution de la clause :keyword:`!finally`." #: reference/compound_stmts.rst:443 -#, fuzzy msgid "" "When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement " "is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!" @@ -527,11 +536,10 @@ msgid "" 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 »." +"construction :keyword:`!try`…\\ :keyword:`!finally`, la clause :keyword:`!" +"finally` est aussi exécutée « à la sortie »." #: reference/compound_stmts.rst:447 -#, fuzzy msgid "" "The return value of a function is determined by the last :keyword:`return` " "statement executed. Since the :keyword:`!finally` clause always executes, " @@ -539,18 +547,17 @@ msgid "" "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 ::" +"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 ::" #: reference/compound_stmts.rst:461 -#, fuzzy msgid "" "Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :" "keyword:`!finally` clause due to a problem with the implementation." msgstr "" "Avant Python 3.8, une instruction :keyword:`continue` n'était pas licite " -"dans une clause :keyword:`finally` en raison d'un problème dans " +"dans une clause :keyword:`!finally` en raison d'un problème dans " "l'implémentation." #: reference/compound_stmts.rst:470 @@ -612,7 +619,6 @@ msgstr "" "est assignée." #: reference/compound_stmts.rst:505 -#, fuzzy msgid "" "The :keyword:`with` statement guarantees that if the :meth:`__enter__` " "method returns without an error, then :meth:`__exit__` will always be " @@ -624,7 +630,7 @@ msgstr "" "se termine sans erreur, alors la méthode :meth:`__exit__` est toujours " "appelée. Ainsi, si une erreur se produit pendant l'affectation à 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." +"suite. Voir l'étape 7 ci-dessous." #: reference/compound_stmts.rst:511 msgid "The suite is executed." @@ -1084,7 +1090,6 @@ msgstr "" "au champ de recherche. La syntaxe est la suivante :" #: reference/compound_stmts.rst:821 -#, fuzzy msgid "" "If the OR pattern fails, the AS pattern fails. Otherwise, the AS pattern " "binds the subject to the name on the right of the as keyword and succeeds. " @@ -1604,7 +1609,7 @@ msgid "" "exc:`TypeError`." msgstr "" "Si ``name_or_attr`` n'est pas une instance de la classe native :class:" -"`type` , lève une :exc:`TypeError`." +"`type`, lève une :exc:`TypeError`." #: reference/compound_stmts.rst:1098 msgid "" @@ -1641,8 +1646,8 @@ msgid "" "If only keyword patterns are present, they are processed as follows, one by " "one:" msgstr "" -"S'il n'y a que des motifs par mot-clé (NdT : dans le sens « argument par " -"mot-clé »), ils sont évalués comme ceci, un par un :" +"S'il n'y a que des motifs par mot-clé (NdT : dans le sens « argument par mot-" +"clé »), ils sont évalués comme ceci, un par un :" #: reference/compound_stmts.rst:1112 msgid "I. The keyword is looked up as an attribute on the subject." @@ -1795,7 +1800,6 @@ msgid ":class:`tuple`" msgstr ":class:`tuple`" #: reference/compound_stmts.rst:1166 -#, fuzzy msgid "" "These classes accept a single positional argument, and the pattern there is " "matched against the whole object rather than an attribute. For example " @@ -1804,7 +1808,7 @@ msgstr "" "Ces classes acceptent un argument positionnel seul et le filtre s'applique " "alors sur l'ensemble de l'objet plutôt que sur un simple attribut. Par " "exemple, ``int(0|1)`` réussit lorsqu'il est confronté à la valeur ``0``, " -"mais pas aux valeurs ``0.0`` ou ``False``." +"mais pas lorsque c'est la valeur ``0.0``." #: reference/compound_stmts.rst:1170 msgid "" @@ -1891,11 +1895,11 @@ msgstr "" "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 ::" +"suivant ::" #: reference/compound_stmts.rst:1249 reference/compound_stmts.rst:1426 msgid "is roughly equivalent to ::" -msgstr "est à peu près équivalent à ::" +msgstr "est à peu près équivalent à ::" #: reference/compound_stmts.rst:1254 msgid "" @@ -2132,11 +2136,11 @@ msgstr "" "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 mère :class:" -"`object` ; d'où ::" +"`object` ; d'où ::" #: reference/compound_stmts.rst:1396 msgid "is equivalent to ::" -msgstr "est équivalente à ::" +msgstr "est équivalente à ::" #: reference/compound_stmts.rst:1401 msgid "" @@ -2183,7 +2187,7 @@ msgstr "" 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 ::" +"fonctions ::" #: reference/compound_stmts.rst:1431 msgid "" @@ -2331,11 +2335,11 @@ msgid "Is semantically equivalent to::" msgstr "est sémantiquement équivalent à ::" #: reference/compound_stmts.rst:1541 -#, fuzzy msgid "" "See also :meth:`~object.__aiter__` and :meth:`~object.__anext__` for details." msgstr "" -"Voir aussi :meth:`__aiter__` et :meth:`__anext__` pour plus de détails." +"Voir aussi :meth:`~object.__aiter__` et :meth:`~object.__anext__` pour plus " +"de détails." #: reference/compound_stmts.rst:1543 msgid "" @@ -2359,12 +2363,12 @@ msgstr "" "capable de suspendre l'exécution dans ses méthodes *enter* et *exit*." #: reference/compound_stmts.rst:1583 -#, fuzzy msgid "" "See also :meth:`~object.__aenter__` and :meth:`~object.__aexit__` for " "details." msgstr "" -"Voir aussi :meth:`__aenter__` et :meth:`__aexit__` pour plus de détails." +"Voir aussi :meth:`~object.__aenter__` et :meth:`~object.__aexit__` pour plus " +"de détails." #: reference/compound_stmts.rst:1585 msgid "" @@ -2417,11 +2421,11 @@ msgstr "" "Sequence`" #: reference/compound_stmts.rst:1605 -#, fuzzy msgid "" "a builtin class that has its (CPython) :c:macro:`Py_TPFLAGS_SEQUENCE` bit set" msgstr "" -"une classe native dont le bit (CPython) :data:`Py_TPFLAGS_SEQUENCE` est à 1" +"une classe native dont le bit (CPython) :c:macro:`Py_TPFLAGS_SEQUENCE` est à " +"1" #: reference/compound_stmts.rst:1606 reference/compound_stmts.rst:1625 msgid "a class that inherits from any of the above" @@ -2472,11 +2476,10 @@ msgstr "" "Mapping`" #: reference/compound_stmts.rst:1624 -#, fuzzy msgid "" "a builtin class that has its (CPython) :c:macro:`Py_TPFLAGS_MAPPING` bit set" msgstr "" -"une classe native dont le bit (CPython) :data:`Py_TPFLAGS_MAPPING` est à 1" +"une classe native dont le bit (CPython) :c:macro:`Py_TPFLAGS_MAPPING` est à 1" #: reference/compound_stmts.rst:1627 msgid "" @@ -2508,7 +2511,7 @@ msgstr "" #: reference/compound_stmts.rst:7 msgid "compound" -msgstr "" +msgstr "composé" #: reference/compound_stmts.rst:86 reference/compound_stmts.rst:111 #: reference/compound_stmts.rst:129 reference/compound_stmts.rst:144 @@ -2518,43 +2521,42 @@ msgstr "" #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1367 #: reference/compound_stmts.rst:1468 reference/compound_stmts.rst:1502 #: reference/compound_stmts.rst:1547 -#, fuzzy msgid "statement" -msgstr "Instructions composées" +msgstr "instruction" #: reference/compound_stmts.rst:21 msgid "clause" -msgstr "" +msgstr "clause" #: reference/compound_stmts.rst:21 msgid "suite" -msgstr "" +msgstr "suite" #: reference/compound_stmts.rst:21 msgid "; (semicolon)" -msgstr "" +msgstr "; (point-virgule)" #: reference/compound_stmts.rst:64 msgid "NEWLINE token" -msgstr "" +msgstr "lexème NEWLINE" #: reference/compound_stmts.rst:64 msgid "DEDENT token" -msgstr "" +msgstr "lexème DEDENT" #: reference/compound_stmts.rst:64 msgid "dangling" -msgstr "" +msgstr "fantôme" #: reference/compound_stmts.rst:64 reference/compound_stmts.rst:86 #: reference/compound_stmts.rst:111 reference/compound_stmts.rst:144 #: reference/compound_stmts.rst:207 reference/compound_stmts.rst:391 msgid "else" -msgstr "" +msgstr "else" #: reference/compound_stmts.rst:86 reference/compound_stmts.rst:589 msgid "if" -msgstr "" +msgstr "if" #: reference/compound_stmts.rst:86 reference/compound_stmts.rst:111 #: reference/compound_stmts.rst:144 reference/compound_stmts.rst:207 @@ -2562,11 +2564,11 @@ msgstr "" #: reference/compound_stmts.rst:409 reference/compound_stmts.rst:472 #: reference/compound_stmts.rst:589 reference/compound_stmts.rst:1478 msgid "keyword" -msgstr "" +msgstr "mot-clé" #: reference/compound_stmts.rst:86 msgid "elif" -msgstr "" +msgstr "elif" #: reference/compound_stmts.rst:86 reference/compound_stmts.rst:111 #: reference/compound_stmts.rst:144 reference/compound_stmts.rst:207 @@ -2574,308 +2576,297 @@ msgstr "" #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1311 #: reference/compound_stmts.rst:1367 msgid ": (colon)" -msgstr "" +msgstr ": (deux-points)" #: reference/compound_stmts.rst:86 reference/compound_stmts.rst:111 #: reference/compound_stmts.rst:144 reference/compound_stmts.rst:207 #: reference/compound_stmts.rst:472 reference/compound_stmts.rst:589 #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1367 -#, fuzzy msgid "compound statement" -msgstr "Instructions composées" +msgstr "instruction composée" #: reference/compound_stmts.rst:111 msgid "while" -msgstr "" +msgstr "while" #: reference/compound_stmts.rst:111 reference/compound_stmts.rst:144 msgid "loop" -msgstr "" +msgstr "boucle" #: reference/compound_stmts.rst:129 reference/compound_stmts.rst:169 #: reference/compound_stmts.rst:391 reference/compound_stmts.rst:438 msgid "break" -msgstr "" +msgstr "break" #: reference/compound_stmts.rst:129 reference/compound_stmts.rst:169 #: reference/compound_stmts.rst:391 reference/compound_stmts.rst:438 msgid "continue" -msgstr "" +msgstr "continue" #: reference/compound_stmts.rst:144 msgid "for" -msgstr "" +msgstr "for" #: reference/compound_stmts.rst:144 msgid "in" -msgstr "" +msgstr "in" #: reference/compound_stmts.rst:144 msgid "target" -msgstr "" +msgstr "cible" #: reference/compound_stmts.rst:144 msgid "list" -msgstr "" +msgstr "liste" #: reference/compound_stmts.rst:144 reference/compound_stmts.rst:299 #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1367 msgid "object" -msgstr "" +msgstr "objet" #: reference/compound_stmts.rst:144 msgid "sequence" -msgstr "" +msgstr "séquence" #: reference/compound_stmts.rst:190 msgid "built-in function" -msgstr "" +msgstr "fonction native" #: reference/compound_stmts.rst:190 msgid "range" -msgstr "" +msgstr "range" #: reference/compound_stmts.rst:207 msgid "try" -msgstr "" +msgstr "try" #: reference/compound_stmts.rst:207 msgid "except" -msgstr "" +msgstr "except" #: reference/compound_stmts.rst:207 reference/compound_stmts.rst:409 msgid "finally" -msgstr "" +msgstr "finally" #: reference/compound_stmts.rst:207 reference/compound_stmts.rst:266 #: reference/compound_stmts.rst:472 reference/compound_stmts.rst:589 msgid "as" -msgstr "" +msgstr "as" #: reference/compound_stmts.rst:266 msgid "except clause" -msgstr "" +msgstr "clause except" #: reference/compound_stmts.rst:299 msgid "module" -msgstr "" +msgstr "module" #: reference/compound_stmts.rst:299 msgid "sys" -msgstr "" +msgstr "sys" #: reference/compound_stmts.rst:299 msgid "traceback" -msgstr "" +msgstr "trace d'appels" #: reference/compound_stmts.rst:328 msgid "except_star" -msgstr "" +msgstr "except_star" #: reference/compound_stmts.rst:391 reference/compound_stmts.rst:438 msgid "return" -msgstr "" +msgstr "return" #: reference/compound_stmts.rst:472 msgid "with" -msgstr "" +msgstr "with" #: reference/compound_stmts.rst:472 -#, fuzzy msgid "with statement" -msgstr "L'instruction :keyword:`!with`" +msgstr "instruction *with*" #: reference/compound_stmts.rst:472 reference/compound_stmts.rst:1194 #: reference/compound_stmts.rst:1367 msgid ", (comma)" -msgstr "" +msgstr ", (virgule)" #: reference/compound_stmts.rst:589 msgid "match" -msgstr "" +msgstr "match" #: reference/compound_stmts.rst:589 msgid "case" -msgstr "" +msgstr "case" #: reference/compound_stmts.rst:589 -#, fuzzy msgid "pattern matching" -msgstr ":ref:`class-pattern-matching`" +msgstr "filtrage par motif" #: reference/compound_stmts.rst:589 -#, fuzzy msgid "match statement" -msgstr "Voici un exemple d'instruction de filtrage par motif ::" +msgstr "instruction *match*" #: reference/compound_stmts.rst:693 -#, fuzzy msgid "guard" -msgstr "Gardes" +msgstr "garde" #: reference/compound_stmts.rst:732 -#, fuzzy msgid "irrefutable case block" -msgstr "Bloc ``case`` attrape-tout" +msgstr "bloc attrape-tout" #: reference/compound_stmts.rst:732 msgid "case block" -msgstr "" +msgstr "bloc *case*" #: reference/compound_stmts.rst:756 -#, fuzzy msgid "! patterns" -msgstr "Filtres" +msgstr "! motifs" #: reference/compound_stmts.rst:756 msgid "AS pattern, OR pattern, capture pattern, wildcard pattern" -msgstr "" +msgstr "motif AS, motif OR, motif de capture, motif attrape-tout" #: reference/compound_stmts.rst:1185 reference/compound_stmts.rst:1261 msgid "parameter" -msgstr "" +msgstr "paramètre" #: reference/compound_stmts.rst:1185 reference/compound_stmts.rst:1194 #: reference/compound_stmts.rst:1235 reference/compound_stmts.rst:1261 #: reference/compound_stmts.rst:1290 -#, fuzzy msgid "function definition" -msgstr "Définition de fonctions" +msgstr "définition de fonction" #: reference/compound_stmts.rst:1194 msgid "def" -msgstr "" +msgstr "def" #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1311 msgid "function" -msgstr "" +msgstr "fonction" #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1367 -#, fuzzy msgid "definition" -msgstr "Définition de classes" +msgstr "définition" #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1367 msgid "name" -msgstr "" +msgstr "nom" #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1367 msgid "binding" -msgstr "" +msgstr "liaison" #: reference/compound_stmts.rst:1194 msgid "user-defined function" -msgstr "" +msgstr "fonction définie par l'utilisateur" #: reference/compound_stmts.rst:1194 reference/compound_stmts.rst:1367 msgid "() (parentheses)" -msgstr "" +msgstr "() (parenthèses)" #: reference/compound_stmts.rst:1194 msgid "parameter list" -msgstr "" +msgstr "liste de paramètres" #: reference/compound_stmts.rst:1235 reference/compound_stmts.rst:1417 msgid "@ (at)" -msgstr "" +msgstr "@ (arobase)" #: reference/compound_stmts.rst:1261 msgid "default" -msgstr "" +msgstr "par défaut" #: reference/compound_stmts.rst:1261 msgid "value" -msgstr "" +msgstr "valeur" #: reference/compound_stmts.rst:1261 msgid "argument" -msgstr "" +msgstr "argument" #: reference/compound_stmts.rst:1261 msgid "= (equals)" -msgstr "" +msgstr "= (égal)" #: reference/compound_stmts.rst:1290 msgid "/ (slash)" -msgstr "" +msgstr "/ (barre oblique)" #: reference/compound_stmts.rst:1290 msgid "* (asterisk)" -msgstr "" +msgstr "* (astérisque)" #: reference/compound_stmts.rst:1290 msgid "**" -msgstr "" +msgstr "**" #: reference/compound_stmts.rst:1311 msgid "annotations" -msgstr "" +msgstr "annotations" #: reference/compound_stmts.rst:1311 msgid "->" -msgstr "" +msgstr "->" #: reference/compound_stmts.rst:1311 -#, fuzzy msgid "function annotations" -msgstr "Définition de fonctions" +msgstr "annotations de fonction" #: reference/compound_stmts.rst:1329 msgid "lambda" -msgstr "" +msgstr "lambda" #: reference/compound_stmts.rst:1329 msgid "expression" -msgstr "" +msgstr "expression" #: reference/compound_stmts.rst:1367 msgid "class" -msgstr "" +msgstr "classe" #: reference/compound_stmts.rst:1367 msgid "execution" -msgstr "" +msgstr "exécution" #: reference/compound_stmts.rst:1367 msgid "frame" -msgstr "" +msgstr "cadre" #: reference/compound_stmts.rst:1367 msgid "inheritance" -msgstr "" +msgstr "héritage" #: reference/compound_stmts.rst:1367 msgid "docstring" -msgstr "" +msgstr "chaîne de documentation" #: reference/compound_stmts.rst:1367 reference/compound_stmts.rst:1417 -#, fuzzy msgid "class definition" -msgstr "Définition de classes" +msgstr "définition de classe" #: reference/compound_stmts.rst:1367 msgid "expression list" -msgstr "" +msgstr "liste d'expressions" #: reference/compound_stmts.rst:1468 msgid "async def" -msgstr "" +msgstr "async def" #: reference/compound_stmts.rst:1478 msgid "async" -msgstr "" +msgstr "async" #: reference/compound_stmts.rst:1478 msgid "await" -msgstr "" +msgstr "await" #: reference/compound_stmts.rst:1502 msgid "async for" -msgstr "" +msgstr "async for" #: reference/compound_stmts.rst:1547 msgid "async with" -msgstr "" +msgstr "async with" #, fuzzy #~ msgid "" diff --git a/reference/expressions.po b/reference/expressions.po index 94634880..4c2f6d5c 100644 --- a/reference/expressions.po +++ b/reference/expressions.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-07-23 14:38+0200\n" -"PO-Revision-Date: 2022-12-04 14:55+0100\n" -"Last-Translator: Jean Abou Samra \n" +"PO-Revision-Date: 2023-12-07 23:06+0100\n" +"Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"X-Generator: Poedit 3.2.1\n" +"X-Generator: Poedit 3.2.2\n" #: reference/expressions.rst:6 msgid "Expressions" @@ -228,7 +228,6 @@ msgstr "" "produire le même objet)." #: reference/expressions.rst:156 -#, fuzzy msgid "" "Note that tuples are not formed by the parentheses, but rather by use of the " "comma. The exception is the empty tuple, for which parentheses *are* " @@ -445,7 +444,6 @@ msgid "Dictionary displays" msgstr "Agencements de dictionnaires" #: reference/expressions.rst:307 -#, fuzzy msgid "" "A dictionary display is a possibly empty series of dict items (key/value " "pairs) enclosed in curly braces:" @@ -458,7 +456,6 @@ msgid "A dictionary display yields a new dictionary object." msgstr "Un agencement de dictionnaire produit un nouvel objet dictionnaire." #: reference/expressions.rst:318 -#, fuzzy msgid "" "If a comma-separated sequence of dict items is given, they are evaluated " "from left to right to define the entries of the dictionary: each key object " @@ -470,13 +467,12 @@ msgstr "" "Si une séquence (dont les éléments sont séparés par des virgules) de couples " "clés-valeurs est fournie, les couples sont évalués de la gauche vers la " "droite pour définir les entrées du dictionnaire : chaque objet clé est " -"utilisé comme clé dans le dictionnaire pour stocker la donnée " +"utilisé comme clé dans le dictionnaire pour stocker la valeur " "correspondante. Cela signifie que vous pouvez spécifier la même clé " "plusieurs fois dans la liste des couples clés-valeurs et, dans ce cas, la " "valeur finalement stockée dans le dictionnaire est la dernière donnée." #: reference/expressions.rst:328 -#, fuzzy msgid "" "A double asterisk ``**`` denotes :dfn:`dictionary unpacking`. Its operand " "must be a :term:`mapping`. Each mapping item is added to the new " @@ -510,7 +506,6 @@ msgstr "" "dictionnaire dans l'ordre dans lequel ils sont produits." #: reference/expressions.rst:344 -#, fuzzy msgid "" "Restrictions on the types of the key values are listed earlier in section :" "ref:`types`. (To summarize, the key type should be :term:`hashable`, which " @@ -681,7 +676,6 @@ msgstr "" "`asynchronous-generator-functions`." #: reference/expressions.rst:452 -#, fuzzy msgid "" "When a generator function is called, it returns an iterator known as a " "generator. That generator then controls the execution of the generator " @@ -706,18 +700,19 @@ msgstr "" "génératrice. L'exécution commence lorsque l'une des méthodes du générateur " "est appelée. À ce moment, l'exécution se déroule jusqu'à la première " "expression ``yield``, où elle se suspend, renvoyant la valeur de :token:" -"`~python-grammar:expression_list` à l'appelant du générateur. Cette " -"suspension conserve tous les états locaux, y compris les liaisons en cours " -"des variables locales, le pointeur d'instruction, la pile d'évaluation " -"interne et l'état de tous les gestionnaires d'exceptions. Lorsque " -"l'exécution reprend en appelant l'une des méthodes du générateur, la " -"fonction s'exécute exactement comme si l'expression ``yield`` n'avait été " -"qu'un simple appel externe. La valeur de l'expression ``yield`` après " -"reprise dépend de la méthode qui a permis la reprise de l'exécution. Si " -"c'est :meth:`~generator.__next__` qui a été utilisée (généralement *via* un :" -"keyword:`for` ou la fonction native :func:`next`) alors le résultat est :" -"const:`None`. Sinon, si c'est :meth:`~generator.send` qui a été utilisée, " -"alors le résultat est la valeur transmise à cette méthode." +"`~python-grammar:expression_list` à l'appelant du générateur ou ``None`` si :" +"token:`~python-grammar:expression_list` est omis. Cette suspension conserve " +"tous les états locaux, y compris les liaisons en cours des variables " +"locales, le pointeur d'instruction, la pile d'évaluation interne et l'état " +"de tous les gestionnaires d'exceptions. Lorsque l'exécution reprend en " +"appelant l'une des méthodes du générateur, la fonction s'exécute exactement " +"comme si l'expression ``yield`` n'avait été qu'un simple appel externe. La " +"valeur de l'expression ``yield`` après reprise dépend de la méthode qui a " +"permis la reprise de l'exécution. Si c'est :meth:`~generator.__next__` qui a " +"été utilisée (généralement *via* un :keyword:`for` ou la fonction native :" +"func:`next`) alors le résultat est :const:`None`. Sinon, si c'est :meth:" +"`~generator.send` qui a été utilisée, alors le résultat est la valeur " +"transmise à cette méthode." #: reference/expressions.rst:472 msgid "" @@ -935,7 +930,6 @@ msgstr "" "d'exception, de façon similaire à l'utilisation du mot-clé :keyword:`raise`." #: reference/expressions.rst:578 -#, fuzzy msgid "" "For backwards compatibility, however, the second signature is supported, " "following a convention from older versions of Python. The *type* argument " @@ -1296,7 +1290,7 @@ msgstr "" #: reference/expressions.rst:819 msgid "Subscriptions" -msgstr "Indiçage (ou sélections)" +msgstr "sélection (ou indiçage)" #: reference/expressions.rst:834 msgid "" @@ -1305,7 +1299,7 @@ msgid "" "term:`generic class ` will generally return a :ref:" "`GenericAlias ` object." msgstr "" -"L'indiçage d'une instance de :ref:`classe containeur ` " +"L'indiçage d'une instance de :ref:`classe conteneur ` " "sélectionne généralement un élément du conteneur. L'indiçage d'une :term:" "`classe générique ` renvoie généralement un objet :ref:" "`GenericAlias `." @@ -1544,21 +1538,21 @@ msgstr "" "arguments positionnels, comme suit. Pour commencer, une liste de *slots* " "vides est créée pour les paramètres formels. S'il y a N arguments " "positionnels, ils sont placés dans les N premiers *slots*. Ensuite, pour " -"chaque argument par mot-clé, l'identifiant est utilisé pour déterminer le " -"*slot* correspondant (si l'identifiant est le même que le nom du premier " -"paramètre formel, le premier *slot* est utilisé, et ainsi de suite). Si le " -"*slot* est déjà rempli, une exception :exc:`TypeError` est levée. Sinon, " -"l'argument est placé dans le *slot*, ce qui le remplit (même si l'expression " -"est ``None``, cela remplit le *slot*). Quand tous les arguments ont été " -"traités, les *slots* qui sont toujours vides sont remplis avec la valeur par " -"défaut correspondante dans la définition de la fonction (les valeurs par " -"défaut sont calculées, une seule fois, lorsque la fonction est définie ; " -"ainsi, un objet mutable tel qu'une liste ou un dictionnaire utilisé en tant " -"valeur par défaut sera partagé entre tous les appels qui ne spécifient pas " -"de valeur d argument pour ce *slot* ; on évite généralement de faire ça). " -"S'il reste des *slots* pour lesquels aucune valeur par défaut n'est définie, " -"une exception :exc:`TypeError` est levée. Sinon, la liste des *slots* " -"remplie est utilisée en tant que liste des arguments pour l'appel." +"chaque argument nommé, l'identifiant est utilisé pour déterminer le *slot* " +"correspondant (si l'identifiant est le même que le nom du premier paramètre " +"formel, le premier *slot* est utilisé, et ainsi de suite). Si le *slot* est " +"déjà rempli, une exception :exc:`TypeError` est levée. Sinon, l'argument est " +"placé dans le *slot*, ce qui le remplit (même si l'expression est ``None``, " +"cela remplit le *slot*). Quand tous les arguments ont été traités, les " +"*slots* qui sont toujours vides sont remplis avec la valeur par défaut " +"correspondante dans la définition de la fonction (les valeurs par défaut " +"sont calculées, une seule fois, lorsque la fonction est définie ; ainsi, un " +"objet mutable tel qu'une liste ou un dictionnaire utilisé en tant valeur par " +"défaut sera partagé entre tous les appels qui ne spécifient pas de valeur d " +"argument pour ce *slot* ; on évite généralement de faire ça). S'il reste des " +"*slots* pour lesquels aucune valeur par défaut n'est définie, une exception :" +"exc:`TypeError` est levée. Sinon, la liste des *slots* remplie est utilisée " +"en tant que liste des arguments pour l'appel." #: reference/expressions.rst:1006 msgid "" @@ -1570,8 +1564,8 @@ msgid "" msgstr "" "Une implémentation peut fournir des fonctions natives dont les paramètres " "positionnels n'ont pas de nom, même s'ils sont « nommés » pour les besoins " -"de la documentation. Ils ne peuvent donc pas être spécifiés par mot-clé. En " -"CPython, les fonctions implémentées en C qui utilisent :c:func:" +"de la documentation. Ils ne peuvent donc pas être fournis comme arguments " +"nommés. En CPython, les fonctions implémentées en C qui utilisent :c:func:" "`PyArg_ParseTuple` pour analyser leurs arguments en font partie." #: reference/expressions.rst:1012 @@ -1597,13 +1591,13 @@ msgid "" "keywords as keys and the argument values as corresponding values), or a " "(new) empty dictionary if there were no excess keyword arguments." msgstr "" -"Si un argument par mot-clé ne correspond à aucun nom de paramètre formel, " -"une exception :exc:`TypeError` est levée, à moins qu'un paramètre formel " +"Si un argument nommé ne correspond à aucun nom de paramètre formel, une " +"exception :exc:`TypeError` est levée, à moins qu'un paramètre formel " "n'utilise la syntaxe ``**identifier`` ; dans ce cas, le paramètre formel " -"reçoit un dictionnaire contenant les arguments par mot-clé en trop (en " -"utilisant les mots-clés comme clés et les arguments comme valeurs pour ce " +"reçoit un dictionnaire contenant les arguments nommés en trop (en utilisant " +"les mots-clés comme clés et les arguments comme valeurs pour ce " "dictionnaire), ou un (nouveau) dictionnaire vide s'il n'y a pas d'argument " -"par mot-clé en trop." +"nommé en trop." #: reference/expressions.rst:1029 msgid "" @@ -1642,7 +1636,6 @@ msgstr "" "fait que la confusion reste rare." #: reference/expressions.rst:1058 -#, fuzzy msgid "" "If the syntax ``**expression`` appears in the function call, ``expression`` " "must evaluate to a :term:`mapping`, the contents of which are treated as " @@ -1653,9 +1646,9 @@ msgstr "" "Si la syntaxe ``**expression`` apparaît dans un appel de fonction, " "``expression`` doit pouvoir s'évaluer comme un :term:`tableau de " "correspondances `, dont le contenu est traité comme des arguments " -"par mots-clés supplémentaires. Si un mot-clé est déjà présent (en tant " -"qu'argument par mot-clé explicite, ou venant d'un autre dépaquetage), une " -"exception :exc:`TypeError` est levée." +"par mots-clés supplémentaires. Si un paramètre correspondant à une clé a " +"déjà été fourni (en tant qu'argument nommé explicite, en provenance d'un " +"autre dépaquetage), une exception :exc:`TypeError` est levée." #: reference/expressions.rst:1064 msgid "" @@ -1668,6 +1661,15 @@ msgid "" "parameter, if there is one, or if there is not, a :exc:`TypeError` exception " "is raised." msgstr "" +"Lorsque ``**expression`` est utilisée, chaque clé de ce tableau de " +"correspondances doit être une chaîne. Chaque valeur du tableau est affectée " +"au premier paramètre formel éligible à l'affectation par mot-clé dont le nom " +"est égal à la clé. Une clé n'a pas besoin d'être un identifiant Python (par " +"exemple, ``\"max-temp °F\"`` est acceptable, bien qu'elle ne corresponde à " +"aucun paramètre formel qui pourrait être déclaré). S'il n'y a pas de " +"correspondance avec un paramètre formel, la paire clé-valeur est collectée " +"par le paramètre ``**``, s'il y en a un. S'il n'y a pas de paramètre ``**``, " +"une exception :exc:`TypeError` est levée." #: reference/expressions.rst:1074 msgid "" @@ -2432,7 +2434,6 @@ msgstr "" "[1,2,3]`` est vrai)." #: reference/expressions.rst:1556 -#, fuzzy msgid "" "Mappings (instances of :class:`dict`) compare equal if and only if they have " "equal ``(key, value)`` pairs. Equality comparison of the keys and values " @@ -2799,6 +2800,13 @@ msgid "" "all other places where they can be used, parentheses are not required, " "including in ``if`` and ``while`` statements." msgstr "" +"Les expressions d'affectation doivent être entourées de parenthèses " +"lorsqu'elles sont utilisées comme sous-expressions dans les expressions de " +"découpage, les expressions conditionnelles, les expressions lambda, les " +"expressions d'argument nommé et les expressions de compréhensions avec *if* " +"ainsi que dans les instructions ``assert`` et ``with``. Dans tous les autres " +"endroits où elles peuvent être utilisées, les parenthèses ne sont pas " +"obligatoires, y compris dans les instructions ``if`` et ``while``." #: reference/expressions.rst:1774 msgid "See :pep:`572` for more details about assignment expressions." @@ -2932,7 +2940,6 @@ msgid "Operator precedence" msgstr "Priorités des opérateurs" #: reference/expressions.rst:1904 -#, fuzzy msgid "" "The following table summarizes the operator precedence in Python, from " "highest precedence (most binding) to lowest precedence (least binding). " @@ -2946,7 +2953,8 @@ msgstr "" "grande). Les opérateurs qui sont dans la même case ont la même priorité. À " "moins que la syntaxe ne soit explicitement indiquée, les opérateurs sont " "binaires. Les opérateurs dans la même case regroupent de la gauche vers la " -"droite (sauf pour la puissance qui regroupe de la droite vers la gauche)." +"droite (sauf pour la puissance et les expressions conditionnelles qui " +"regroupent de la droite vers la gauche)." #: reference/expressions.rst:1910 msgid "" @@ -3238,75 +3246,70 @@ msgstr "" #: reference/expressions.rst:362 reference/expressions.rst:1696 #: reference/expressions.rst:1809 reference/expressions.rst:1837 -#, fuzzy msgid "expression" -msgstr "Expressions" +msgstr "expression" #: reference/expressions.rst:8 msgid "BNF" -msgstr "" +msgstr "BNF" #: reference/expressions.rst:1197 reference/expressions.rst:1245 msgid "arithmetic" -msgstr "" +msgstr "arithmétique" #: reference/expressions.rst:28 -#, fuzzy msgid "conversion" -msgstr "Conversions arithmétiques" +msgstr "conversion" #: reference/expressions.rst:51 msgid "atom" -msgstr "" +msgstr "atome" #: reference/expressions.rst:82 msgid "name" -msgstr "" +msgstr "nom" #: reference/expressions.rst:68 -#, fuzzy msgid "identifier" -msgstr "Identifiants (noms)" +msgstr "identifiant" #: reference/expressions.rst:537 reference/expressions.rst:709 #: reference/expressions.rst:802 reference/expressions.rst:1280 #: reference/expressions.rst:1370 -#, fuzzy msgid "exception" -msgstr "Description" +msgstr "exception" #: reference/expressions.rst:74 msgid "NameError" -msgstr "" +msgstr "NameError" #: reference/expressions.rst:82 msgid "mangling" -msgstr "" +msgstr "transformation" #: reference/expressions.rst:82 msgid "private" -msgstr "" +msgstr "privé" #: reference/expressions.rst:82 msgid "names" -msgstr "" +msgstr "noms" #: reference/expressions.rst:104 -#, fuzzy msgid "literal" -msgstr "Littéraux" +msgstr "littéral" #: reference/expressions.rst:341 msgid "immutable" -msgstr "" +msgstr "immuable" #: reference/expressions.rst:117 msgid "data" -msgstr "" +msgstr "valeur" #: reference/expressions.rst:117 msgid "type" -msgstr "" +msgstr "type" #: reference/expressions.rst:244 reference/expressions.rst:298 #: reference/expressions.rst:362 reference/expressions.rst:699 @@ -3314,380 +3317,347 @@ msgstr "" #: reference/expressions.rst:1103 reference/expressions.rst:1124 #: reference/expressions.rst:1847 msgid "object" -msgstr "" +msgstr "objet" #: reference/expressions.rst:133 -#, fuzzy msgid "parenthesized form" -msgstr "Formes parenthésées" +msgstr "forme entre parenthèses" #: reference/expressions.rst:362 reference/expressions.rst:942 msgid "() (parentheses)" -msgstr "" +msgstr "() (parenthèses)" #: reference/expressions.rst:133 -#, fuzzy msgid "tuple display" -msgstr "Agencements d'ensembles" +msgstr "agencement de *n*-uplet" #: reference/expressions.rst:244 msgid "empty" -msgstr "" +msgstr "vide" #: reference/expressions.rst:825 reference/expressions.rst:1847 msgid "tuple" -msgstr "" +msgstr "*n*-uplet" #: reference/expressions.rst:1866 msgid "comma" -msgstr "" +msgstr "virgule" #: reference/expressions.rst:244 reference/expressions.rst:298 #: reference/expressions.rst:942 reference/expressions.rst:1837 msgid ", (comma)" -msgstr "" +msgstr ", (virgule)" #: reference/expressions.rst:244 reference/expressions.rst:298 -#, fuzzy msgid "comprehensions" -msgstr "Expressions" +msgstr "compréhensions" #: reference/expressions.rst:177 msgid "for" -msgstr "" +msgstr "for" #: reference/expressions.rst:212 msgid "in comprehensions" -msgstr "" +msgstr "dans les compréhensions" #: reference/expressions.rst:1783 msgid "if" -msgstr "" +msgstr "if" #: reference/expressions.rst:177 msgid "async for" -msgstr "" +msgstr "async for" #: reference/expressions.rst:1142 msgid "await" -msgstr "" +msgstr "await" #: reference/expressions.rst:802 reference/expressions.rst:898 #: reference/expressions.rst:1837 msgid "list" -msgstr "" +msgstr "liste" #: reference/expressions.rst:270 reference/expressions.rst:298 -#, fuzzy msgid "display" -msgstr "Agencements d'ensembles" +msgstr "agencement" #: reference/expressions.rst:821 msgid "[] (square brackets)" -msgstr "" +msgstr "[] (crochets)" #: reference/expressions.rst:244 -#, fuzzy msgid "list expression" -msgstr "Expression ``await``" +msgstr "expression de liste" #: reference/expressions.rst:270 reference/expressions.rst:1837 -#, fuzzy msgid "expression list" -msgstr "Listes d'expressions" +msgstr "liste d'expressions" #: reference/expressions.rst:270 msgid "set" -msgstr "" +msgstr "ensemble" #: reference/expressions.rst:298 msgid "{} (curly brackets)" -msgstr "" +msgstr "{} (accolades)" #: reference/expressions.rst:270 -#, fuzzy msgid "set expression" -msgstr "Expression ``await``" +msgstr "expression d'ensemble" #: reference/expressions.rst:324 reference/expressions.rst:825 -#, fuzzy msgid "dictionary" -msgstr "Agencements de dictionnaires" +msgstr "dictionnaire" #: reference/expressions.rst:298 msgid "key" -msgstr "" +msgstr "clé" #: reference/expressions.rst:298 msgid "value" -msgstr "" +msgstr "valeur" #: reference/expressions.rst:298 msgid "key/value pair" -msgstr "" +msgstr "couple clé-valeur" #: reference/expressions.rst:298 -#, fuzzy msgid "dictionary expression" -msgstr "Expressions conditionnelles" +msgstr "expression de dictionnaire" #: reference/expressions.rst:892 reference/expressions.rst:1809 msgid ": (colon)" -msgstr "" +msgstr ": (deux-points)" #: reference/expressions.rst:298 -#, fuzzy msgid "in dictionary expressions" -msgstr "Expressions conditionnelles" +msgstr "dans les expressions de dictionnaire" #: reference/expressions.rst:324 -#, fuzzy msgid "in dictionary displays" -msgstr "Agencements de dictionnaires" +msgstr "dans les agencements de dictionnaire" #: reference/expressions.rst:1025 reference/expressions.rst:1854 msgid "unpacking" -msgstr "" +msgstr "dépaquetage" #: reference/expressions.rst:1055 reference/expressions.rst:1162 msgid "**" -msgstr "" +msgstr "**" #: reference/expressions.rst:341 msgid "hashable" -msgstr "" +msgstr "hachable" #: reference/expressions.rst:417 reference/expressions.rst:525 -#, fuzzy msgid "generator" -msgstr "Opérateur" +msgstr "générateur" #: reference/expressions.rst:362 -#, fuzzy msgid "generator expression" -msgstr "Expressions génératrices" +msgstr "expression génératrice" #: reference/expressions.rst:1142 -#, fuzzy msgid "keyword" -msgstr ":keyword:`or`" +msgstr "mot-clé" #: reference/expressions.rst:600 msgid "yield" -msgstr "" +msgstr "yield" #: reference/expressions.rst:484 msgid "from" -msgstr "" +msgstr "from" #: reference/expressions.rst:1090 reference/expressions.rst:1809 msgid "function" -msgstr "" +msgstr "fonction" #: reference/expressions.rst:470 msgid "coroutine" -msgstr "" +msgstr "coroutine" #: reference/expressions.rst:484 -#, fuzzy msgid "yield from expression" -msgstr "Expressions ``yield``" +msgstr "expression *yield from*" #: reference/expressions.rst:537 -#, fuzzy msgid "StopIteration" -msgstr "Opérations de décalage" +msgstr "StopIteration" #: reference/expressions.rst:756 -#, fuzzy msgid "GeneratorExit" -msgstr "Expressions génératrices" +msgstr "GeneratorExit" #: reference/expressions.rst:600 -#, fuzzy msgid "examples" -msgstr "Exemples" +msgstr "exemples" #: reference/expressions.rst:699 -#, fuzzy msgid "asynchronous-generator" -msgstr "Fonctions génératrices asynchrones" +msgstr "générateur asynchrone" #: reference/expressions.rst:709 msgid "StopAsyncIteration" -msgstr "" +msgstr "StopAsyncIteration" #: reference/expressions.rst:779 -#, fuzzy msgid "primary" -msgstr "Primaires" +msgstr "primaire" #: reference/expressions.rst:793 msgid "attribute" -msgstr "" +msgstr "attribut" #: reference/expressions.rst:793 -#, fuzzy msgid "reference" -msgstr "Références à des attributs" +msgstr "référence" #: reference/expressions.rst:793 msgid ". (dot)" -msgstr "" +msgstr ". (point)" #: reference/expressions.rst:793 -#, fuzzy msgid "attribute reference" -msgstr "Références à des attributs" +msgstr "référence à un attribut" #: reference/expressions.rst:802 -#, fuzzy msgid "AttributeError" -msgstr "Références à des attributs" +msgstr "AttributeError" #: reference/expressions.rst:802 msgid "module" -msgstr "" +msgstr "module" #: reference/expressions.rst:821 -#, fuzzy msgid "subscription" -msgstr "Indiçage (ou sélections)" +msgstr "sélection (ou indiçage)" #: reference/expressions.rst:898 reference/expressions.rst:1661 msgid "sequence" -msgstr "" +msgstr "séquence" #: reference/expressions.rst:825 msgid "mapping" -msgstr "" +msgstr "tableau de correspondances" #: reference/expressions.rst:878 reference/expressions.rst:898 msgid "string" -msgstr "" +msgstr "chaîne" #: reference/expressions.rst:878 msgid "item" -msgstr "" +msgstr "élément" #: reference/expressions.rst:878 msgid "character" -msgstr "" +msgstr "caractère" #: reference/expressions.rst:892 -#, fuzzy msgid "slicing" -msgstr "Tranches" +msgstr "découpage" #: reference/expressions.rst:892 msgid "slice" -msgstr "" +msgstr "tranche" #: reference/expressions.rst:924 msgid "start (slice object attribute)" -msgstr "" +msgstr "start (attribut d'objet tranche)" #: reference/expressions.rst:924 msgid "stop (slice object attribute)" -msgstr "" +msgstr "stop (attribut d'objet tranche)" #: reference/expressions.rst:924 msgid "step (slice object attribute)" -msgstr "" +msgstr "step (attribut d'objet tranche)" #: reference/expressions.rst:942 msgid "callable" -msgstr "" +msgstr "appelable" #: reference/expressions.rst:1090 reference/expressions.rst:1117 #: reference/expressions.rst:1134 msgid "call" -msgstr "" +msgstr "appel" #: reference/expressions.rst:942 msgid "argument" -msgstr "" +msgstr "argument" #: reference/expressions.rst:975 msgid "call semantics" -msgstr "" +msgstr "sémantique des appels" #: reference/expressions.rst:942 msgid "argument list" -msgstr "" +msgstr "liste d'arguments" #: reference/expressions.rst:942 msgid "= (equals)" -msgstr "" +msgstr "= (égal)" #: reference/expressions.rst:1025 reference/expressions.rst:1055 msgid "in function calls" -msgstr "" +msgstr "dans les appels de fonction" #: reference/expressions.rst:975 msgid "parameter" -msgstr "" +msgstr "paramètre" #: reference/expressions.rst:1258 reference/expressions.rst:1854 msgid "* (asterisk)" -msgstr "" +msgstr "* (astérisque)" #: reference/expressions.rst:1090 -#, fuzzy msgid "user-defined" -msgstr "une fonction définie par l'utilisateur :" +msgstr "défini par l'utilisateur" #: reference/expressions.rst:1090 -#, fuzzy msgid "user-defined function" -msgstr "une fonction définie par l'utilisateur :" +msgstr "fonction définie par l'utilisateur" #: reference/expressions.rst:1103 -#, fuzzy msgid "built-in function" -msgstr "une fonction ou une méthode native :" +msgstr "fonction native" #: reference/expressions.rst:1103 msgid "method" -msgstr "" +msgstr "méthode" #: reference/expressions.rst:1103 -#, fuzzy msgid "built-in method" -msgstr "une fonction ou une méthode native :" +msgstr "méthode native" #: reference/expressions.rst:1117 msgid "class" -msgstr "" +msgstr "classe" #: reference/expressions.rst:1117 -#, fuzzy msgid "class object" -msgstr "un objet classe :" +msgstr "objet classe" #: reference/expressions.rst:1124 -#, fuzzy msgid "class instance" -msgstr "une instance de classe :" +msgstr "instance de classe" #: reference/expressions.rst:1134 -#, fuzzy msgid "instance" -msgstr "une instance de classe :" +msgstr "instance" #: reference/expressions.rst:1134 msgid "__call__() (object method)" -msgstr "" +msgstr "__call__() (méthode d'objet)" #: reference/expressions.rst:1162 msgid "power" -msgstr "" +msgstr "puissance" #: reference/expressions.rst:1197 reference/expressions.rst:1354 #: reference/expressions.rst:1696 -#, fuzzy msgid "operation" -msgstr "Opérateur" +msgstr "opération" #: reference/expressions.rst:1206 reference/expressions.rst:1223 #: reference/expressions.rst:1271 reference/expressions.rst:1296 @@ -3695,329 +3665,309 @@ msgstr "Opérateur" #: reference/expressions.rst:1407 reference/expressions.rst:1661 #: reference/expressions.rst:1712 reference/expressions.rst:1722 #: reference/expressions.rst:1901 -#, fuzzy msgid "operator" -msgstr "Opérateur" +msgstr "opérateur" #: reference/expressions.rst:1197 msgid "unary" -msgstr "" +msgstr "unaire" #: reference/expressions.rst:1381 reference/expressions.rst:1398 #: reference/expressions.rst:1407 -#, fuzzy msgid "bitwise" -msgstr "OR (bit à bit)" +msgstr "OU (bit à bit)" #: reference/expressions.rst:1206 msgid "negation" -msgstr "" +msgstr "négation" #: reference/expressions.rst:1206 msgid "minus" -msgstr "" +msgstr "moins" #: reference/expressions.rst:1338 msgid "- (minus)" -msgstr "" +msgstr "- (moins)" #: reference/expressions.rst:1215 -#, fuzzy msgid "unary operator" -msgstr "Opérateur" +msgstr "opérateur unaire" #: reference/expressions.rst:1215 msgid "plus" -msgstr "" +msgstr "plus" #: reference/expressions.rst:1325 msgid "+ (plus)" -msgstr "" +msgstr "+ (plus)" #: reference/expressions.rst:1223 msgid "inversion" -msgstr "" +msgstr "inversion" #: reference/expressions.rst:1223 msgid "~ (tilde)" -msgstr "" +msgstr "~ (tilde)" #: reference/expressions.rst:1234 msgid "TypeError" -msgstr "" +msgstr "TypeError" #: reference/expressions.rst:1381 msgid "binary" -msgstr "" +msgstr "binaire" #: reference/expressions.rst:1258 msgid "multiplication" -msgstr "" +msgstr "multiplication" #: reference/expressions.rst:1271 msgid "matrix multiplication" -msgstr "" +msgstr "multiplication matricielle" #: reference/expressions.rst:1271 msgid "@ (at)" -msgstr "" +msgstr "@ (arobase)" #: reference/expressions.rst:1280 msgid "ZeroDivisionError" -msgstr "" +msgstr "ZeroDivisionError" #: reference/expressions.rst:1280 msgid "division" -msgstr "" +msgstr "division" #: reference/expressions.rst:1280 msgid "/ (slash)" -msgstr "" +msgstr "/ (barre oblique)" #: reference/expressions.rst:1280 msgid "//" -msgstr "" +msgstr "//" #: reference/expressions.rst:1296 msgid "modulo" -msgstr "" +msgstr "modulo" #: reference/expressions.rst:1296 msgid "% (percent)" -msgstr "" +msgstr "% (pourcentage)" #: reference/expressions.rst:1325 msgid "addition" -msgstr "" +msgstr "addition" #: reference/expressions.rst:1338 -#, fuzzy msgid "binary operator" -msgstr "Opérations binaires bit à bit" +msgstr "opérateur binaire" #: reference/expressions.rst:1338 -#, fuzzy msgid "subtraction" -msgstr "Addition et soustraction" +msgstr "soustraction" #: reference/expressions.rst:1354 msgid "shifting" -msgstr "" +msgstr "décalage" #: reference/expressions.rst:1354 msgid "<<" -msgstr "" +msgstr "<<" #: reference/expressions.rst:1354 msgid ">>" -msgstr "" +msgstr ">>" #: reference/expressions.rst:1370 msgid "ValueError" -msgstr "" +msgstr "ValueError" #: reference/expressions.rst:1717 msgid "and" -msgstr "" +msgstr "and" #: reference/expressions.rst:1390 msgid "& (ampersand)" -msgstr "" +msgstr "& (esperluette)" #: reference/expressions.rst:1398 msgid "xor" -msgstr "" +msgstr "xor" #: reference/expressions.rst:1398 msgid "exclusive" -msgstr "" +msgstr "exclusif" #: reference/expressions.rst:1407 reference/expressions.rst:1722 msgid "or" -msgstr "" +msgstr "ou" #: reference/expressions.rst:1398 msgid "^ (caret)" -msgstr "" +msgstr "^ (caret)" #: reference/expressions.rst:1407 msgid "inclusive" -msgstr "" +msgstr "inclusif" #: reference/expressions.rst:1407 msgid "| (vertical bar)" -msgstr "" +msgstr "| (barre verticale)" #: reference/expressions.rst:1422 -#, fuzzy msgid "comparison" -msgstr "Comparaisons" +msgstr "comparaison" #: reference/expressions.rst:1422 msgid "C" -msgstr "" +msgstr "C" #: reference/expressions.rst:1422 msgid "language" -msgstr "" +msgstr "langage" #: reference/expressions.rst:1422 msgid "< (less)" -msgstr "" +msgstr "< (plus petit)" #: reference/expressions.rst:1422 msgid "> (greater)" -msgstr "" +msgstr "> (plus grand)" #: reference/expressions.rst:1422 msgid "<=" -msgstr "" +msgstr "<=" #: reference/expressions.rst:1422 msgid ">=" -msgstr "" +msgstr ">=" #: reference/expressions.rst:1422 msgid "==" -msgstr "" +msgstr "==" #: reference/expressions.rst:1422 msgid "!=" -msgstr "" +msgstr "!=" #: reference/expressions.rst:1446 msgid "chaining" -msgstr "" +msgstr "chaînage" #: reference/expressions.rst:1446 -#, fuzzy msgid "comparisons" -msgstr "Comparaisons" +msgstr "comparaisons" #: reference/expressions.rst:1661 msgid "in" -msgstr "" +msgstr "in" #: reference/expressions.rst:1661 msgid "not in" -msgstr "" +msgstr "not in" #: reference/expressions.rst:1661 msgid "membership" -msgstr "" +msgstr "appartenance" #: reference/expressions.rst:1670 msgid "test" -msgstr "" +msgstr "test" #: reference/expressions.rst:1670 msgid "is" -msgstr "" +msgstr "is" #: reference/expressions.rst:1670 msgid "is not" -msgstr "" +msgstr "is not" #: reference/expressions.rst:1670 msgid "identity" -msgstr "" +msgstr "identité" #: reference/expressions.rst:1696 -#, fuzzy msgid "Conditional" -msgstr "Expressions conditionnelles" +msgstr "conditionnelle" #: reference/expressions.rst:1696 -#, fuzzy msgid "Boolean" -msgstr "OR (booléen)" +msgstr "booléenne" #: reference/expressions.rst:1712 msgid "not" -msgstr "" +msgstr "not" #: reference/expressions.rst:1736 msgid ":= (colon equals)" -msgstr "" +msgstr ":= (deux points égal)" #: reference/expressions.rst:1736 -#, fuzzy msgid "assignment expression" -msgstr "Expression d'affectation" +msgstr "expression d'affectation" #: reference/expressions.rst:1736 -#, fuzzy msgid "walrus operator" -msgstr "L'opérateur puissance" +msgstr "opérateur morse" #: reference/expressions.rst:1736 -#, fuzzy msgid "named expression" -msgstr "Expression lambda" +msgstr "expression nommée" #: reference/expressions.rst:1783 -#, fuzzy msgid "conditional" -msgstr "Expressions conditionnelles" +msgstr "conditionnelle" #: reference/expressions.rst:1783 msgid "ternary" -msgstr "" +msgstr "ternaire" #: reference/expressions.rst:1783 -#, fuzzy msgid "conditional expression" -msgstr "Expressions conditionnelles" +msgstr "expression conditionnelle" #: reference/expressions.rst:1783 msgid "else" -msgstr "" +msgstr "else" #: reference/expressions.rst:1809 -#, fuzzy msgid "lambda" -msgstr "Expressions lambda" +msgstr "lambda" #: reference/expressions.rst:1809 msgid "form" -msgstr "" +msgstr "forme" #: reference/expressions.rst:1809 msgid "anonymous" -msgstr "" +msgstr "anonyme" #: reference/expressions.rst:1809 -#, fuzzy msgid "lambda expression" -msgstr "Expression lambda" +msgstr "expression lambda" #: reference/expressions.rst:1854 -#, fuzzy msgid "iterable" -msgstr "Littéraux" +msgstr "itérable" #: reference/expressions.rst:1854 -#, fuzzy msgid "in expression lists" -msgstr "Listes d'expressions" +msgstr "dans les expressions de liste" #: reference/expressions.rst:1866 msgid "trailing" -msgstr "" +msgstr "finale" #: reference/expressions.rst:1880 -#, fuzzy msgid "evaluation" -msgstr "Ordre d'évaluation" +msgstr "évaluation" #: reference/expressions.rst:1880 msgid "order" -msgstr "" +msgstr "ordre" #: reference/expressions.rst:1901 -#, fuzzy msgid "precedence" -msgstr "Priorités des opérateurs" +msgstr "précédence des opérateurs" #~ msgid "" #~ "Subscription of a sequence (string, tuple or list) or mapping " diff --git a/reference/simple_stmts.po b/reference/simple_stmts.po index 1ba32e91..7dc737c9 100644 --- a/reference/simple_stmts.po +++ b/reference/simple_stmts.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-07-23 14:38+0200\n" -"PO-Revision-Date: 2022-12-04 14:56+0100\n" -"Last-Translator: Jean Abou Samra \n" +"PO-Revision-Date: 2023-12-02 10:40+0100\n" +"Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"X-Generator: Poedit 3.2.1\n" +"X-Generator: Poedit 3.2.2\n" #: reference/simple_stmts.rst:6 msgid "Simple statements" @@ -286,7 +286,6 @@ msgstr "" "une liste)." #: reference/simple_stmts.rst:210 -#, fuzzy msgid "" "If the primary is a mapping object (such as a dictionary), the subscript " "must have a type compatible with the mapping's key type, and the mapping is " @@ -471,7 +470,6 @@ msgstr "" "d'une assignation optionnelle :" #: reference/simple_stmts.rst:333 -#, fuzzy msgid "" "The difference from normal :ref:`assignment` is that only a single target is " "allowed." @@ -553,10 +551,10 @@ msgid "" msgstr "" "La proposition qui a ajouté le module :mod:`typing` pour fournir une syntaxe " "standard pour les annotations de type qui peuvent être utilisées dans les " -"outils d'analyse statique et les EDIs." +"outils d'analyse statique et les environnements de développement intégrés " +"(*EDI*)." #: reference/simple_stmts.rst:367 -#, fuzzy msgid "" "Now annotated assignments allow the same expressions in the right hand side " "as regular assignments. Previously, some expressions (like un-parenthesized " @@ -581,13 +579,13 @@ msgstr "" #: reference/simple_stmts.rst:389 msgid "The simple form, ``assert expression``, is equivalent to ::" -msgstr "La forme la plus simple, ``assert expression``, est équivalente à ::" +msgstr "La forme la plus simple, ``assert expression``, est équivalente à ::" #: reference/simple_stmts.rst:394 msgid "" "The extended form, ``assert expression1, expression2``, is equivalent to ::" msgstr "" -"La forme étendue, ``assert expression1, expression2``, est équivalente à ::" +"La forme étendue, ``assert expression1, expression2``, est équivalente à ::" #: reference/simple_stmts.rst:403 msgid "" @@ -765,11 +763,11 @@ msgstr "" "`expression yield `. L'instruction *yield* peut être utilisée " "pour omettre les parenthèses qui seraient autrement requises dans " "l'instruction équivalente d'expression *yield*. Par exemple, les " -"instructions *yield* ::" +"instructions *yield* ::" #: reference/simple_stmts.rst:537 msgid "are equivalent to the yield expression statements ::" -msgstr "sont équivalentes aux instructions expressions *yield* ::" +msgstr "sont équivalentes aux instructions expressions *yield* ::" #: reference/simple_stmts.rst:542 msgid "" @@ -1025,7 +1023,6 @@ msgstr "" "clauses étaient séparées dans des instructions d'importations individuelles." #: reference/simple_stmts.rst:759 -#, fuzzy msgid "" "The details of the first step, finding and loading modules, are described in " "greater detail in the section on the :ref:`import system `, " @@ -1035,7 +1032,7 @@ msgid "" "could not be located, *or* that an error occurred while initializing the " "module, which includes execution of the module's code." msgstr "" -"Les détails de la première étape, de recherche et de chargement des modules " +"Les détails de la première étape, de recherche et de chargement des modules, " "sont décrits largement dans la section relative au :ref:`système " "d'importation `, qui décrit également les différents types de " "paquets et modules qui peuvent être importés, de même que les points " @@ -1516,464 +1513,455 @@ msgstr "Les spécifications pour l'instruction :keyword:`nonlocal`." #: reference/simple_stmts.rst:8 msgid "simple" -msgstr "" +msgstr "simple" #: reference/simple_stmts.rst:38 reference/simple_stmts.rst:262 #: reference/simple_stmts.rst:378 reference/simple_stmts.rst:443 #: reference/simple_stmts.rst:482 reference/simple_stmts.rst:555 #: reference/simple_stmts.rst:703 reference/simple_stmts.rst:858 #: reference/simple_stmts.rst:991 -#, fuzzy msgid "statement" -msgstr "Les instructions simples" +msgstr "instruction" #: reference/simple_stmts.rst:41 msgid "expression" -msgstr "" +msgstr "expression" #: reference/simple_stmts.rst:41 reference/simple_stmts.rst:115 #: reference/simple_stmts.rst:443 msgid "list" -msgstr "" +msgstr "liste" #: reference/simple_stmts.rst:972 msgid "built-in function" -msgstr "" +msgstr "fonction native" #: reference/simple_stmts.rst:55 msgid "repr" -msgstr "" +msgstr "repr" #: reference/simple_stmts.rst:74 reference/simple_stmts.rst:195 #: reference/simple_stmts.rst:577 msgid "object" -msgstr "" +msgstr "objet" #: reference/simple_stmts.rst:55 msgid "None" -msgstr "" +msgstr "None" #: reference/simple_stmts.rst:55 msgid "string" -msgstr "" +msgstr "chaîne de caractères" #: reference/simple_stmts.rst:55 msgid "conversion" -msgstr "" +msgstr "conversion" #: reference/simple_stmts.rst:55 msgid "output" -msgstr "" +msgstr "sortie" #: reference/simple_stmts.rst:55 msgid "standard" -msgstr "" +msgstr "standard" #: reference/simple_stmts.rst:55 msgid "writing" -msgstr "" +msgstr "écrire" #: reference/simple_stmts.rst:55 msgid "values" -msgstr "" +msgstr "valeurs" #: reference/simple_stmts.rst:55 msgid "procedure" -msgstr "" +msgstr "procédure" #: reference/simple_stmts.rst:55 msgid "call" -msgstr "" +msgstr "appel" #: reference/simple_stmts.rst:74 msgid "= (equals)" -msgstr "" +msgstr "= (égal)" #: reference/simple_stmts.rst:74 -#, fuzzy msgid "assignment statement" -msgstr "Les assignations" +msgstr "instruction d'affectation" #: reference/simple_stmts.rst:115 reference/simple_stmts.rst:186 #: reference/simple_stmts.rst:262 reference/simple_stmts.rst:321 msgid "assignment" -msgstr "" +msgstr "affectation" #: reference/simple_stmts.rst:728 reference/simple_stmts.rst:944 msgid "binding" -msgstr "" +msgstr "liaison" #: reference/simple_stmts.rst:456 reference/simple_stmts.rst:783 #: reference/simple_stmts.rst:944 msgid "name" -msgstr "" +msgstr "nom" #: reference/simple_stmts.rst:74 msgid "rebinding" -msgstr "" +msgstr "redéfinir une liaison" #: reference/simple_stmts.rst:186 msgid "mutable" -msgstr "" +msgstr "mutable" #: reference/simple_stmts.rst:158 reference/simple_stmts.rst:465 msgid "attribute" -msgstr "" +msgstr "attribut" #: reference/simple_stmts.rst:115 reference/simple_stmts.rst:682 msgid "target" -msgstr "" +msgstr "cible" #: reference/simple_stmts.rst:378 reference/simple_stmts.rst:944 #: reference/simple_stmts.rst:991 msgid ", (comma)" -msgstr "" +msgstr ", (virgule)" #: reference/simple_stmts.rst:115 msgid "in target list" -msgstr "" +msgstr "dans la liste cible" #: reference/simple_stmts.rst:809 msgid "* (asterisk)" -msgstr "" +msgstr "* (astérisque)" #: reference/simple_stmts.rst:115 -#, fuzzy msgid "in assignment target list" -msgstr "Les assignations" +msgstr "dans la liste cible d'affectation" #: reference/simple_stmts.rst:115 msgid "[] (square brackets)" -msgstr "" +msgstr "[] (crochets)" #: reference/simple_stmts.rst:115 msgid "() (parentheses)" -msgstr "" +msgstr "() (parenthèses)" #: reference/simple_stmts.rst:152 msgid "destructor" -msgstr "" +msgstr "destructeur" #: reference/simple_stmts.rst:186 msgid "subscription" -msgstr "" +msgstr "sélection (ou indiçage)" #: reference/simple_stmts.rst:195 msgid "sequence" -msgstr "" +msgstr "séquence" #: reference/simple_stmts.rst:206 msgid "mapping" -msgstr "" +msgstr "tableau de correspondances" #: reference/simple_stmts.rst:206 msgid "dictionary" -msgstr "" +msgstr "dictionnaire" #: reference/simple_stmts.rst:219 msgid "slicing" -msgstr "" +msgstr "découpage" #: reference/simple_stmts.rst:262 msgid "augmented" -msgstr "" +msgstr "augmentée" #: reference/simple_stmts.rst:262 -#, fuzzy msgid "assignment, augmented" -msgstr "Les assignations" +msgstr "affectation, augmentée" #: reference/simple_stmts.rst:262 msgid "+=" -msgstr "" +msgstr "+=" #: reference/simple_stmts.rst:262 -#, fuzzy msgid "augmented assignment" -msgstr "Les assignations augmentées" +msgstr "affectation augmentée" #: reference/simple_stmts.rst:262 msgid "-=" -msgstr "" +msgstr "-=" #: reference/simple_stmts.rst:262 msgid "*=" -msgstr "" +msgstr "*=" #: reference/simple_stmts.rst:262 msgid "/=" -msgstr "" +msgstr "/=" #: reference/simple_stmts.rst:262 msgid "%=" -msgstr "" +msgstr "%=" #: reference/simple_stmts.rst:262 msgid "&=" -msgstr "" +msgstr "&=" #: reference/simple_stmts.rst:262 msgid "^=" -msgstr "" +msgstr "^=" #: reference/simple_stmts.rst:262 msgid "|=" -msgstr "" +msgstr "|=" #: reference/simple_stmts.rst:262 msgid "**=" -msgstr "" +msgstr "**=" #: reference/simple_stmts.rst:262 msgid "//=" -msgstr "" +msgstr "//=" #: reference/simple_stmts.rst:262 msgid ">>=" -msgstr "" +msgstr ">>=" #: reference/simple_stmts.rst:262 msgid "<<=" -msgstr "" +msgstr "<<=" #: reference/simple_stmts.rst:321 msgid "annotated" -msgstr "" +msgstr "annotée" #: reference/simple_stmts.rst:321 -#, fuzzy msgid "assignment, annotated" -msgstr "Les assignations" +msgstr "affectation annotée" #: reference/simple_stmts.rst:321 msgid ": (colon)" -msgstr "" +msgstr ": (deux-points)" #: reference/simple_stmts.rst:321 msgid "annotated variable" -msgstr "" +msgstr "variable annotée" #: reference/simple_stmts.rst:378 msgid "assert" -msgstr "" +msgstr "assert" #: reference/simple_stmts.rst:378 msgid "debugging" -msgstr "" +msgstr "débogage" #: reference/simple_stmts.rst:378 msgid "assertions" -msgstr "" +msgstr "assertions" #: reference/simple_stmts.rst:378 -#, fuzzy msgid "expression list" -msgstr "Les expressions" +msgstr "liste d'expressions" #: reference/simple_stmts.rst:399 msgid "__debug__" -msgstr "" +msgstr "__debug__" #: reference/simple_stmts.rst:519 reference/simple_stmts.rst:587 #: reference/simple_stmts.rst:728 msgid "exception" -msgstr "" +msgstr "exception" #: reference/simple_stmts.rst:399 msgid "AssertionError" -msgstr "" +msgstr "AssertionError" #: reference/simple_stmts.rst:421 msgid "pass" -msgstr "" +msgstr "pass" #: reference/simple_stmts.rst:421 msgid "null" -msgstr "" +msgstr "null" #: reference/simple_stmts.rst:421 msgid "operation" -msgstr "" +msgstr "opération" #: reference/simple_stmts.rst:443 msgid "del" -msgstr "" +msgstr "del" #: reference/simple_stmts.rst:465 msgid "deletion" -msgstr "" +msgstr "effacement" #: reference/simple_stmts.rst:944 msgid "global" -msgstr "" +msgstr "global" #: reference/simple_stmts.rst:456 msgid "unbinding" -msgstr "" +msgstr "suppression de liaison" #: reference/simple_stmts.rst:482 msgid "return" -msgstr "" +msgstr "return" #: reference/simple_stmts.rst:519 msgid "function" -msgstr "" +msgstr "fonction" #: reference/simple_stmts.rst:482 msgid "definition" -msgstr "" +msgstr "définition" #: reference/simple_stmts.rst:482 msgid "class" -msgstr "" +msgstr "classe" #: reference/simple_stmts.rst:682 reference/simple_stmts.rst:703 #: reference/simple_stmts.rst:728 msgid "keyword" -msgstr "" +msgstr "mot-clé" #: reference/simple_stmts.rst:691 reference/simple_stmts.rst:703 msgid "finally" -msgstr "" +msgstr "finally" #: reference/simple_stmts.rst:519 msgid "yield" -msgstr "" +msgstr "yield" #: reference/simple_stmts.rst:519 msgid "generator" -msgstr "" +msgstr "générateur" #: reference/simple_stmts.rst:519 msgid "iterator" -msgstr "" +msgstr "itérateur" #: reference/simple_stmts.rst:519 msgid "StopIteration" -msgstr "" +msgstr "StopIteration" #: reference/simple_stmts.rst:555 msgid "raise" -msgstr "" +msgstr "raise" #: reference/simple_stmts.rst:555 msgid "raising" -msgstr "" +msgstr "lever" #: reference/simple_stmts.rst:555 msgid "__traceback__ (exception attribute)" -msgstr "" +msgstr "__traceback__ (attribut d'exception)" #: reference/simple_stmts.rst:577 msgid "traceback" -msgstr "" +msgstr "trace d'appels" #: reference/simple_stmts.rst:587 msgid "chaining" -msgstr "" +msgstr "chaîner" #: reference/simple_stmts.rst:587 msgid "__cause__ (exception attribute)" -msgstr "" +msgstr "__cause__ (attribut d'exception)" #: reference/simple_stmts.rst:587 msgid "__context__ (exception attribute)" -msgstr "" +msgstr "__context__ (attribut d'exception)" #: reference/simple_stmts.rst:669 msgid "break" -msgstr "" +msgstr "break" #: reference/simple_stmts.rst:703 msgid "for" -msgstr "" +msgstr "for" #: reference/simple_stmts.rst:703 msgid "while" -msgstr "" +msgstr "while" #: reference/simple_stmts.rst:703 msgid "loop" -msgstr "" +msgstr "boucle" #: reference/simple_stmts.rst:682 msgid "else" -msgstr "" +msgstr "else" #: reference/simple_stmts.rst:682 msgid "loop control" -msgstr "" +msgstr "contrôle de boucle" #: reference/simple_stmts.rst:703 msgid "continue" -msgstr "" +msgstr "continue" #: reference/simple_stmts.rst:831 msgid "import" -msgstr "" +msgstr "importation" #: reference/simple_stmts.rst:728 msgid "module" -msgstr "" +msgstr "module" #: reference/simple_stmts.rst:728 msgid "importing" -msgstr "" +msgstr "importer" #: reference/simple_stmts.rst:783 msgid "from" -msgstr "" +msgstr "from" #: reference/simple_stmts.rst:770 msgid "as" -msgstr "" +msgstr "as" #: reference/simple_stmts.rst:728 msgid "ImportError" -msgstr "" +msgstr "ImportError" #: reference/simple_stmts.rst:770 reference/simple_stmts.rst:809 -#, fuzzy msgid "import statement" -msgstr "Les instructions simples" +msgstr "instruction *import*" #: reference/simple_stmts.rst:815 msgid "__all__ (optional module attribute)" -msgstr "" +msgstr "__all__ (attribut de module facultatif)" #: reference/simple_stmts.rst:831 msgid "relative" -msgstr "" +msgstr "relative" #: reference/simple_stmts.rst:858 msgid "future" -msgstr "" +msgstr "future" #: reference/simple_stmts.rst:858 msgid "__future__" -msgstr "" +msgstr "__future__" #: reference/simple_stmts.rst:858 -#, fuzzy msgid "future statement" -msgstr "L'instruction future" +msgstr "instruction *future*" #: reference/simple_stmts.rst:991 msgid "identifier list" -msgstr "" +msgstr "liste d'identifiants" #: reference/simple_stmts.rst:972 msgid "exec" -msgstr "" +msgstr "exec" #: reference/simple_stmts.rst:972 msgid "eval" -msgstr "" +msgstr "eval" #: reference/simple_stmts.rst:972 msgid "compile" -msgstr "" +msgstr "compiler" #: reference/simple_stmts.rst:991 msgid "nonlocal" -msgstr "" +msgstr "nonlocal" diff --git a/reference/toplevel_components.po b/reference/toplevel_components.po index 0130b3d2..c91037a2 100644 --- a/reference/toplevel_components.po +++ b/reference/toplevel_components.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-07-23 14:38+0200\n" -"PO-Revision-Date: 2019-03-19 23:26+0100\n" -"Last-Translator: \n" +"PO-Revision-Date: 2023-12-07 23:07+0100\n" +"Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \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 2.0.2\n" +"X-Generator: Poedit 3.2.2\n" #: reference/toplevel_components.rst:6 msgid "Top-level components" @@ -157,58 +157,56 @@ msgstr "" #: reference/toplevel_components.rst:8 msgid "interpreter" -msgstr "" +msgstr "interpréteur" #: reference/toplevel_components.rst:21 msgid "program" -msgstr "" +msgstr "programme" #: reference/toplevel_components.rst:23 reference/toplevel_components.rst:39 msgid "module" -msgstr "" +msgstr "module" #: reference/toplevel_components.rst:23 msgid "sys" -msgstr "" +msgstr "sys" #: reference/toplevel_components.rst:23 reference/toplevel_components.rst:39 msgid "__main__" -msgstr "" +msgstr "__main__" #: reference/toplevel_components.rst:23 msgid "builtins" -msgstr "" +msgstr "builtins" #: reference/toplevel_components.rst:39 -#, fuzzy msgid "interactive mode" -msgstr "Entrée interactive" +msgstr "mode interactif" #: reference/toplevel_components.rst:49 msgid "UNIX" -msgstr "" +msgstr "UNIX" #: reference/toplevel_components.rst:49 msgid "Windows" -msgstr "" +msgstr "Windows" #: reference/toplevel_components.rst:49 msgid "command line" -msgstr "" +msgstr "ligne de commande" #: reference/toplevel_components.rst:49 msgid "standard input" -msgstr "" +msgstr "entrée standard" #: reference/toplevel_components.rst:100 -#, fuzzy msgid "input" -msgstr "Fichier d'entrée" +msgstr "entrée" #: reference/toplevel_components.rst:101 msgid "built-in function" -msgstr "" +msgstr "fonction native" #: reference/toplevel_components.rst:101 msgid "eval" -msgstr "" +msgstr "eval"