From ee1ee4d28d5e551fe516046929b92bad1259b9fd Mon Sep 17 00:00:00 2001 From: Christophe Nanteuil Date: Sat, 7 Oct 2023 19:47:25 +0200 Subject: [PATCH] fin de fuzzies pour reference --- reference/compound_stmts.po | 385 ++++++++++---------- reference/datamodel.po | 580 +++++++++++++++++-------------- reference/executionmodel.po | 82 ++--- reference/expressions.po | 513 +++++++++++++-------------- reference/import.po | 59 ++-- reference/introduction.po | 26 +- reference/lexical_analysis.po | 245 +++++++------ reference/simple_stmts.po | 254 +++++++------- reference/toplevel_components.po | 36 +- 9 files changed, 1105 insertions(+), 1075 deletions(-) diff --git a/reference/compound_stmts.po b/reference/compound_stmts.po index 46252926..1a96e9e4 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-10-07 19:42+0200\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 parente (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 déclenché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 mélanger :keyword:`except` et :keyword:`!except*` dans un même :" +"keyword:`try`. :keyword:`break`, :keyword:`continue` et :keyword:`return` ne " +"peuvent pas 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 "compound" #: 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 "dangling" #: 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 "keyword" #: 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 "loop" #: 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 "traceback" #: 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 "guard" #: 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 "! patterns" #: 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 "default" #: 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/datamodel.po b/reference/datamodel.po index 6fbc0d04..44109bf6 100644 --- a/reference/datamodel.po +++ b/reference/datamodel.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-10-01 16:53+0200\n" -"Last-Translator: Christophe Nanteuil \n" +"PO-Revision-Date: 2022-11-20 21:56+0100\n" +"Last-Translator: Jean Abou Samra \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.2\n" +"X-Generator: Poedit 2.4.2\n" #: reference/datamodel.rst:6 msgid "Data model" @@ -501,7 +501,7 @@ msgstr "" "Ils représentent des ensembles de taille finie indicés par des entiers " "positifs ou nuls. La fonction native :func:`len` renvoie le nombre " "d'éléments de la séquence. Quand la longueur d'une séquence est *n*, " -"l'ensemble des indices contient les entiers 0, 1 …, *n-1*. On accède à " +"l'ensemble des indices contient les entiers 0, 1, …, *n-1*. On accède à " "l'élément d'indice *i* de la séquence *a* par ``a[i]``." #: reference/datamodel.rst:283 @@ -558,6 +558,7 @@ msgid "Strings" msgstr "Chaînes de caractères" #: reference/datamodel.rst:317 +#, fuzzy msgid "" "A string is a sequence of values that represent Unicode code points. All the " "code points in the range ``U+0000 - U+10FFFF`` can be represented in a " @@ -573,7 +574,7 @@ msgstr "" "Une chaîne de caractères (*string* en anglais) est une séquence de valeurs " "qui représentent des caractères Unicode. Tout caractère dont le code est " "dans l'intervalle ``U+0000 - U+10FFFF`` peut être représenté dans une " -"chaîne. Python ne possède pas de type :c:expr:`char` ; à la place, chaque " +"chaîne. Python ne possède pas de type :c:type:`char` ; à la place, chaque " "caractère Unicode dans la chaîne est représenté par un objet chaîne de " "longueur ``1``. La fonction native :func:`ord` convertit un caractère " "Unicode de la représentation en chaîne vers un entier dans l'intervalle ``0 " @@ -1688,6 +1689,7 @@ msgstr "" "objets muables." #: reference/datamodel.rst:975 +#, fuzzy msgid "" "Special read-only attributes: :attr:`co_name` gives the function name; :attr:" "`co_qualname` gives the fully qualified function name; :attr:`co_argcount` " @@ -2222,6 +2224,7 @@ msgstr "" "(classiquement une instance de *cls*)." #: reference/datamodel.rst:1272 +#, fuzzy msgid "" "Typical implementations create a new instance of the class by invoking the " "superclass's :meth:`__new__` method using ``super().__new__(cls[, ...])`` " @@ -2354,14 +2357,6 @@ msgid "" "references its own traceback, which references the locals of all frames " "caught in the traceback." msgstr "" -"Il est possible qu'un cycle de référence empêche le compteur de références " -"d'un objet d'atteindre zéro. Dans ce cas, le cycle sera ultérieurement " -"détecté et supprimé par le :term:`ramasse miettes `. Une " -"cause fréquente de cycle de références est lorsqu'une exception a été " -"interceptée dans une variable locale. Les paramètres locaux de la trame font " -"ensuite référence à l'exception, qui fait référence à son propre traçage, " -"qui fait référence aux paramètres locaux de toutes les trames capturées dans " -"le traçage." #: reference/datamodel.rst:1347 msgid "Documentation for the :mod:`gc` module." @@ -2656,6 +2651,7 @@ msgstr "" "print(sys.hash_info.width)\"``." #: reference/datamodel.rst:1524 +#, fuzzy msgid "" "If a class does not define an :meth:`__eq__` method it should not define a :" "meth:`__hash__` operation either; if it defines :meth:`__eq__` but not :meth:" @@ -2672,9 +2668,9 @@ msgstr "" "utilisées en tant qu'élément dans une collection de hachables. Si une classe " "définit des objets mutables et implémente la méthode :meth:`__eq__`, elle ne " "doit pas implémenter :meth:`__hash__` puisque l'implémentation des " -"collections :term:`hachables ` requiert que les clés soient des " -"empreintes immuables (si l'empreinte d'un objet change, il ne sera plus " -"stocké à l'emplacement prévu)." +"collections hachables requiert que les clés soient des empreintes immuables " +"(si l'empreinte d'un objet change, il ne sera plus stocké à l'emplacement " +"prévu)." #: reference/datamodel.rst:1533 msgid "" @@ -2743,6 +2739,7 @@ msgstr "" "valeur n'est pas prévisible entre deux invocations de Python." #: reference/datamodel.rst:1563 +#, fuzzy msgid "" "This is intended to provide protection against a denial-of-service caused by " "carefully chosen inputs that exploit the worst case performance of a dict " @@ -2752,8 +2749,8 @@ msgstr "" "C'est un comportement voulu pour se protéger contre un déni de service qui " "utiliserait des entrées malicieusement choisies pour effectuer des " "insertions dans le dictionnaire dans le pire cas, avec une complexité en " -"O(n\\ :sup:`2`). Lisez http://ocert.org/advisories/ocert-2011-003.html pour " -"en obtenir les détails (article en anglais)." +"O(n\\ :sup:`2`). Lisez http://www.ocert.org/advisories/ocert-2011-003.html " +"pour en obtenir les détails (article en anglais)." #: reference/datamodel.rst:1568 msgid "" @@ -3424,15 +3421,16 @@ msgstr "" "ajoutée pour empêcher cela." #: reference/datamodel.rst:1947 +#, fuzzy msgid "" ":exc:`TypeError` will be raised if nonempty *__slots__* are defined for a " "class derived from a :c:member:`\"variable-length\" built-in type " "` such as :class:`int`, :class:`bytes`, and :class:" "`tuple`." msgstr "" -"Une :exc:`TyeError` est levée si un *__slot__* non vide est défini pour une " -"classe dérivée des :c:member:`types natifs à longueur variable ` tels que :class:`int`, :class:`bytes` et :class:`tuple`." +"Un *__slot__* non vide ne fonctionne pas pour les classes dérivées des types " +"natifs à longueur variable tels que :class:`int`, :class:`bytes` et :class:" +"`tuple`." #: reference/datamodel.rst:1952 msgid "Any non-string :term:`iterable` may be assigned to *__slots__*." @@ -3647,6 +3645,7 @@ msgid "Resolving MRO entries" msgstr "Résolution des entrées MRO" #: reference/datamodel.rst:2090 +#, fuzzy msgid "" "If a base that appears in a class definition is not an instance of :class:" "`type`, then an :meth:`!__mro_entries__` method is searched on the base. If " @@ -3657,33 +3656,30 @@ msgid "" "the base. The returned tuple may be empty: in these cases, the original base " "is ignored." msgstr "" -"Si une classe mère qui apparaît dans la définition d'une classe n'est pas " -"une instance de :class:`type`, alors Python cherche une méthode :meth:`!" -"__mro_entries__` dans cette classe mère. S'il la trouve, au moment de la " -"création de la classe, la classe mère est remplacée par le résultat de " -"l'appel à :meth:`!__mro_entries__`. Cette méthode est appelée avec le *n*-" -"uplet des classes mères originales passé comme paramètre *bases*. Cette " -"méthode doit renvoyer un *n*-uplet de classes qui seront utilisées à la " -"place de la classe mère. Le *n*-uplet renvoyé peut être vide : dans ce cas " -"la classe mère originale est ignorée." +"Si une classe de base qui apparaît dans la définition d'une classe n'est pas " +"une instance de :class:`type`, alors Python y recherche une méthode " +"``__mro_entries__``. S'il la trouve, il l'appelle avec le *n*-uplet original " +"des classes de bases. Cette méthode doit renvoyer un *n*-uplet de classes " +"qui est utilisé à la place de la classe de base. Le *n*-uplet peut être " +"vide, dans ce cas la classe de base originale est ignorée." #: reference/datamodel.rst:2102 msgid ":func:`types.resolve_bases`" -msgstr ":func:`types.resolve_bases`" +msgstr "" #: reference/datamodel.rst:2102 msgid "Dynamically resolve bases that are not instances of :class:`type`." msgstr "" -"Résout dynamiquement les classes mères qui ne sont pas des instances de :" -"class:`type`." #: reference/datamodel.rst:2104 msgid ":pep:`560`" -msgstr ":pep:`560`" +msgstr "" #: reference/datamodel.rst:2105 +#, fuzzy msgid "Core support for typing module and generic types." -msgstr "Gestion de base pour les types modules et les types génériques" +msgstr "" +":pep:`560` — Gestion de base pour les types modules et les types génériques" #: reference/datamodel.rst:2109 msgid "Determining the appropriate metaclass" @@ -4158,13 +4154,13 @@ msgid "" "instead. ``__class_getitem__()`` should return a :ref:`GenericAlias` object if it is properly defined." msgstr "" -"D'habitude, la :ref:`sélection d'indices ` d'un objet en " -"utilisant des crochets appelle la méthode :meth:`~object.__getitem__` de " -"l'instance, définie dans la classe de l'objet. Cependant, si l'objet dont on " -"cherche un indice est lui-même une classe, la méthode de classe :meth:" -"`~object.__class_getitem__` peut être appelée à la place. " -"``__class_getitem__()`` doit renvoyer un objet :ref:`GenericAlias` si elle est correctement définie." +"D'habitude, l':ref:`indiçage ` d'un objet en utilisant des " +"crochets appelle la méthode :meth:`~object.__getitem__` de l'instance, " +"définie dans la classe de l'objet. Cependant, si l'objet dont on cherche un " +"indice est lui-même une classe, la méthode de classe :meth:`~object." +"__class_getitem__` peut être appelée à la place. ``__class_getitem__()`` " +"doit renvoyer un objet :ref:`GenericAlias` si elle est " +"correctement définie." #: reference/datamodel.rst:2343 msgid "" @@ -4199,8 +4195,8 @@ msgid "" "example of this can be found in the :mod:`enum` module::" msgstr "" "Cependant, si une classe a une métaclasse particularisée qui définit :meth:" -"`~object.__getitem__`, la sélection d'indices de la classe peut conduire à " -"un comportement différent. Un exemple peut être trouvé dans le module :mod:" +"`~object.__getitem__`, l'indiçage de la classe peut conduire à un " +"comportement différent. Un exemple peut être trouvé dans le module :mod:" "`enum` ::" #: reference/datamodel.rst:2415 @@ -4215,7 +4211,7 @@ msgid "" "called instead of :meth:`~object.__getitem__`" msgstr "" "Introduction de :meth:`~object.__class_getitem__`, et présentation des cas " -"où une :ref:`sélection d'indices ` conduit à l'appel de " +"où un :ref:`indiçage` conduit à l'appel de " "``__class_getitem__()`` au lieu de :meth:`~object.__getitem__`" #: reference/datamodel.rst:2422 @@ -4323,6 +4319,7 @@ msgstr "" # suit un : #: reference/datamodel.rst:2485 +#, fuzzy msgid "" "In CPython, the length is required to be at most :data:`sys.maxsize`. If the " "length is larger than :data:`!sys.maxsize` some features (such as :func:" @@ -4330,8 +4327,8 @@ msgid "" "OverflowError` by truth value testing, an object must define a :meth:" "`__bool__` method." msgstr "" -"en CPython, la longueur doit valoir au maximum :data:`sys.maxsize`. Si la " -"longueur est plus grande que :data:`!sys.maxsize`, des propriétés (telles " +"en CPython, la longueur doit valoir au maximum :attr:`sys.maxsize`. Si la " +"longueur est plus grande que :attr:`!sys.maxsize`, des propriétés (telles " "que :func:`len`) peuvent lever :exc:`OverflowError`. Afin d'éviter de lever :" "exc:`!OverflowError` lors de tests booléens, un objet doit définir la " "méthode :meth:`__bool__`." @@ -4809,6 +4806,7 @@ msgid "Customizing positional arguments in class pattern matching" msgstr "Arguments positionnels dans le filtrage par motif sur les classes" #: reference/datamodel.rst:2836 +#, fuzzy msgid "" "When using a class name in a pattern, positional arguments in the pattern " "are not allowed by default, i.e. ``case MyClass(x, y)`` is typically invalid " @@ -4963,7 +4961,6 @@ msgstr "" "objets :term:`awaitable`. Par exemple, :class:`asyncio.Future` implémente " "cette méthode pour être compatible avec les expressions :keyword:`await`." -# suit un : #: reference/datamodel.rst:2967 msgid "" "The language doesn't place any restriction on the type or value of the " @@ -4971,10 +4968,6 @@ msgid "" "specific to the implementation of the asynchronous execution framework (e." "g. :mod:`asyncio`) that will be managing the :term:`awaitable` object." msgstr "" -"le langage n'impose aucune restriction sur le type ou la valeur des objets " -"générés par l'itérateur renvoyé par ``__await__``, car cela est spécifique à " -"l'implémentation du cadriciel d'exécution asynchrone (par exemple :mod:" -"`asyncio`) qui gère l'objet :term:`awaitable`." #: reference/datamodel.rst:2975 msgid ":pep:`492` for additional information about awaitable objects." @@ -5239,905 +5232,958 @@ msgstr "" #: reference/datamodel.rst:807 reference/datamodel.rst:894 #: reference/datamodel.rst:998 reference/datamodel.rst:1117 #: reference/datamodel.rst:2504 +#, fuzzy msgid "object" -msgstr "Objet" +msgstr "Objets Code" #: reference/datamodel.rst:122 msgid "data" -msgstr "données" +msgstr "" #: reference/datamodel.rst:269 reference/datamodel.rst:386 #: reference/datamodel.rst:690 reference/datamodel.rst:1179 #: reference/datamodel.rst:1418 reference/datamodel.rst:2050 #: reference/datamodel.rst:2632 reference/datamodel.rst:2681 #: reference/datamodel.rst:2738 reference/datamodel.rst:2766 +#, fuzzy msgid "built-in function" -msgstr "Fonction native" +msgstr "Fonctions natives" #: reference/datamodel.rst:23 msgid "id" -msgstr "identifiant" +msgstr "" #: reference/datamodel.rst:122 reference/datamodel.rst:2050 +#, fuzzy msgid "type" -msgstr "type" +msgstr "Ensembles" #: reference/datamodel.rst:23 msgid "identity of an object" -msgstr "identité d'un objet" +msgstr "" #: reference/datamodel.rst:23 msgid "value of an object" -msgstr "valeur d'un objet" +msgstr "" #: reference/datamodel.rst:23 msgid "type of an object" -msgstr "type d'objet" +msgstr "" #: reference/datamodel.rst:23 +#, fuzzy msgid "mutable object" -msgstr "Objet *attendable* (*awaitable*)" +msgstr "Objets *attendables* (*awaitable*)" #: reference/datamodel.rst:23 +#, fuzzy msgid "immutable object" -msgstr "Objet immuable" +msgstr "Objets *attendables* (*awaitable*)" #: reference/datamodel.rst:60 msgid "garbage collection" -msgstr "ramasse-miettes" +msgstr "" #: reference/datamodel.rst:60 msgid "reference counting" -msgstr "comptage de références" +msgstr "" #: reference/datamodel.rst:60 +#, fuzzy msgid "unreachable object" -msgstr "Objet inatteignable" +msgstr "Objets cadres" #: reference/datamodel.rst:807 msgid "container" -msgstr "conteneur" +msgstr "" #: reference/datamodel.rst:122 msgid "hierarchy" -msgstr "hiérarchie" +msgstr "" #: reference/datamodel.rst:122 msgid "extension" -msgstr "extension" +msgstr "" #: reference/datamodel.rst:380 reference/datamodel.rst:729 #: reference/datamodel.rst:910 +#, fuzzy msgid "module" -msgstr "Module" +msgstr "Modules" #: reference/datamodel.rst:244 reference/datamodel.rst:690 msgid "C" -msgstr "C" +msgstr "" #: reference/datamodel.rst:244 reference/datamodel.rst:690 msgid "language" -msgstr "langage" +msgstr "" #: reference/datamodel.rst:807 reference/datamodel.rst:867 #: reference/datamodel.rst:887 +#, fuzzy msgid "attribute" msgstr "Attribut" #: reference/datamodel.rst:135 msgid "special" -msgstr "spécial" +msgstr "" #: reference/datamodel.rst:135 msgid "generic" -msgstr "générique" +msgstr "" #: reference/datamodel.rst:173 msgid "..." -msgstr "..." +msgstr "" #: reference/datamodel.rst:173 msgid "ellipsis literal" -msgstr "points de suspension littéraux" +msgstr "" #: reference/datamodel.rst:894 msgid "numeric" -msgstr "numérique" +msgstr "" #: reference/datamodel.rst:238 reference/datamodel.rst:310 msgid "integer" -msgstr "entier" +msgstr "" #: reference/datamodel.rst:227 msgid "Boolean" -msgstr "Booléen" +msgstr "" #: reference/datamodel.rst:227 msgid "False" -msgstr "Faux" +msgstr "" #: reference/datamodel.rst:227 msgid "True" -msgstr "Vrai" +msgstr "" #: reference/datamodel.rst:238 msgid "representation" -msgstr "représentation" +msgstr "" #: reference/datamodel.rst:244 msgid "floating point" -msgstr "nombre à virgule flottante" +msgstr "" #: reference/datamodel.rst:259 msgid "number" -msgstr "nombre" +msgstr "" #: reference/datamodel.rst:244 msgid "Java" -msgstr "Java" +msgstr "" #: reference/datamodel.rst:2738 msgid "complex" -msgstr "complexe" +msgstr "" #: reference/datamodel.rst:386 reference/datamodel.rst:2474 msgid "len" -msgstr "len" +msgstr "" #: reference/datamodel.rst:894 +#, fuzzy msgid "sequence" -msgstr "Séquence" +msgstr "Séquences" #: reference/datamodel.rst:269 msgid "index operation" -msgstr "opération de sélection d'indices" +msgstr "" #: reference/datamodel.rst:269 msgid "item selection" -msgstr "sélection d'éléments" +msgstr "" #: reference/datamodel.rst:352 reference/datamodel.rst:420 msgid "subscription" -msgstr "sélection" +msgstr "" #: reference/datamodel.rst:352 msgid "slicing" -msgstr "saucissonnage" +msgstr "" #: reference/datamodel.rst:295 +#, fuzzy msgid "immutable sequence" msgstr "Séquences immuables" #: reference/datamodel.rst:295 +#, fuzzy msgid "immutable" -msgstr "ne peut pas être modifié" +msgstr "Accessible en écriture" #: reference/datamodel.rst:1388 reference/datamodel.rst:1418 +#, fuzzy msgid "string" msgstr "Chaînes de caractères" #: reference/datamodel.rst:306 +#, fuzzy msgid "immutable sequences" msgstr "Séquences immuables" #: reference/datamodel.rst:310 msgid "chr" -msgstr "chr" +msgstr "" #: reference/datamodel.rst:310 msgid "ord" -msgstr "ord" +msgstr "" #: reference/datamodel.rst:310 msgid "character" -msgstr "caractère" +msgstr "" #: reference/datamodel.rst:310 msgid "Unicode" -msgstr "Unicode" +msgstr "" #: reference/datamodel.rst:330 +#, fuzzy msgid "tuple" -msgstr "*n*-uplet (*tuple* en anglais)" +msgstr "*n*-uplets (*tuples* en anglais)" #: reference/datamodel.rst:330 msgid "singleton" -msgstr "singleton" +msgstr "" #: reference/datamodel.rst:330 msgid "empty" -msgstr "vide" +msgstr "" #: reference/datamodel.rst:1413 +#, fuzzy msgid "bytes" msgstr "Chaînes d'octets (ou *bytes*)" #: reference/datamodel.rst:343 msgid "byte" -msgstr "octet" +msgstr "" #: reference/datamodel.rst:352 +#, fuzzy msgid "mutable sequence" msgstr "Séquences immuables" #: reference/datamodel.rst:352 +#, fuzzy msgid "mutable" -msgstr "peut être modifié" +msgstr "Accessible en écriture" #: reference/datamodel.rst:824 reference/datamodel.rst:887 msgid "assignment" -msgstr "affectation" +msgstr "" #: reference/datamodel.rst:729 reference/datamodel.rst:1309 #: reference/datamodel.rst:2793 msgid "statement" -msgstr "instruction" +msgstr "" #: reference/datamodel.rst:366 msgid "list" -msgstr "liste" +msgstr "" #: reference/datamodel.rst:373 +#, fuzzy msgid "bytearray" msgstr "Tableaux d'octets" #: reference/datamodel.rst:380 msgid "array" -msgstr "tableau" +msgstr "" #: reference/datamodel.rst:386 +#, fuzzy msgid "set type" -msgstr "Type « Ensemble »" +msgstr "Ensembles" #: reference/datamodel.rst:405 msgid "set" -msgstr "ensemble" +msgstr "" #: reference/datamodel.rst:412 +#, fuzzy msgid "frozenset" -msgstr "Ensemble figé" +msgstr "Ensembles figés" #: reference/datamodel.rst:894 +#, fuzzy msgid "mapping" -msgstr "Tableau de correspondances" +msgstr "Tableaux de correspondances" #: reference/datamodel.rst:807 reference/datamodel.rst:1499 +#, fuzzy msgid "dictionary" -msgstr "Dictionnaire" +msgstr "Dictionnaires" #: reference/datamodel.rst:453 msgid "dbm.ndbm" -msgstr "dbm.ndbm" +msgstr "" #: reference/datamodel.rst:453 msgid "dbm.gnu" -msgstr "dbm.gnu" +msgstr "" #: reference/datamodel.rst:467 +#, fuzzy msgid "callable" -msgstr "Types « appelable »" +msgstr "Types appelables" #: reference/datamodel.rst:477 reference/datamodel.rst:660 #: reference/datamodel.rst:690 +#, fuzzy msgid "function" -msgstr "Fonction native" +msgstr "Fonctions natives" #: reference/datamodel.rst:807 reference/datamodel.rst:2427 msgid "call" -msgstr "appel" +msgstr "" #: reference/datamodel.rst:467 msgid "invocation" -msgstr "invocation" +msgstr "" #: reference/datamodel.rst:467 msgid "argument" -msgstr "argument" +msgstr "" #: reference/datamodel.rst:582 +#, fuzzy msgid "user-defined" -msgstr "défini par l'utilisateur" +msgstr "Fonctions définies par l'utilisateur" #: reference/datamodel.rst:477 +#, fuzzy msgid "user-defined function" -msgstr "Fonction définie par l'utilisateur" +msgstr "Fonctions définies par l'utilisateur" #: reference/datamodel.rst:491 msgid "__doc__ (function attribute)" -msgstr "__doc__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__name__ (function attribute)" -msgstr "__name__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__module__ (function attribute)" -msgstr "__module__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__dict__ (function attribute)" -msgstr "__dict__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__defaults__ (function attribute)" -msgstr "__defaults__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__closure__ (function attribute)" -msgstr "__closure__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__code__ (function attribute)" -msgstr "__code__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__globals__ (function attribute)" -msgstr "__globals__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__annotations__ (function attribute)" -msgstr "__annotations__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "__kwdefaults__ (function attribute)" -msgstr "__kwdefaults__ (attribut de fonction)" +msgstr "" #: reference/datamodel.rst:491 msgid "global" -msgstr "global" +msgstr "" #: reference/datamodel.rst:748 msgid "namespace" -msgstr "espace de noms" +msgstr "" #: reference/datamodel.rst:705 msgid "method" -msgstr "méthode" +msgstr "" #: reference/datamodel.rst:582 +#, fuzzy msgid "user-defined method" -msgstr "Méthode définie par l'utilisateur" +msgstr "Fonctions définies par l'utilisateur" #: reference/datamodel.rst:590 msgid "__func__ (method attribute)" -msgstr "__func__ (attribut de méthode)" +msgstr "" #: reference/datamodel.rst:590 msgid "__self__ (method attribute)" -msgstr "__self__ (attribut de méthode)" +msgstr "" #: reference/datamodel.rst:590 msgid "__doc__ (method attribute)" -msgstr "__doc__ (attribut de méthode)" +msgstr "" #: reference/datamodel.rst:590 msgid "__name__ (method attribute)" -msgstr "__name__ (attribut de méthode)" +msgstr "" #: reference/datamodel.rst:590 msgid "__module__ (method attribute)" -msgstr "__module__ (attribut de méthode)" +msgstr "" #: reference/datamodel.rst:998 msgid "generator" -msgstr "Générateur" +msgstr "" #: reference/datamodel.rst:645 msgid "iterator" -msgstr "itérateur" +msgstr "" #: reference/datamodel.rst:2939 +#, fuzzy msgid "coroutine" -msgstr "Coroutine" +msgstr "Coroutines" #: reference/datamodel.rst:670 +#, fuzzy msgid "asynchronous generator" -msgstr "générateur asynchrone" +msgstr "Itérateurs asynchrones" #: reference/datamodel.rst:670 +#, fuzzy msgid "asynchronous iterator" -msgstr "Itérateur asynchrone" +msgstr "Itérateurs asynchrones" #: reference/datamodel.rst:705 +#, fuzzy msgid "built-in method" -msgstr "Méthode native" +msgstr "Méthodes natives" #: reference/datamodel.rst:705 msgid "built-in" -msgstr "natif" +msgstr "" #: reference/datamodel.rst:729 msgid "import" -msgstr "importation" +msgstr "" #: reference/datamodel.rst:748 msgid "__name__ (module attribute)" -msgstr "__name__ (attribut de module)" +msgstr "" #: reference/datamodel.rst:748 +#, fuzzy msgid "__doc__ (module attribute)" -msgstr "__doc__ (attribut de module)" +msgstr "l'attribut ``__class__`` du module est maintenant en lecture-écriture." #: reference/datamodel.rst:748 msgid "__file__ (module attribute)" -msgstr "__file__ (attribut de module)" +msgstr "" #: reference/datamodel.rst:748 msgid "__annotations__ (module attribute)" -msgstr "__annotations__ (attribut de module)" +msgstr "" #: reference/datamodel.rst:779 msgid "__dict__ (module attribute)" -msgstr "__dict__ (attribut de module)" +msgstr "" #: reference/datamodel.rst:824 reference/datamodel.rst:1292 #: reference/datamodel.rst:2157 +#, fuzzy msgid "class" -msgstr "Classe" +msgstr "Classes" #: reference/datamodel.rst:867 reference/datamodel.rst:887 +#, fuzzy msgid "class instance" msgstr "Instances de classe" #: reference/datamodel.rst:867 reference/datamodel.rst:2427 +#, fuzzy msgid "instance" -msgstr "Instance" +msgstr "Instances de classe" #: reference/datamodel.rst:829 +#, fuzzy msgid "class object" -msgstr "Objets « classe »" +msgstr "Objets méthodes de classes" #: reference/datamodel.rst:833 msgid "__name__ (class attribute)" -msgstr "__name__ (attribut de classe)" +msgstr "" #: reference/datamodel.rst:833 msgid "__module__ (class attribute)" -msgstr "__module__ (attribut de classe)" +msgstr "" #: reference/datamodel.rst:833 msgid "__dict__ (class attribute)" -msgstr "__dict__ (attribut de classe)" +msgstr "" #: reference/datamodel.rst:833 msgid "__bases__ (class attribute)" -msgstr "__bases__ (attribut de classe)" +msgstr "" #: reference/datamodel.rst:833 msgid "__doc__ (class attribute)" -msgstr "__doc__ (attribut de classe)" +msgstr "" #: reference/datamodel.rst:833 msgid "__annotations__ (class attribute)" -msgstr "__annotations__ (attribut de classe)" +msgstr "" #: reference/datamodel.rst:902 msgid "__dict__ (instance attribute)" -msgstr "__dict__ (attribut d'instance)" +msgstr "" #: reference/datamodel.rst:902 msgid "__class__ (instance attribute)" -msgstr "__class__ (attribut d'instance)" +msgstr "" #: reference/datamodel.rst:910 msgid "open" -msgstr "ouvrir" +msgstr "" #: reference/datamodel.rst:910 msgid "io" -msgstr "io" +msgstr "" #: reference/datamodel.rst:910 msgid "popen() (in module os)" -msgstr "popen() (dans le module os)" +msgstr "" #: reference/datamodel.rst:910 msgid "makefile() (socket method)" -msgstr "makefile() (méthode de connecteur)" +msgstr "" #: reference/datamodel.rst:910 msgid "sys.stdin" -msgstr "sys.stdin" +msgstr "" #: reference/datamodel.rst:910 msgid "sys.stdout" -msgstr "sys.stdout" +msgstr "" #: reference/datamodel.rst:910 msgid "sys.stderr" -msgstr "sys.stderr" +msgstr "" #: reference/datamodel.rst:910 msgid "stdio" -msgstr "stdio" +msgstr "" #: reference/datamodel.rst:910 msgid "stdin (in module sys)" -msgstr "stdin (dans le module sys)" +msgstr "" #: reference/datamodel.rst:910 msgid "stdout (in module sys)" -msgstr "stdout (dans le module sys)" +msgstr "" #: reference/datamodel.rst:910 msgid "stderr (in module sys)" -msgstr "stderr (dans le module sys)" +msgstr "" #: reference/datamodel.rst:936 +#, fuzzy msgid "internal type" -msgstr "Type interne" +msgstr "Types internes" #: reference/datamodel.rst:936 msgid "types, internal" -msgstr "types, interne" +msgstr "" #: reference/datamodel.rst:944 msgid "bytecode" -msgstr "code intermédiaire" +msgstr "" #: reference/datamodel.rst:944 msgid "code" -msgstr "code" +msgstr "" #: reference/datamodel.rst:944 +#, fuzzy msgid "code object" -msgstr "Objets « code »" +msgstr "Objets Code" #: reference/datamodel.rst:956 msgid "co_argcount (code object attribute)" -msgstr "co_argcount (attribut d'objet de code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_posonlyargcount (code object attribute)" -msgstr "co_posonlyargcount (attribut d'objet de code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_kwonlyargcount (code object attribute)" -msgstr "co_kwonlyargcount (attribut d'objet de code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_code (code object attribute)" -msgstr "co_code (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_consts (code object attribute)" -msgstr "co_consts (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_filename (code object attribute)" -msgstr "co_filename (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_firstlineno (code object attribute)" -msgstr "co_firstlineno (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_flags (code object attribute)" -msgstr "co_flags (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_lnotab (code object attribute)" -msgstr "co_lnotab (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_name (code object attribute)" -msgstr "co_name (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_names (code object attribute)" -msgstr "co_names (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_nlocals (code object attribute)" -msgstr "co_nlocals (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_stacksize (code object attribute)" -msgstr "co_stacksize (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_varnames (code object attribute)" -msgstr "co_varnames (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_cellvars (code object attribute)" -msgstr "co_cellvars (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_freevars (code object attribute)" -msgstr "co_freevars (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:956 msgid "co_qualname (code object attribute)" -msgstr "co_qualname (attribut d'objet code)" +msgstr "" #: reference/datamodel.rst:1014 msgid "documentation string" -msgstr "chaîne de documentation" +msgstr "" #: reference/datamodel.rst:1055 msgid "frame" -msgstr "frame" +msgstr "" #: reference/datamodel.rst:1060 msgid "f_back (frame attribute)" -msgstr "f_back (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1060 msgid "f_code (frame attribute)" -msgstr "f_code (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1060 msgid "f_globals (frame attribute)" -msgstr "f_globals (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1060 msgid "f_locals (frame attribute)" -msgstr "f_locals (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1060 msgid "f_lasti (frame attribute)" -msgstr "f_lasti (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1060 msgid "f_builtins (frame attribute)" -msgstr "f_builtins (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1079 msgid "f_trace (frame attribute)" -msgstr "f_trace (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1079 +#, fuzzy msgid "f_trace_lines (frame attribute)" -msgstr "f_trace_lines (attribute de frame)" +msgstr "Attributs prédéfinis (accessibles en écriture) :" #: reference/datamodel.rst:1079 msgid "f_trace_opcodes (frame attribute)" -msgstr "f_trace_opcodes (attribut de frame)" +msgstr "" #: reference/datamodel.rst:1079 +#, fuzzy msgid "f_lineno (frame attribute)" -msgstr "f_lineno (attribut de frame)" +msgstr "Attributs prédéfinis (accessibles en écriture) :" #: reference/datamodel.rst:1117 +#, fuzzy msgid "traceback" -msgstr "trace d'appels" +msgstr "Objets traces d'appels" #: reference/datamodel.rst:1117 msgid "stack" -msgstr "pile" +msgstr "" #: reference/datamodel.rst:1117 msgid "trace" -msgstr "trace" +msgstr "" #: reference/datamodel.rst:1117 msgid "exception" -msgstr "exception" +msgstr "" #: reference/datamodel.rst:1117 msgid "handler" -msgstr "gestionnaire" +msgstr "" #: reference/datamodel.rst:1117 msgid "execution" -msgstr "exécution" +msgstr "" #: reference/datamodel.rst:1117 msgid "exc_info (in module sys)" -msgstr "exc_info (dans le module sys)" +msgstr "" #: reference/datamodel.rst:1117 msgid "last_traceback (in module sys)" -msgstr "last_traceback (dans le module sys)" +msgstr "" #: reference/datamodel.rst:1117 msgid "sys.exc_info" -msgstr "sys.exc_info" +msgstr "" #: reference/datamodel.rst:1117 msgid "sys.exception" -msgstr "sys.exception" +msgstr "" #: reference/datamodel.rst:1117 msgid "sys.last_traceback" -msgstr "sys.last_traceback" +msgstr "" #: reference/datamodel.rst:1149 msgid "tb_frame (traceback attribute)" -msgstr "tb_frame (attribut de trace d'appels)" +msgstr "" #: reference/datamodel.rst:1149 msgid "tb_lineno (traceback attribute)" -msgstr "tb_lineno (attribut de trace d'appels)" +msgstr "" #: reference/datamodel.rst:1149 msgid "tb_lasti (traceback attribute)" -msgstr "tb_lasti (attribut de trace d'appels)" +msgstr "" #: reference/datamodel.rst:1149 msgid "try" -msgstr "try" +msgstr "" #: reference/datamodel.rst:1167 msgid "tb_next (traceback attribute)" -msgstr "tb_next (attribut de trace d'appels)" +msgstr "" #: reference/datamodel.rst:2504 msgid "slice" -msgstr "slice" +msgstr "" #: reference/datamodel.rst:1185 msgid "start (slice object attribute)" -msgstr "start (attribut d'objet slice)" +msgstr "" #: reference/datamodel.rst:1185 msgid "stop (slice object attribute)" -msgstr "stop (attribut d'objet slice)" +msgstr "" #: reference/datamodel.rst:1185 msgid "step (slice object attribute)" -msgstr "step (attribut d'objet slice)" +msgstr "" #: reference/datamodel.rst:1227 msgid "operator" -msgstr "opérateur" +msgstr "" #: reference/datamodel.rst:1227 msgid "overloading" -msgstr "surcharge" +msgstr "" #: reference/datamodel.rst:1227 msgid "__getitem__() (mapping object method)" -msgstr "__getitem__() (méthode d'objet de correspondances)" +msgstr "" #: reference/datamodel.rst:1263 msgid "subclassing" -msgstr "sous-classement (ou dérivation)" +msgstr "" #: reference/datamodel.rst:1263 +#, fuzzy msgid "immutable types" -msgstr "Types immuables" +msgstr "Types appelables" #: reference/datamodel.rst:1292 msgid "constructor" -msgstr "constructeur" +msgstr "" #: reference/datamodel.rst:1309 msgid "destructor" -msgstr "destructeur" +msgstr "" #: reference/datamodel.rst:1309 msgid "finalizer" -msgstr "finaliseur" +msgstr "" #: reference/datamodel.rst:1309 msgid "del" -msgstr "del" +msgstr "" #: reference/datamodel.rst:1371 +#, fuzzy msgid "repr() (built-in function)" -msgstr "repr() (fonction native)" +msgstr "Fonctions natives" #: reference/datamodel.rst:1371 msgid "__repr__() (object method)" -msgstr "__repr__() (méthode d'objet)" +msgstr "" #: reference/datamodel.rst:1388 msgid "__str__() (object method)" -msgstr "__str__() (méthode d'objet)" +msgstr "" #: reference/datamodel.rst:1388 +#, fuzzy msgid "format() (built-in function)" -msgstr "format() (fonction native)" +msgstr "Fonctions natives" #: reference/datamodel.rst:1388 +#, fuzzy msgid "print() (built-in function)" -msgstr "print() (fonction native)" +msgstr "Fonctions natives" #: reference/datamodel.rst:1418 msgid "__format__() (object method)" -msgstr "__format__() (méthode d'objet)" +msgstr "" #: reference/datamodel.rst:1418 msgid "conversion" -msgstr "conversion" +msgstr "" #: reference/datamodel.rst:1418 msgid "print" -msgstr "print" +msgstr "" #: reference/datamodel.rst:1457 msgid "comparisons" -msgstr "comparaisons" +msgstr "" #: reference/datamodel.rst:1499 msgid "hash" -msgstr "hash" +msgstr "" #: reference/datamodel.rst:1580 msgid "__len__() (mapping object method)" -msgstr "__len__() (méthode d'objet de correspondances)" +msgstr "" #: reference/datamodel.rst:1683 +#, fuzzy msgid "__getattr__ (module attribute)" -msgstr "__getattr__ (attribut de module)" +msgstr "attributs ``__getattr__`` et ``__dir__`` du module." #: reference/datamodel.rst:1683 +#, fuzzy msgid "__dir__ (module attribute)" -msgstr "__dir__ (attribut de module)" +msgstr "attributs ``__getattr__`` et ``__dir__`` du module." #: reference/datamodel.rst:1683 +#, fuzzy msgid "__class__ (module attribute)" -msgstr "__class__ (attribut de module)" +msgstr "l'attribut ``__class__`` du module est maintenant en lecture-écriture." #: reference/datamodel.rst:2050 +#, fuzzy msgid "metaclass" -msgstr "métaclasse" +msgstr "Métaclasses" #: reference/datamodel.rst:2050 msgid "= (equals)" -msgstr "= (égal)" +msgstr "" #: reference/datamodel.rst:2050 +#, fuzzy msgid "class definition" -msgstr "définition de classe" +msgstr "Liaison avec une classe" #: reference/datamodel.rst:2110 +#, fuzzy msgid "metaclass hint" -msgstr "indication de métaclasse" +msgstr "Métaclasses" #: reference/datamodel.rst:2133 msgid "__prepare__ (metaclass method)" -msgstr "__prepare__ (méthode de métaclasse)" +msgstr "" #: reference/datamodel.rst:2157 msgid "body" -msgstr "body" +msgstr "" #: reference/datamodel.rst:2177 +#, fuzzy msgid "__class__ (method cell)" -msgstr "__class__ (method cell)" +msgstr "Objets méthodes de classes" #: reference/datamodel.rst:2177 msgid "__classcell__ (class namespace entry)" -msgstr "__classcell__ (entrée d'espace de noms de classe)" +msgstr "" #: reference/datamodel.rst:2474 msgid "__bool__() (object method)" -msgstr "__bool__() (méthode objet)" +msgstr "" #: reference/datamodel.rst:2667 msgid "divmod" -msgstr "divmod" +msgstr "" #: reference/datamodel.rst:2667 reference/datamodel.rst:2681 msgid "pow" -msgstr "pow" +msgstr "" #: reference/datamodel.rst:2728 msgid "abs" -msgstr "abs" +msgstr "" #: reference/datamodel.rst:2738 msgid "int" -msgstr "int" +msgstr "" #: reference/datamodel.rst:2738 msgid "float" -msgstr "float" +msgstr "" #: reference/datamodel.rst:2766 msgid "round" -msgstr "round" +msgstr "" #: reference/datamodel.rst:2793 msgid "with" -msgstr "with" +msgstr "" #: reference/datamodel.rst:2793 +#, fuzzy msgid "context manager" -msgstr "Gestionnaire de contexte" +msgstr "Gestionnaires de contexte asynchrones" #, fuzzy #~ msgid "" diff --git a/reference/executionmodel.po b/reference/executionmodel.po index 35b3ba7b..2153c1ab 100644 --- a/reference/executionmodel.po +++ b/reference/executionmodel.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-10-01 17:05+0200\n" -"Last-Translator: Christophe Nanteuil \n" +"PO-Revision-Date: 2022-11-11 19:54+0100\n" +"Last-Translator: Jules Lasne \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.2\n" +"X-Generator: Poedit 2.4.2\n" #: reference/executionmodel.rst:6 msgid "Execution model" @@ -110,18 +110,18 @@ msgid ":keyword:`for` loop header," msgstr "de l'entête d'une boucle :keyword:`for`," #: reference/executionmodel.rst:69 +#, fuzzy msgid "" "after :keyword:`!as` in a :keyword:`with` statement, :keyword:`except` " "clause, :keyword:`except* ` clause, or in the as-pattern in " "structural pattern matching," msgstr "" "après :keyword:`!as` dans une instruction :keyword:`with`, une clause :" -"keyword:`except`, une clause :keyword:`except* ` ou dans un " -"filtrage par motifs," +"keyword:`except` ou dans un filtrage par motifs," #: reference/executionmodel.rst:71 msgid "in a capture pattern in structural pattern matching" -msgstr "dans un champ de recherche d'un filtrage par motifs," +msgstr "dans un champ de recherche d'un filtrage par motifs" #: reference/executionmodel.rst:73 msgid ":keyword:`import` statements." @@ -133,9 +133,9 @@ msgid "" "names defined in the imported module, except those beginning with an " "underscore. This form may only be used at the module level." msgstr "" -"L'instruction :keyword:`!import` sous la forme ``from … import *`` lie tous " -"les noms définis dans le module importé, sauf ceux qui commencent par le " -"caractère souligné. Cette écriture ne peut être utilisée qu'au niveau du " +"L'instruction :keyword:`!import` sous la forme ``from ... import *`` lie " +"tous les noms définis dans le module importé, sauf ceux qui commencent par " +"le caractère souligné. Cette écriture ne peut être utilisée qu'au niveau du " "module." #: reference/executionmodel.rst:79 @@ -222,6 +222,7 @@ msgstr "" "`UnboundLocalError` est une sous-classe de :exc:`NameError`." #: reference/executionmodel.rst:125 +#, fuzzy msgid "" "If a name binding operation occurs anywhere within a code block, all uses of " "the name within the block are treated as references to the current block. " @@ -239,8 +240,7 @@ msgstr "" "n'attend pas de déclaration de variables et autorise les opérations de " "liaison n'importe où dans un bloc de code. Les variables locales d'un bloc " "de code peuvent être déterminées en parcourant tout le texte du bloc à la " -"recherche des opérations de liaisons. Reportez-vous à :ref:`l'entrée de la " -"FAQ relative à UnboundLocalError ` pour des exemples." +"recherche des opérations de liaisons." #: reference/executionmodel.rst:134 msgid "" @@ -327,7 +327,6 @@ msgstr "" msgid "Builtins and restricted execution" msgstr "Noms natifs et restrictions d'exécution" -# suit un : #: reference/executionmodel.rst:183 msgid "" "Users should not touch ``__builtins__``; it is strictly an implementation " @@ -335,7 +334,7 @@ msgid "" "keyword:`import` the :mod:`builtins` module and modify its attributes " "appropriately." msgstr "" -"l'utilisateur ne doit pas toucher à ``__builtins__`` ; c'est et cela doit " +"L'utilisateur ne doit pas toucher à ``__builtins__`` ; c'est et cela doit " "rester réservé aux besoins de l'implémentation. Les utilisateurs qui " "souhaitent surcharger des valeurs dans l'espace de nommage natif doivent :" "keyword:`importer ` le module :mod:`builtins` et modifier ses " @@ -502,112 +501,117 @@ msgstr "" "moment où le module est compilé." #: reference/executionmodel.rst:8 +#, fuzzy msgid "execution model" msgstr "Modèle d'exécution" #: reference/executionmodel.rst:8 msgid "code" -msgstr "code" +msgstr "" #: reference/executionmodel.rst:17 msgid "block" -msgstr "bloc" +msgstr "" #: reference/executionmodel.rst:31 reference/executionmodel.rst:179 +#, fuzzy msgid "execution" -msgstr "exécution" +msgstr "Modèle d'exécution" #: reference/executionmodel.rst:31 msgid "frame" -msgstr "cadre" +msgstr "" #: reference/executionmodel.rst:42 msgid "namespace" -msgstr "espace de noms" +msgstr "" #: reference/executionmodel.rst:42 reference/executionmodel.rst:101 msgid "scope" -msgstr "portée" +msgstr "" #: reference/executionmodel.rst:51 msgid "name" -msgstr "nom" +msgstr "" #: reference/executionmodel.rst:51 msgid "binding" -msgstr "liaison" +msgstr "" #: reference/executionmodel.rst:57 msgid "from" -msgstr "from" +msgstr "" #: reference/executionmodel.rst:57 +#, fuzzy msgid "import statement" -msgstr "instruction *import*" +msgstr "des instructions :keyword:`import`." #: reference/executionmodel.rst:85 msgid "free" -msgstr "libération" +msgstr "" #: reference/executionmodel.rst:85 msgid "variable" -msgstr "variable" +msgstr "" #: reference/executionmodel.rst:109 msgid "environment" -msgstr "environnement" +msgstr "" #: reference/executionmodel.rst:115 msgid "NameError (built-in exception)" -msgstr "NameError (exception native)" +msgstr "" #: reference/executionmodel.rst:115 msgid "UnboundLocalError" -msgstr "UnboundLocalError" +msgstr "" #: reference/executionmodel.rst:154 msgid "module" -msgstr "module" +msgstr "" #: reference/executionmodel.rst:154 msgid "__main__" -msgstr "__main__" +msgstr "" #: reference/executionmodel.rst:179 msgid "restricted" -msgstr "restricted" +msgstr "" #: reference/executionmodel.rst:226 +#, fuzzy msgid "exception" -msgstr "Exception" +msgstr "Exceptions" #: reference/executionmodel.rst:228 msgid "raise an exception" -msgstr "lever une exception" +msgstr "" #: reference/executionmodel.rst:228 msgid "handle an exception" -msgstr "gérer une exception" +msgstr "" #: reference/executionmodel.rst:228 msgid "exception handler" -msgstr "gestionnaire d'exceptions" +msgstr "" #: reference/executionmodel.rst:228 msgid "errors" -msgstr "erreurs" +msgstr "" #: reference/executionmodel.rst:228 msgid "error handling" -msgstr "gestion des erreurs" +msgstr "" #: reference/executionmodel.rst:249 +#, fuzzy msgid "termination model" -msgstr "Modèle de fin d'exécution" +msgstr "Modèle d'exécution" #: reference/executionmodel.rst:256 msgid "SystemExit (built-in exception)" -msgstr "SystemExit (exception native)" +msgstr "" #~ msgid "" #~ "The following constructs bind names: formal parameters to functions, :" diff --git a/reference/expressions.po b/reference/expressions.po index 90af4c1f..e4701bff 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-10-07 16:52+0200\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" @@ -446,7 +446,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:" @@ -459,7 +458,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 " @@ -471,13 +469,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 " @@ -511,7 +508,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 " @@ -682,7 +678,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 " @@ -707,18 +702,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 "" @@ -936,7 +932,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 " @@ -1545,21 +1540,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 "" @@ -1571,8 +1566,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 @@ -1598,13 +1593,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 "" @@ -1643,7 +1638,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 " @@ -1654,9 +1648,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, ou venant d'un autre " +"dépaquetage), une exception :exc:`TypeError` est levée." #: reference/expressions.rst:1064 msgid "" @@ -1669,6 +1663,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 en a pas, une exception :" +"exc:`TypeError` est levée." #: reference/expressions.rst:1074 msgid "" @@ -2433,7 +2436,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 " @@ -2800,6 +2802,12 @@ 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 " +"sélection, conditionnelles, lambda, argument nommé et 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." @@ -2933,7 +2941,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). " @@ -2947,7 +2954,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 "" @@ -3239,75 +3247,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 "mangling" #: reference/expressions.rst:82 msgid "private" -msgstr "" +msgstr "private" #: reference/expressions.rst:82 msgid "names" -msgstr "" +msgstr "names" #: reference/expressions.rst:104 -#, fuzzy msgid "literal" -msgstr "Littéraux" +msgstr "literal" #: reference/expressions.rst:341 msgid "immutable" -msgstr "" +msgstr "immutable" #: reference/expressions.rst:117 msgid "data" -msgstr "" +msgstr "data" #: 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 @@ -3315,240 +3318,217 @@ msgstr "" #: reference/expressions.rst:1103 reference/expressions.rst:1124 #: reference/expressions.rst:1847 msgid "object" -msgstr "" +msgstr "object" #: reference/expressions.rst:133 -#, fuzzy msgid "parenthesized form" -msgstr "Formes parenthésées" +msgstr "parenthesized form" #: 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 "tuple display" #: reference/expressions.rst:244 msgid "empty" -msgstr "" +msgstr "empty" #: reference/expressions.rst:825 reference/expressions.rst:1847 msgid "tuple" -msgstr "" +msgstr "tuple" #: reference/expressions.rst:1866 msgid "comma" -msgstr "" +msgstr "comma" #: 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 "comprehensions" #: reference/expressions.rst:177 msgid "for" -msgstr "" +msgstr "for" #: reference/expressions.rst:212 msgid "in comprehensions" -msgstr "" +msgstr "in comprehensions\t" #: 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 "list" #: reference/expressions.rst:270 reference/expressions.rst:298 -#, fuzzy msgid "display" -msgstr "Agencements d'ensembles" +msgstr "display" #: reference/expressions.rst:821 msgid "[] (square brackets)" -msgstr "" +msgstr "[] (crochets)" #: reference/expressions.rst:244 -#, fuzzy msgid "list expression" -msgstr "Expression ``await``" +msgstr "list expression" #: reference/expressions.rst:270 reference/expressions.rst:1837 -#, fuzzy msgid "expression list" -msgstr "Listes d'expressions" +msgstr "expression list" #: reference/expressions.rst:270 msgid "set" -msgstr "" +msgstr "set" #: reference/expressions.rst:298 msgid "{} (curly brackets)" -msgstr "" +msgstr "{} (accolades)" #: reference/expressions.rst:270 -#, fuzzy msgid "set expression" -msgstr "Expression ``await``" +msgstr "set expression" #: reference/expressions.rst:324 reference/expressions.rst:825 -#, fuzzy msgid "dictionary" -msgstr "Agencements de dictionnaires" +msgstr "dictionary" #: reference/expressions.rst:298 msgid "key" -msgstr "" +msgstr "key" #: reference/expressions.rst:298 msgid "value" -msgstr "" +msgstr "value" #: reference/expressions.rst:298 msgid "key/value pair" -msgstr "" +msgstr "key/value pair" #: reference/expressions.rst:298 -#, fuzzy msgid "dictionary expression" -msgstr "Expressions conditionnelles" +msgstr "dictionary expression" #: 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 "in dictionary expressions" #: reference/expressions.rst:324 -#, fuzzy msgid "in dictionary displays" -msgstr "Agencements de dictionnaires" +msgstr "in dictionary displays" #: reference/expressions.rst:1025 reference/expressions.rst:1854 msgid "unpacking" -msgstr "" +msgstr "unpacking" #: reference/expressions.rst:1055 reference/expressions.rst:1162 msgid "**" -msgstr "" +msgstr "**" #: reference/expressions.rst:341 msgid "hashable" -msgstr "" +msgstr "hashable" #: reference/expressions.rst:417 reference/expressions.rst:525 -#, fuzzy msgid "generator" -msgstr "Opérateur" +msgstr "generator" #: reference/expressions.rst:362 -#, fuzzy msgid "generator expression" -msgstr "Expressions génératrices" +msgstr "generator expression" #: reference/expressions.rst:1142 -#, fuzzy msgid "keyword" -msgstr ":keyword:`or`" +msgstr "keyword" #: 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 "function" #: reference/expressions.rst:470 msgid "coroutine" -msgstr "" +msgstr "coroutine" #: reference/expressions.rst:484 -#, fuzzy msgid "yield from expression" -msgstr "Expressions ``yield``" +msgstr "yield from expression" #: 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 "examples" #: reference/expressions.rst:699 -#, fuzzy msgid "asynchronous-generator" -msgstr "Fonctions génératrices asynchrones" +msgstr "asynchronous-generator" #: reference/expressions.rst:709 msgid "StopAsyncIteration" -msgstr "" +msgstr "StopAsyncIteration" #: reference/expressions.rst:779 -#, fuzzy msgid "primary" -msgstr "Primaires" +msgstr "primary" #: reference/expressions.rst:793 msgid "attribute" -msgstr "" +msgstr "attribute" #: reference/expressions.rst:793 -#, fuzzy msgid "reference" -msgstr "Références à des attributs" +msgstr "reference" #: reference/expressions.rst:793 msgid ". (dot)" -msgstr "" +msgstr ". (point)" #: reference/expressions.rst:793 -#, fuzzy msgid "attribute reference" -msgstr "Références à des attributs" +msgstr "attribute reference" #: 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 @@ -3557,138 +3537,129 @@ msgstr "Indiçage (ou sélections)" #: reference/expressions.rst:898 reference/expressions.rst:1661 msgid "sequence" -msgstr "" +msgstr "séquence" #: reference/expressions.rst:825 msgid "mapping" -msgstr "" +msgstr "mapping" #: reference/expressions.rst:878 reference/expressions.rst:898 msgid "string" -msgstr "" +msgstr "string" #: reference/expressions.rst:878 msgid "item" -msgstr "" +msgstr "item" #: reference/expressions.rst:878 msgid "character" -msgstr "" +msgstr "character" #: reference/expressions.rst:892 -#, fuzzy msgid "slicing" -msgstr "Tranches" +msgstr "slicing" #: reference/expressions.rst:892 msgid "slice" -msgstr "" +msgstr "slice" #: reference/expressions.rst:924 msgid "start (slice object attribute)" -msgstr "" +msgstr "start (attribut d'objet slice)" #: reference/expressions.rst:924 msgid "stop (slice object attribute)" -msgstr "" +msgstr "stop (attribut d'objet slice)" #: reference/expressions.rst:924 msgid "step (slice object attribute)" -msgstr "" +msgstr "step (attribut d'objet slice)" #: reference/expressions.rst:942 msgid "callable" -msgstr "" +msgstr "callable" #: reference/expressions.rst:1090 reference/expressions.rst:1117 #: reference/expressions.rst:1134 msgid "call" -msgstr "" +msgstr "call" #: 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 "in function calls" #: 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 "user-defined" #: 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 objet)" #: reference/expressions.rst:1162 msgid "power" -msgstr "" +msgstr "power" #: reference/expressions.rst:1197 reference/expressions.rst:1354 #: reference/expressions.rst:1696 -#, fuzzy msgid "operation" -msgstr "Opérateur" +msgstr "operation" #: reference/expressions.rst:1206 reference/expressions.rst:1223 #: reference/expressions.rst:1271 reference/expressions.rst:1296 @@ -3696,327 +3667,307 @@ 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" #: 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 "inclusive" #: 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 "language" #: 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 "chaining" #: reference/expressions.rst:1446 -#, fuzzy msgid "comparisons" 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 "membership" #: 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 "identity" #: reference/expressions.rst:1696 -#, fuzzy msgid "Conditional" -msgstr "Expressions conditionnelles" +msgstr "Conditional" #: reference/expressions.rst:1696 -#, fuzzy msgid "Boolean" -msgstr "OR (booléen)" +msgstr "Boolean" #: reference/expressions.rst:1712 msgid "not" -msgstr "" +msgstr "not" #: reference/expressions.rst:1736 msgid ":= (colon equals)" -msgstr "" +msgstr ":= (deux points égale)" #: reference/expressions.rst:1736 -#, fuzzy msgid "assignment expression" -msgstr "Expression d'affectation" +msgstr "assignment expression" #: reference/expressions.rst:1736 -#, fuzzy msgid "walrus operator" -msgstr "L'opérateur puissance" +msgstr "walrus operator" #: reference/expressions.rst:1736 -#, fuzzy msgid "named expression" -msgstr "Expression lambda" +msgstr "named expression" #: reference/expressions.rst:1783 -#, fuzzy msgid "conditional" -msgstr "Expressions conditionnelles" +msgstr "condtional" #: reference/expressions.rst:1783 msgid "ternary" -msgstr "" +msgstr "ternary" #: 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 "form" #: reference/expressions.rst:1809 msgid "anonymous" -msgstr "" +msgstr "anonymous" #: reference/expressions.rst:1809 -#, fuzzy msgid "lambda expression" -msgstr "Expression lambda" +msgstr "lambda expression" #: reference/expressions.rst:1854 -#, fuzzy msgid "iterable" -msgstr "Littéraux" +msgstr "iterable" #: reference/expressions.rst:1854 -#, fuzzy msgid "in expression lists" -msgstr "Listes d'expressions" +msgstr "in expression lists" #: reference/expressions.rst:1866 msgid "trailing" -msgstr "" +msgstr "trailing" #: reference/expressions.rst:1880 -#, fuzzy msgid "evaluation" -msgstr "Ordre d'évaluation" +msgstr "evaluation" #: reference/expressions.rst:1880 msgid "order" -msgstr "" +msgstr "order" #: reference/expressions.rst:1901 -#, fuzzy msgid "precedence" msgstr "Priorités des opérateurs" diff --git a/reference/import.po b/reference/import.po index 096077ba..aa820134 100644 --- a/reference/import.po +++ b/reference/import.po @@ -6,7 +6,7 @@ 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-10-07 15:57+0200\n" +"PO-Revision-Date: 2023-07-08 11:34+0200\n" "Last-Translator: Christophe Nanteuil \n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -1042,6 +1042,7 @@ msgstr "" "par l'intermédiaire du chargeur." #: reference/import.rst:557 +#, fuzzy msgid "" "The module's ``__package__`` attribute must be set. Its value must be a " "string, but it can be the same value as its ``__name__``. When the module " @@ -1059,6 +1060,7 @@ msgstr "" "modules. Voir la :pep:`366` pour plus de détails." #: reference/import.rst:565 +#, fuzzy msgid "" "This attribute is used instead of ``__name__`` to calculate explicit " "relative imports for main modules, as defined in :pep:`366`. It is expected " @@ -1093,6 +1095,7 @@ msgstr "" "certains cas `." #: reference/import.rst:581 +#, fuzzy msgid "" "When ``__package__`` is not defined, ``__spec__.parent`` is used as a " "fallback." @@ -2107,6 +2110,7 @@ msgstr "" "garanti pour les autres implémentations de Python." #: reference/import.rst:1063 +#, fuzzy msgid "" "In legacy code, it is possible to find instances of :class:`imp." "NullImporter` in the :data:`sys.path_importer_cache`. It is recommended " @@ -2120,95 +2124,104 @@ msgstr "" #: reference/import.rst:8 msgid "import machinery" -msgstr "mécanisme d'importation" +msgstr "" #: reference/import.rst:95 reference/import.rst:129 +#, fuzzy msgid "package" -msgstr "paquet" +msgstr "Les paquets" #: reference/import.rst:95 msgid "regular" -msgstr "régulier" +msgstr "" #: reference/import.rst:129 msgid "namespace" -msgstr "espace de noms" +msgstr "" #: reference/import.rst:129 msgid "portion" -msgstr "portion" +msgstr "" #: reference/import.rst:175 +#, fuzzy msgid "sys.modules" -msgstr "sys.modules" +msgstr "Sous-modules" #: reference/import.rst:276 msgid "finder" -msgstr "chercheur" +msgstr "" #: reference/import.rst:210 +#, fuzzy msgid "loader" -msgstr "chargeur" +msgstr "Chargeurs" #: reference/import.rst:210 +#, fuzzy msgid "module spec" -msgstr "spécifications de module" +msgstr "Spécificateurs de modules" #: reference/import.rst:249 +#, fuzzy msgid "import hooks" msgstr "Points d'entrées automatiques pour l'importation" #: reference/import.rst:249 +#, fuzzy msgid "meta hooks" -msgstr "méta-points d'entrées automatiques" +msgstr "Points d'entrées automatiques pour l'importation" #: reference/import.rst:249 +#, fuzzy msgid "path hooks" -msgstr "point d'entrée automatique sur les chemins" +msgstr "Points d'entrées automatiques pour l'importation" #: reference/import.rst:249 msgid "hooks" -msgstr "point d'entrée automatique" +msgstr "" #: reference/import.rst:249 msgid "import" -msgstr "importation" +msgstr "" #: reference/import.rst:249 msgid "meta" -msgstr "méta" +msgstr "" #: reference/import.rst:249 msgid "path" -msgstr "chemin" +msgstr "" #: reference/import.rst:276 +#, fuzzy msgid "sys.meta_path" -msgstr "sys.meta_path" +msgstr "Méta-chemins" #: reference/import.rst:276 msgid "find_spec" -msgstr "find_spec" +msgstr "" #: reference/import.rst:727 +#, fuzzy msgid "path based finder" -msgstr "Le chercheur d'entrées dans *path*" +msgstr "Le chercheur dans *path*" #: reference/import.rst:776 msgid "sys.path" -msgstr "sys.path" +msgstr "" #: reference/import.rst:776 msgid "sys.path_hooks" -msgstr "sys.path_hooks" +msgstr "" #: reference/import.rst:776 msgid "sys.path_importer_cache" -msgstr "sys.path_importer_cache" +msgstr "" #: reference/import.rst:776 msgid "PYTHONPATH" -msgstr "PYTHONPATH" +msgstr "" #~ msgid "Open issues" #~ msgstr "Idées d'amélioration" diff --git a/reference/introduction.po b/reference/introduction.po index ce45b15a..ee5f320c 100644 --- a/reference/introduction.po +++ b/reference/introduction.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-10-01 14:35+0200\n" -"Last-Translator: Christophe Nanteuil \n" +"PO-Revision-Date: 2018-10-07 19:09+0200\n" +"Last-Translator: \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.2\n" +"X-Generator: Poedit 2.1.1\n" #: reference/introduction.rst:6 msgid "Introduction" @@ -124,6 +124,7 @@ msgid "Jython" msgstr "Jython" #: reference/introduction.rst:54 +#, fuzzy msgid "" "Python implemented in Java. This implementation can be used as a scripting " "language for Java applications, or can be used to create applications using " @@ -135,7 +136,7 @@ msgstr "" "langage de script pour les applications Java ou pour créer des applications " "utilisant des bibliothèques Java. Elle est également souvent utilisée pour " "créer des tests de bibliothèques Java. Plus d’informations peuvent être " -"trouvées sur `the Jython website `_ (site en " +"trouvées sur `the Jython website `_ (site en " "anglais)." #: reference/introduction.rst:63 @@ -159,6 +160,7 @@ msgid "IronPython" msgstr "IronPython" #: reference/introduction.rst:66 +#, fuzzy msgid "" "An alternate Python for .NET. Unlike Python.NET, this is a complete Python " "implementation that generates IL, and compiles Python code directly to .NET " @@ -170,13 +172,14 @@ msgstr "" "implémentation Python complète qui génère du code intermédiaire (IL) .NET et " "compile le code Python directement en assemblages .NET. Il a été créé par " "Jim Hugunin, le programmeur à l’origine de Jython. Pour plus d’informations, " -"voir `the IronPython website `_ (site en anglais)." +"voir `the IronPython website `_ (site en anglais)." #: reference/introduction.rst:77 msgid "PyPy" msgstr "PyPy" #: reference/introduction.rst:72 +#, fuzzy msgid "" "An implementation of Python written completely in Python. It supports " "several advanced features not found in other implementations like stackless " @@ -193,7 +196,7 @@ msgstr "" "est d'encourager l'expérimentation du langage lui-même en facilitant la " "modification de l'interpréteur (puisqu'il est écrit en Python). Des " "informations complémentaires sont disponibles sur la `page d'accueil du " -"projet PyPy `_ (site en anglais)." +"projet PyPy `_ (site en anglais)." #: reference/introduction.rst:79 msgid "" @@ -301,24 +304,25 @@ msgstr "" #: reference/introduction.rst:91 msgid "BNF" -msgstr "BNF" +msgstr "" #: reference/introduction.rst:91 msgid "grammar" -msgstr "grammaire" +msgstr "" #: reference/introduction.rst:91 msgid "syntax" -msgstr "syntaxe" +msgstr "" #: reference/introduction.rst:91 +#, fuzzy msgid "notation" msgstr "Notations" #: reference/introduction.rst:117 msgid "lexical definitions" -msgstr "définitions lexicales" +msgstr "" #: reference/introduction.rst:117 msgid "ASCII" -msgstr "ASCII" +msgstr "" diff --git a/reference/lexical_analysis.po b/reference/lexical_analysis.po index d0c818ff..45e2bda6 100644 --- a/reference/lexical_analysis.po +++ b/reference/lexical_analysis.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-10-01 15:18+0200\n" -"Last-Translator: Christophe Nanteuil \n" +"PO-Revision-Date: 2022-11-21 22:32+0100\n" +"Last-Translator: Samuel Giffard \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.2\n" +"X-Generator: Poedit 2.4.2\n" #: reference/lexical_analysis.rst:6 msgid "Lexical analysis" @@ -141,11 +141,11 @@ msgstr "" "de cette expression désigne l'encodage du fichier source. Cette déclaration " "d'encodage doit être seule sur sa ligne et, si elle est sur la deuxième " "ligne, la première ligne doit aussi être une ligne composée uniquement d'un " -"commentaire. Les formes recommandées pour l'expression de l'encodage sont ::" +"commentaire. Les formes recommandées pour l'expression de l'encodage sont ::" #: reference/lexical_analysis.rst:93 msgid "which is recognized also by GNU Emacs, and ::" -msgstr "qui est reconnue aussi par GNU *Emacs* et ::" +msgstr "qui est reconnue aussi par GNU Emacs et ::" #: reference/lexical_analysis.rst:97 msgid "which is recognized by Bram Moolenaar's VIM." @@ -428,7 +428,7 @@ msgstr "" #: reference/lexical_analysis.rst:276 msgid "Identifiers and keywords" -msgstr "Identifiants et mots clés" +msgstr "Identifiants et mots-clés" #: reference/lexical_analysis.rst:280 msgid "" @@ -457,7 +457,7 @@ msgid "" msgstr "" "Dans l'intervalle ASCII (*U+0001..U+007F*), les caractères licites pour les " "identifiants sont les mêmes que pour Python 2.x : les lettres minuscules et " -"majuscules de ``A`` à ``Z``, le tiret bas (ou *underscore*) ``_`` et, sauf " +"majuscules de ``A`` à ``Z``, le souligné (ou *underscore*) ``_`` et, sauf " "pour le premier caractère, les chiffres de ``0`` à ``9``." #: reference/lexical_analysis.rst:292 @@ -528,6 +528,7 @@ msgid "*Pc* - connector punctuations" msgstr "*Pc* — connecteurs (tirets et autres lignes)" #: reference/lexical_analysis.rst:317 +#, fuzzy msgid "" "*Other_ID_Start* - explicit list of characters in `PropList.txt `_ to support backwards " @@ -550,6 +551,7 @@ msgstr "" "forme NFKC." #: reference/lexical_analysis.rst:325 +#, fuzzy msgid "" "A non-normative HTML file listing all valid identifier characters for " "Unicode 14.0.0 can be found at https://www.unicode.org/Public/14.0.0/ucd/" @@ -557,7 +559,7 @@ msgid "" msgstr "" "Un fichier HTML, ne faisant pas référence, listant tous les caractères " "valides pour Unicode 14.0.0 se trouve à https://www.unicode.org/" -"Public/14.0.0/ucd/DerivedCoreProperties.txt" +"Public/14.0.0/ucd/DerivedCoreProperties.txt." #: reference/lexical_analysis.rst:333 msgid "Keywords" @@ -613,8 +615,8 @@ msgid "" "underscore characters:" msgstr "" "Certaines classes d'identifiants (outre les mots-clés) ont une signification " -"particulière. Ces classes se reconnaissent par des tirets bas (aussi appelés " -"caractères de soulignement) en tête et en queue d'identifiant :" +"particulière. Ces classes se reconnaissent par des caractères de " +"soulignement en tête et en queue d'identifiant :" #: reference/lexical_analysis.rst:387 msgid "``_*``" @@ -645,7 +647,7 @@ msgid "" "`builtins` module, alongside built-in functions like ``print``.)" msgstr "" "De son côté, l'interpréteur interactif place le résultat de la dernière " -"évaluation dans la variable ``_`` (son emplacement se situe dans le module :" +"évaluation dans la variable ``-`` (son emplacement se situe dans le module :" "mod:`builtins`, avec les fonctions natives telles que ``print``)." #: reference/lexical_analysis.rst:399 @@ -657,14 +659,13 @@ msgstr "" "pour désigner des éléments « spéciaux », mais il n'est pas spécial pour " "Python en tant que tel." -# suit un : #: reference/lexical_analysis.rst:404 msgid "" "The name ``_`` is often used in conjunction with internationalization; refer " "to the documentation for the :mod:`gettext` module for more information on " "this convention." msgstr "" -"le nom ``_`` est souvent utilisé pour internationaliser l'affichage ; " +"Le nom ``_`` est souvent utilisé pour internationaliser l'affichage ; " "reportez-vous à la documentation du module :mod:`gettext` pour plus " "d'informations sur cette convention." @@ -751,6 +752,7 @@ msgstr "" "section :ref:`encodings`." #: reference/lexical_analysis.rst:480 +#, fuzzy msgid "" "In plain English: Both types of literals can be enclosed in matching single " "quotes (``'``) or double quotes (``\"``). They can also be enclosed in " @@ -824,10 +826,10 @@ msgid "" "are possible, but formatted bytes literals are not." msgstr "" "Une chaîne littérale qui contient ``'f'`` ou ``'F'`` dans le préfixe est " -"une :dfn:`chaîne de caractères littérale formatée` ; reportez-vous à :ref:`f-" -"strings`. Le ``'f'`` peut être combiné avec ``'r'`` mais pas avec ``'b'`` ou " -"``'u'``, donc les chaînes de caractères formatées sont possibles mais les " -"littéraux de suites d'octets ne peuvent pas l'être." +"une :dfn:`chaîne de caractères littérale formatée` ; lisez :ref:`f-strings`. " +"Le ``'f'`` peut être combiné avec ``'r'`` mais pas avec ``'b'`` ou ``'u'``, " +"donc les chaînes de caractères formatées sont possibles mais les littéraux " +"de suites d'octets ne peuvent pas l'être." #: reference/lexical_analysis.rst:525 msgid "" @@ -866,8 +868,9 @@ msgid "Notes" msgstr "Notes" #: reference/lexical_analysis.rst:551 +#, fuzzy msgid "``\\``\\ " -msgstr "``\\``\\ " +msgstr "``\\newline``" #: reference/lexical_analysis.rst:551 msgid "Backslash and newline ignored" @@ -875,7 +878,7 @@ msgstr "barre oblique inversée et retour à la ligne ignorés" #: reference/lexical_analysis.rst:551 msgid "\\(1)" -msgstr "\\(1)" +msgstr "" #: reference/lexical_analysis.rst:553 msgid "``\\\\``" @@ -967,7 +970,7 @@ msgstr "caractère dont le code est *ooo* en octal" #: reference/lexical_analysis.rst:573 msgid "(2,4)" -msgstr "(2,4)" +msgstr "" #: reference/lexical_analysis.rst:576 msgid "``\\xhh``" @@ -979,7 +982,7 @@ msgstr "caractère dont le code est *ooo* en hexadécimal" #: reference/lexical_analysis.rst:576 msgid "(3,4)" -msgstr "(3,4)" +msgstr "" #: reference/lexical_analysis.rst:579 msgid "Escape sequences only recognized in string literals are:" @@ -1021,7 +1024,7 @@ msgstr "caractère dont le code est *xxxxxxxx* en hexadécimal sur 32 bits" #: reference/lexical_analysis.rst:590 msgid "\\(7)" -msgstr "\\(7)" +msgstr "" #: reference/lexical_analysis.rst:594 msgid "Notes:" @@ -1030,8 +1033,6 @@ msgstr "Notes :" #: reference/lexical_analysis.rst:597 msgid "A backslash can be added at the end of a line to ignore the newline::" msgstr "" -"Une barre oblique inverse peut être ajoutée à la fin d'une ligne pour " -"ignorer le caractère de nouvelle ligne ::" #: reference/lexical_analysis.rst:603 msgid "" @@ -1039,23 +1040,20 @@ msgid "" "`, or parentheses and :ref:`string literal concatenation `." msgstr "" -"Le même résultat peut être obtenu en utilisant :ref:`chaînes entre triples " -"guillemets `, ou des parenthèses et la :ref:`concaténation " -"littérale de chaînes `." #: reference/lexical_analysis.rst:608 msgid "As in Standard C, up to three octal digits are accepted." msgstr "" "Comme dans le C Standard, jusqu'à trois chiffres en base huit sont acceptés." -# suit un : #: reference/lexical_analysis.rst:610 +#, fuzzy msgid "" "Octal escapes with value larger than ``0o377`` produce a :exc:" "`DeprecationWarning`. In a future Python version they will be a :exc:" "`SyntaxWarning` and eventually a :exc:`SyntaxError`." msgstr "" -"les séquences d'échappement pour les valeurs octales plus grandes que " +"Les séquences d'échappement pour les valeurs octales plus grandes que " "``0o377`` produisent une :exc:`DeprecationWarning`. Dans les versions " "suivantes de Python, elles génèreront une :exc:`SyntaxWarning` et " "éventuellement une :exc:`SyntaxError`." @@ -1076,10 +1074,9 @@ msgstr "" "un octet dont la valeur est donnée. Dans une chaîne littérale, un " "échappement est un caractère Unicode dont le code est donné." -# suit un : #: reference/lexical_analysis.rst:624 msgid "Support for name aliases [#]_ has been added." -msgstr "ajout de la prise en charge des alias de noms [#]_." +msgstr "Ajout du support pour les alias de noms [#]_." #: reference/lexical_analysis.rst:628 msgid "Exactly four hex digits are required." @@ -1111,14 +1108,14 @@ msgstr "" "dans les littéraux de chaînes de caractères ne sont pas reconnues pour les " "littéraux de suites d'octets." -# suit un : #: reference/lexical_analysis.rst:644 +#, fuzzy msgid "" "Unrecognized escape sequences produce a :exc:`DeprecationWarning`. In a " "future Python version they will be a :exc:`SyntaxWarning` and eventually a :" "exc:`SyntaxError`." msgstr "" -"les séquences d'échappement non reconnues produisent une :exc:" +"Les séquences d'échappement non reconnues produisent une :exc:" "`DeprecationWarning`. Dans les versions suivantes de Python, elles génèrent " "une :exc:`SyntaxWarning` et éventuellement une :exc:`SyntaxError`." @@ -1260,14 +1257,13 @@ msgstr "" "commentaire. Chaque expression est évaluée dans le contexte où la chaîne de " "caractères formatée apparaît, de gauche à droite." -# suit un : #: reference/lexical_analysis.rst:739 msgid "" "Prior to Python 3.7, an :keyword:`await` expression and comprehensions " "containing an :keyword:`async for` clause were illegal in the expressions in " "formatted string literals due to a problem with the implementation." msgstr "" -"avant Python 3.7, il était illégal d’utiliser :keyword:`await` ainsi que les " +"Avant Python 3.7, il était illégal d’utiliser :keyword:`await` ainsi que les " "compréhensions utilisant :keyword:`async for` dans les expressions au sein " "des chaînes de caractères formatées littérales à cause d’un problème dans " "l’implémentation." @@ -1320,6 +1316,7 @@ msgstr "" "inclus dans la valeur finale de la chaîne complète." #: reference/lexical_analysis.rst:765 +#, fuzzy msgid "" "Top-level format specifiers may include nested replacement fields. These " "nested fields may include their own conversion fields and :ref:`format " @@ -1439,7 +1436,7 @@ msgid "" msgstr "" "Les tirets bas sont ignorés pour déterminer la valeur numérique du littéral. " "Ils peuvent être utilisés pour grouper les chiffres afin de faciliter la " -"lecture. Un tiret bas peut être placé entre des chiffres ou après la " +"lecture. Un souligné peut être placé entre des chiffres ou après la " "spécification de la base telle que ``0x``." #: reference/lexical_analysis.rst:890 @@ -1457,10 +1454,9 @@ msgstr "" msgid "Some examples of integer literals::" msgstr "Quelques exemples d'entiers littéraux ::" -# suit un : #: reference/lexical_analysis.rst:900 reference/lexical_analysis.rst:932 msgid "Underscores are now allowed for grouping purposes in literals." -msgstr "les tirets bas ne sont pas autorisés pour grouper les littéraux." +msgstr "Les tirets bas ne sont pas autorisés pour grouper les littéraux." #: reference/lexical_analysis.rst:911 msgid "Floating point literals" @@ -1485,7 +1481,7 @@ msgstr "" "étant en base 10. Par exemple, ``077e010`` est licite et désigne le même " "nombre que ``77e10``. La plage autorisée pour les littéraux de nombres à " "virgule flottante dépend de l'implémentation. Comme pour les entiers " -"littéraux, les tirets bas permettent de grouper des chiffres." +"littéraux, les soulignés permettent de grouper des chiffres." #: reference/lexical_analysis.rst:928 msgid "Some examples of floating point literals::" @@ -1568,420 +1564,459 @@ msgid "Footnotes" msgstr "Notes" #: reference/lexical_analysis.rst:1012 +#, fuzzy msgid "https://www.unicode.org/Public/11.0.0/ucd/NameAliases.txt" msgstr "https://www.unicode.org/Public/11.0.0/ucd/NameAliases.txt" #: reference/lexical_analysis.rst:8 +#, fuzzy msgid "lexical analysis" msgstr "Analyse lexicale" #: reference/lexical_analysis.rst:8 msgid "parser" -msgstr "analyseur" +msgstr "" #: reference/lexical_analysis.rst:8 msgid "token" -msgstr "lexème" +msgstr "" #: reference/lexical_analysis.rst:25 +#, fuzzy msgid "line structure" msgstr "Structure des lignes" #: reference/lexical_analysis.rst:35 +#, fuzzy msgid "logical line" msgstr "Lignes logiques" #: reference/lexical_analysis.rst:35 reference/lexical_analysis.rst:115 #: reference/lexical_analysis.rst:529 +#, fuzzy msgid "physical line" msgstr "Lignes physiques" #: reference/lexical_analysis.rst:35 reference/lexical_analysis.rst:115 +#, fuzzy msgid "line joining" msgstr "Continuation de ligne explicite" #: reference/lexical_analysis.rst:35 msgid "NEWLINE token" -msgstr "lexème NEWLINE" +msgstr "" #: reference/lexical_analysis.rst:67 +#, fuzzy msgid "comment" msgstr "Commentaires" #: reference/lexical_analysis.rst:67 msgid "hash character" -msgstr "caractère croisillon" +msgstr "" #: reference/lexical_analysis.rst:67 reference/lexical_analysis.rst:81 msgid "# (hash)" -msgstr "# (hachage)" +msgstr "" #: reference/lexical_analysis.rst:81 msgid "source character set" -msgstr "jeu de caractères source" +msgstr "" #: reference/lexical_analysis.rst:81 +#, fuzzy msgid "encoding declarations (source file)" msgstr "Déclaration d'encodage" #: reference/lexical_analysis.rst:81 +#, fuzzy msgid "source encoding declaration" msgstr "Déclaration d'encodage" #: reference/lexical_analysis.rst:115 +#, fuzzy msgid "line continuation" msgstr "Indentation" #: reference/lexical_analysis.rst:115 msgid "backslash character" -msgstr "caractère barre oblique inverse" +msgstr "" #: reference/lexical_analysis.rst:160 +#, fuzzy msgid "blank line" msgstr "Lignes vierges" #: reference/lexical_analysis.rst:175 +#, fuzzy msgid "indentation" msgstr "Indentation" #: reference/lexical_analysis.rst:175 msgid "leading whitespace" -msgstr "espace de début" +msgstr "" #: reference/lexical_analysis.rst:175 msgid "space" -msgstr "espace" +msgstr "" #: reference/lexical_analysis.rst:175 msgid "tab" -msgstr "tabulation" +msgstr "" #: reference/lexical_analysis.rst:175 msgid "grouping" -msgstr "regroupement" +msgstr "" #: reference/lexical_analysis.rst:175 msgid "statement grouping" -msgstr "regroupement d'instructions" +msgstr "" #: reference/lexical_analysis.rst:203 msgid "INDENT token" -msgstr "lexème INDENT" +msgstr "" #: reference/lexical_analysis.rst:203 msgid "DEDENT token" -msgstr "lexème DEDENT" +msgstr "" #: reference/lexical_analysis.rst:278 msgid "identifier" -msgstr "identifiant" +msgstr "" #: reference/lexical_analysis.rst:278 msgid "name" -msgstr "nom" +msgstr "" #: reference/lexical_analysis.rst:335 reference/lexical_analysis.rst:359 +#, fuzzy msgid "keyword" -msgstr "Mot clé" +msgstr "Mots-clés" #: reference/lexical_analysis.rst:335 msgid "reserved word" -msgstr "mot réservé" +msgstr "" #: reference/lexical_analysis.rst:359 +#, fuzzy msgid "soft keyword" msgstr "Mots-clés ad hoc" #: reference/lexical_analysis.rst:374 msgid "_, identifiers" -msgstr "_, identifiants" +msgstr "" #: reference/lexical_analysis.rst:374 msgid "__, identifiers" -msgstr "__, identifiants" +msgstr "" #: reference/lexical_analysis.rst:430 +#, fuzzy msgid "literal" msgstr "Littéraux" #: reference/lexical_analysis.rst:430 msgid "constant" -msgstr "constante" +msgstr "" #: reference/lexical_analysis.rst:435 reference/lexical_analysis.rst:476 +#, fuzzy msgid "string literal" msgstr "Chaînes de caractères littérales formatées" #: reference/lexical_analysis.rst:435 reference/lexical_analysis.rst:487 +#, fuzzy msgid "bytes literal" msgstr "Entiers littéraux" #: reference/lexical_analysis.rst:435 msgid "ASCII" -msgstr "ASCII" +msgstr "" #: reference/lexical_analysis.rst:435 +#, fuzzy msgid "' (single quote)" msgstr "guillemet simple (``'``)" #: reference/lexical_analysis.rst:435 +#, fuzzy msgid "\" (double quote)" msgstr "guillemet double (``\"``)" #: reference/lexical_analysis.rst:435 msgid "u'" -msgstr "u'" +msgstr "" #: reference/lexical_analysis.rst:435 msgid "u\"" -msgstr "u\"" +msgstr "" #: reference/lexical_analysis.rst:476 msgid "triple-quoted string" -msgstr "chaîne entre guillemets triples" +msgstr "" #: reference/lexical_analysis.rst:476 msgid "Unicode Consortium" -msgstr "Consortium Unicode" +msgstr "" #: reference/lexical_analysis.rst:476 msgid "raw string" -msgstr "chaîne brute" +msgstr "" #: reference/lexical_analysis.rst:476 msgid "\"\"\"" -msgstr "\"\"\"" +msgstr "" #: reference/lexical_analysis.rst:476 msgid "'''" -msgstr "'''" +msgstr "" #: reference/lexical_analysis.rst:487 msgid "b'" -msgstr "b'" +msgstr "" #: reference/lexical_analysis.rst:487 msgid "b\"" -msgstr "b\"" +msgstr "" #: reference/lexical_analysis.rst:496 msgid "r'" -msgstr "r'" +msgstr "" #: reference/lexical_analysis.rst:496 +#, fuzzy msgid "raw string literal" msgstr "Chaînes de caractères littérales formatées" #: reference/lexical_analysis.rst:496 msgid "r\"" -msgstr "r\"" +msgstr "" #: reference/lexical_analysis.rst:516 msgid "f'" -msgstr "f'" +msgstr "" #: reference/lexical_analysis.rst:516 reference/lexical_analysis.rst:682 +#, fuzzy msgid "formatted string literal" msgstr "Chaînes de caractères littérales formatées" #: reference/lexical_analysis.rst:516 msgid "f\"" -msgstr "f\"" +msgstr "" #: reference/lexical_analysis.rst:529 +#, fuzzy msgid "escape sequence" msgstr "Séquence d'échappement" #: reference/lexical_analysis.rst:529 msgid "Standard C" -msgstr "Norme C" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "C" -msgstr "C" +msgstr "" #: reference/lexical_analysis.rst:529 +#, fuzzy msgid "\\ (backslash)" msgstr "barre oblique inversée (``\\``)" #: reference/lexical_analysis.rst:529 msgid "\\\\" -msgstr "\\\\" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\a" -msgstr "\\a" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\b" -msgstr "\\b" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\f" -msgstr "\\f" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\n" -msgstr "\\n" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\r" -msgstr "\\r" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\t" -msgstr "\\t" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\v" -msgstr "\\v" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\x" -msgstr "\\x" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\N" -msgstr "\\N" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\u" -msgstr "\\u" +msgstr "" #: reference/lexical_analysis.rst:529 msgid "\\U" -msgstr "\\U" +msgstr "" #: reference/lexical_analysis.rst:635 +#, fuzzy msgid "unrecognized escape sequence" msgstr "Séquence d'échappement" #: reference/lexical_analysis.rst:682 +#, fuzzy msgid "interpolated string literal" msgstr "Chaînes de caractères littérales formatées" #: reference/lexical_analysis.rst:682 msgid "string" -msgstr "chaîne" +msgstr "" #: reference/lexical_analysis.rst:682 +#, fuzzy msgid "formatted literal" msgstr "Chaînes de caractères littérales formatées" #: reference/lexical_analysis.rst:682 +#, fuzzy msgid "interpolated literal" msgstr "Entiers littéraux" #: reference/lexical_analysis.rst:682 msgid "f-string" -msgstr "f-string" +msgstr "" #: reference/lexical_analysis.rst:682 msgid "fstring" -msgstr "chaîne de caractères formatée" +msgstr "" #: reference/lexical_analysis.rst:682 msgid "{} (curly brackets)" -msgstr "{} (accolades)" +msgstr "" #: reference/lexical_analysis.rst:682 +#, fuzzy msgid "in formatted string literal" msgstr "Chaînes de caractères littérales formatées" #: reference/lexical_analysis.rst:682 msgid "! (exclamation)" -msgstr "! (point d'exclamation)" +msgstr "" #: reference/lexical_analysis.rst:682 msgid ": (colon)" -msgstr ": (deux-points)" +msgstr "" #: reference/lexical_analysis.rst:682 msgid "= (equals)" -msgstr "= (signe égal)" +msgstr "" #: reference/lexical_analysis.rst:682 msgid "for help in debugging using string literals" -msgstr "pour obtenir de l'aide sur le débogage à l'aide de chaînes littérales" +msgstr "" #: reference/lexical_analysis.rst:845 msgid "number" -msgstr "nombre" +msgstr "" #: reference/lexical_analysis.rst:845 +#, fuzzy msgid "numeric literal" msgstr "Littéraux numériques" #: reference/lexical_analysis.rst:845 reference/lexical_analysis.rst:858 +#, fuzzy msgid "integer literal" msgstr "Entiers littéraux" #: reference/lexical_analysis.rst:845 +#, fuzzy msgid "floating point literal" msgstr "Nombres à virgule flottante littéraux" #: reference/lexical_analysis.rst:845 msgid "hexadecimal literal" -msgstr "littéraux hexadécimaux" +msgstr "" #: reference/lexical_analysis.rst:845 +#, fuzzy msgid "octal literal" msgstr "Littéraux numériques" #: reference/lexical_analysis.rst:845 +#, fuzzy msgid "binary literal" msgstr "Imaginaires littéraux" #: reference/lexical_analysis.rst:845 +#, fuzzy msgid "decimal literal" msgstr "Littéraux numériques" #: reference/lexical_analysis.rst:845 +#, fuzzy msgid "imaginary literal" msgstr "Imaginaires littéraux" #: reference/lexical_analysis.rst:845 +#, fuzzy msgid "complex literal" msgstr "Littéraux numériques" #: reference/lexical_analysis.rst:858 msgid "0b" -msgstr "0b" +msgstr "" #: reference/lexical_analysis.rst:858 msgid "0o" -msgstr "0o" +msgstr "" #: reference/lexical_analysis.rst:858 msgid "0x" -msgstr "0x" +msgstr "" #: reference/lexical_analysis.rst:858 reference/lexical_analysis.rst:904 msgid "_ (underscore)" -msgstr "_ (caractère de soulignement ou tiret bas)" +msgstr "" #: reference/lexical_analysis.rst:858 reference/lexical_analysis.rst:904 #: reference/lexical_analysis.rst:936 +#, fuzzy msgid "in numeric literal" msgstr "Littéraux numériques" #: reference/lexical_analysis.rst:904 msgid ". (dot)" -msgstr ". (point)" +msgstr "" #: reference/lexical_analysis.rst:904 msgid "e" -msgstr "e" +msgstr "" #: reference/lexical_analysis.rst:936 msgid "j" -msgstr "j" +msgstr "" #: reference/lexical_analysis.rst:962 +#, fuzzy msgid "operators" msgstr "Opérateurs" #: reference/lexical_analysis.rst:979 +#, fuzzy msgid "delimiters" msgstr "Délimiteurs" diff --git a/reference/simple_stmts.po b/reference/simple_stmts.po index 539822dd..bac988e0 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-10-07 17:15+0200\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 "string" #: reference/simple_stmts.rst:55 msgid "conversion" -msgstr "" +msgstr "conversion" #: reference/simple_stmts.rst:55 msgid "output" -msgstr "" +msgstr "output" #: reference/simple_stmts.rst:55 msgid "standard" -msgstr "" +msgstr "standard" #: reference/simple_stmts.rst:55 msgid "writing" -msgstr "" +msgstr "writing" #: 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 "rebinding" #: 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 "target" #: 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 "in target list" #: 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 "in assignment target list" #: 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 "subscription" #: reference/simple_stmts.rst:195 msgid "sequence" -msgstr "" +msgstr "séquence" #: reference/simple_stmts.rst:206 msgid "mapping" -msgstr "" +msgstr "mapping" #: reference/simple_stmts.rst:206 msgid "dictionary" -msgstr "" +msgstr "dictionnaire" #: reference/simple_stmts.rst:219 msgid "slicing" -msgstr "" +msgstr "slicing" #: reference/simple_stmts.rst:262 msgid "augmented" -msgstr "" +msgstr "augmenté" #: reference/simple_stmts.rst:262 -#, fuzzy msgid "assignment, augmented" -msgstr "Les assignations" +msgstr "assignment, augmented" #: 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é" #: 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 "expression list" #: 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 "unbinding" #: 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 "raising" #: reference/simple_stmts.rst:555 msgid "__traceback__ (exception attribute)" -msgstr "" +msgstr "__traceback__ (attribut d'exception)" #: reference/simple_stmts.rst:577 msgid "traceback" -msgstr "" +msgstr "traceback" #: reference/simple_stmts.rst:587 msgid "chaining" -msgstr "" +msgstr "chaining" #: 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 "loop" #: reference/simple_stmts.rst:682 msgid "else" -msgstr "" +msgstr "else" #: reference/simple_stmts.rst:682 msgid "loop control" -msgstr "" +msgstr "loop control" #: reference/simple_stmts.rst:703 msgid "continue" -msgstr "" +msgstr "continue" #: reference/simple_stmts.rst:831 msgid "import" -msgstr "" +msgstr "import" #: 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 "L'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 "compile" #: reference/simple_stmts.rst:991 msgid "nonlocal" -msgstr "" +msgstr "nonlocal" diff --git a/reference/toplevel_components.po b/reference/toplevel_components.po index 0130b3d2..048ea5be 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-10-07 19:46+0200\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 "input" #: reference/toplevel_components.rst:101 msgid "built-in function" -msgstr "" +msgstr "fonction native" #: reference/toplevel_components.rst:101 msgid "eval" -msgstr "" +msgstr "eval"