diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 78ae0ad5..c95fed6d 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -534,6 +534,7 @@ statement instruction subprocess sous-processus support prendre en charge, implémenter (« supporter » n'a pas le même sens en français) +token (parsing) lexème thread fil d'exécution traceback trace d'appels, trace de pile tuple *n*-uplet (avec *n* en italique), on peut diff --git a/library/ast.po b/library/ast.po index 4e95dcd5..0012a69e 100644 --- a/library/ast.po +++ b/library/ast.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-05-29 16:33+0200\n" -"PO-Revision-Date: 2018-09-11 07:42+0200\n" -"Last-Translator: Julien VITARD \n" +"PO-Revision-Date: 2021-09-15 23:54+0200\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 1.8.11\n" +"X-Generator: Poedit 2.4.1\n" #: library/ast.rst:2 msgid ":mod:`ast` --- Abstract Syntax Trees" @@ -30,10 +30,11 @@ msgid "" "with each Python release; this module helps to find out programmatically " "what the current grammar looks like." msgstr "" -"Le module :mod:`ast` permet aux applications Python de traiter la grammaire " -"abstraite de l'arbre syntaxique Python. La grammaire abstraite Python elle-" -"même est susceptible d'être modifiée à chaque nouvelle version de Python; ce " -"module permet de trouver à quoi la grammaire actuelle ressemble." +"Le module :mod:`ast` permet aux applications Python de traiter les arbres " +"syntaxiques, dérivés directement de la grammaire abstraite du langage. On " +"peut notamment déterminer dans un programme la forme de chaque élément de " +"grammaire, qui est susceptible d'être modifiée par les nouvelles versions de " +"Python." #: library/ast.rst:23 msgid "" @@ -45,11 +46,11 @@ msgid "" "func:`compile` function." msgstr "" "Un arbre syntaxique abstrait peut être généré en passant l'option :data:`ast." -"PyCF_ONLY_AST` à la fonction native :func:`compile`, ou en utilisant la " -"fonction de facilité :func:`parse` fournie par le module. Le résultat est un " +"PyCF_ONLY_AST` à la fonction native :func:`compile`, ou à l'aide de la " +"fonction auxiliaire :func:`parse` fournie par ce module. Le résultat est un " "arbre composé d'objets dont les classes héritent toutes de :class:`ast.AST`. " -"Un arbre syntaxique abstrait peut être compilé en code objet Python en " -"utilisant la fonction native :func:`compile`." +"On peut compiler les arbres en code objet Python à l'aide de la fonction " +"native :func:`compile`." #: library/ast.rst:33 msgid "Abstract Grammar" @@ -57,11 +58,11 @@ msgstr "Grammaire abstraite" #: library/ast.rst:35 msgid "The abstract grammar is currently defined as follows:" -msgstr "La grammaire abstraite est actuellement définie comme suit :" +msgstr "La grammaire abstraite est actuellement définie comme suit :" #: library/ast.rst:42 msgid "Node classes" -msgstr "Les classes nœud" +msgstr "Classes de nœuds" #: library/ast.rst:46 msgid "" @@ -70,10 +71,11 @@ msgid "" "`below `. They are defined in the :mod:`_ast` C module " "and re-exported in :mod:`ast`." msgstr "" -"C'est la classe de base de toute classe nœud de l'AST. Les classes nœud " -"courantes sont dérivées du fichier :file:`Parser/Python.asdl`, qui est " -"reproduit :ref:`ci-dessous `. Ils sont définis dans le " -"module C :mod:`_ast` et ré-exportés dans le module :mod:`ast`." +"C'est la classe de base de toute classe de nœuds des d'arbres syntaxiques " +"abstraits. Les classes de nœuds elle-mêmes sont dérivées du fichier :file:" +"`Parser/Python.asdl`, qui est reproduit :ref:`ci-dessous `. Elles sont définies dans le module C :mod:`_ast` et ré-exportées " +"dans le module :mod:`ast`." #: library/ast.rst:51 msgid "" @@ -86,13 +88,13 @@ msgid "" "abstract: only instances of specific constructor nodes are ever created." msgstr "" "Il y a une classe définie pour chacun des symboles présents à gauche dans la " -"grammaire abstraite (par exemple, :class:`ast.stmt` ou :class:`ast.expr`). " -"En plus de cela, il y a une classe définie pour chacun des constructeurs " -"présentés à droite; ces classes héritent des classes situées à gauche dans " +"grammaire abstraite (par exemple :class:`ast.stmt` ou :class:`ast.expr`). En " +"plus de cela, une classe est définie pour chacun des constructeurs présentés " +"à droite ; ces classes héritent des classes situées à leur gauche dans " "l'arbre. Par exemple, la classe :class:`ast.BinOp` hérite de la classe :" -"class:`ast.expr`. Pour les règles de réécriture avec alternatives (comme " -"*sums*), la partie gauche est abstraite : seules les instances des " -"constructeurs spécifiques aux nœuds sont créés." +"class:`ast.expr`. Pour les règles de réécriture avec alternatives (les " +"« sommes »), la classe de la partie gauche est abstraite : seules les " +"classes de nœuds à droite sont instanciées." #: library/ast.rst:64 msgid "" @@ -120,15 +122,14 @@ msgid "" "lists. All possible attributes must be present and have valid values when " "compiling an AST with :func:`compile`." msgstr "" -"Si ces attributs sont marqués comme optionnels dans la grammaire (en " -"utilisant un point d'interrogation ``?``), la valeur peut être ``None``. Si " -"les attributs peuvent avoir zéro ou plus valeurs (marqués avec un astérisque " -"``*``), les valeurs sont représentées par des listes Python. Tous les " -"attributs possibles doivent être présents et avoir une valeur valide pour " -"compiler un AST avec :func:`compile`." +"Si un attribut est marqué comme optionnel dans la grammaire (avec un point " +"d'interrogation ``?``), sa valeur peut être ``None``. S'il peut avoir zéro, " +"une ou plusieurs valeurs (ce qui est marqué par un astérisque ``*``), elles " +"sont regroupées dans une liste Python. Tous les attributs possibles doivent " +"être présents et avoir une valeur valide pour compiler un arbre syntaxique " +"avec :func:`compile`." #: library/ast.rst:82 -#, fuzzy msgid "" "Instances of :class:`ast.expr` and :class:`ast.stmt` subclasses have :attr:" "`lineno`, :attr:`col_offset`, :attr:`end_lineno`, and :attr:`end_col_offset` " @@ -139,13 +140,15 @@ msgid "" "the node. The UTF-8 offset is recorded because the parser uses UTF-8 " "internally." msgstr "" -"Les instances des sous-classes :class:`ast.expr` et :class:`ast.stmt` " -"possèdent les attributs :attr:`lineno` et :attr:`col_offset`. L'attribut :" -"attr:`lineno` est le numéro de ligne dans le code source (indexé à partir de " -"1 tel que la première ligne est la ligne 1) et l'attribut :attr:`col_offset` " -"qui représente le décalage UTF-8 en byte du premier jeton qui a généré le " -"nœud. Le décalage UTF-8 est enregistré parce que l'analyseur syntaxique " -"utilise l'UTF-8 en interne." +"Les instances des sous-classes de :class:`ast.expr` et :class:`ast.stmt` " +"possèdent les attributs :attr:`lineno`, :attr:`col_offset`, :attr:" +"`end_lineno` et :attr:`end_col_offset`. Les attributs :attr:`lineno` et :" +"attr:`end_lineno` sont les numéros de ligne de début et de fin dans le code " +"source (indexés à partir de 1, la première ligne est la ligne 1). Les " +"attributs :attr:`col_offset` et :attr:`end_col_offset` représentent quant à " +"eux les décalages respectifs, en octets au format UTF-8, du premier et du " +"dernier lexème qui ont généré le nœud. Les décalages sont exprimés en octets " +"au format UTF-8 parce que l'analyseur syntaxique utilise l'UTF-8 en interne." #: library/ast.rst:91 msgid "" @@ -154,13 +157,17 @@ msgid "" "one can get the source segment of a one-line expression node using " "``source_line[node.col_offset : node.end_col_offset]``." msgstr "" +"Les décalages *end…* ne sont pas obligatoires ni nécessaires au compilateur. " +"*end_col_offset* pointe *après* le dernier lexème. On peut donc obtenir la " +"partie du code source ayant donné lieu à une expression avec " +"``ligne_source[nœud.col_offset : nœud.end_col_offset]``." #: library/ast.rst:96 msgid "" "The constructor of a class :class:`ast.T` parses its arguments as follows:" msgstr "" -"Le constructeur d'une classe :class:`ast.T` analyse ses arguments comme " -"suit :" +"Le constructeur d'une classe nommée :class:`ast.T` analyse ses arguments " +"comme suit :" #: library/ast.rst:98 msgid "" @@ -168,7 +175,7 @@ msgid "" "in :attr:`T._fields`; they will be assigned as attributes of these names." msgstr "" "S'il y a des arguments positionnels, il doit y avoir autant de termes dans :" -"attr:`T._fields`; ils sont assignés comme attributs portant ces noms." +"attr:`T._fields` ; ils sont assignés comme attributs portant ces noms." #: library/ast.rst:100 msgid "" @@ -184,15 +191,17 @@ msgid "" "use ::" msgstr "" "Par exemple, pour créer et peupler un nœud :class:`ast.UnaryOp`, on peut " -"utiliser ::" +"utiliser ::" #: library/ast.rst:115 msgid "or the more compact ::" -msgstr "ou, plus compact ::" +msgstr "ou, plus compact ::" #: library/ast.rst:122 msgid "Class :class:`ast.Constant` is now used for all constants." msgstr "" +"toutes les constantes sont désormais représentées par des instances de :" +"class:`ast.Constant`." #: library/ast.rst:126 msgid "" @@ -207,6 +216,10 @@ msgid "" "will be removed in future Python releases. In the meantime, instantiating " "them will return an instance of a different class." msgstr "" +"les classes :class:`ast.Num`, :class:`ast.Str`, :class:`ast.Bytes`, :class:" +"`ast.NameConstant` et :class:`ast.Ellipsis` sont toujours présentes, mais " +"seront supprimées dans une version future. Pour l'instant, leurs " +"constructeurs renvoient des instances de classes différentes." #: library/ast.rst:138 msgid "" @@ -214,6 +227,9 @@ msgid "" "available, but they will be removed in future Python releases. In the " "meantime, instantiating them will return an instance of a different class." msgstr "" +"les classes :class:`ast.Index` et :class:`ast.ExtSlice` seront retirées à " +"l'avenir. Pour l'instant, elles sont toujours disponibles mais leurs " +"constructeurs renvoient des instances de classes différentes." #: library/ast.rst:144 msgid "" @@ -221,6 +237,10 @@ msgid "" "adapted from the fantastic `Green Tree Snakes `__ project and all its contributors." msgstr "" +"Les descriptions individuelles des classes de nœuds dans la prochaine " +"section sont au départ adaptées du merveilleux projet `Green Tree Snakes " +"`_, porté par de nombreux " +"contributeurs." #: library/ast.rst:150 msgid "Literals" @@ -234,6 +254,10 @@ msgid "" "container types (tuples and frozensets) if all of their elements are " "constant." msgstr "" +"Valeur constante, contenue dans le champ *value*. Les valeurs possibles sont " +"celles de types simples comme les nombres, les chaînes de caractères, ou " +"encore ``None``, mais aussi certains conteneurs immuables (*n*-uplets et " +"ensembles figés) lorsque tous leurs éléments sont constants." #: library/ast.rst:168 msgid "" @@ -241,32 +265,37 @@ msgid "" "contains a single formatting field and nothing else the node can be isolated " "otherwise it appears in :class:`JoinedStr`." msgstr "" +"Champ de formatage dans une chaîne littérale formatée (*f-string*). Ce nœud " +"peut être isolé si la chaîne contient un unique champ et rien d'autre. " +"Sinon, il apparaît dans :class:`JoinedStr`." #: library/ast.rst:172 msgid "" "``value`` is any expression node (such as a literal, a variable, or a " "function call)." msgstr "" +"*value* est un nœud d'expression quelconque (comme un littéral, une " +"variable, ou encore un appel de fonction)." #: library/ast.rst:174 msgid "``conversion`` is an integer:" -msgstr "" +msgstr "*conversion* est un entier parmi les valeurs suivantes :" #: library/ast.rst:176 msgid "-1: no formatting" -msgstr "" +msgstr "-1, aucun formatage ;" #: library/ast.rst:177 msgid "115: ``!s`` string formatting" -msgstr "" +msgstr "115, pour le formatage par ``str()`` correspondant à ``!s`` ;" #: library/ast.rst:178 msgid "114: ``!r`` repr formatting" -msgstr "" +msgstr "114, pour le formatage par ``repr()`` correspondant à ``!r`` ;" #: library/ast.rst:179 msgid "97: ``!a`` ascii formatting" -msgstr "" +msgstr "97, pour le formatage par ``ascii()`` correspondant à ``!a``." #: library/ast.rst:181 msgid "" @@ -274,12 +303,18 @@ msgid "" "the value, or ``None`` if no format was specified. Both ``conversion`` and " "``format_spec`` can be set at the same time." msgstr "" +"*format_spec* est un nœud :class:`JoinedStr` qui précise la manière de " +"formater la valeur. Si aucun formatage particulier n'a été donné, " +"*format_spec* vaut ``None``. *conversion* et *format_spec* peuvent tout à " +"fait coexister." #: library/ast.rst:188 msgid "" "An f-string, comprising a series of :class:`FormattedValue` and :class:" "`Constant` nodes." msgstr "" +"Chaîne littérale formatée (*f-string*), qui contient une liste de nœuds :" +"class:`FormattedValue` et :class:`Constant`." #: library/ast.rst:217 msgid "" @@ -287,10 +322,14 @@ msgid "" "``ctx`` is :class:`Store` if the container is an assignment target (i.e. " "``(x,y)=something``), and :class:`Load` otherwise." msgstr "" +"Liste ou *n*-uplet, dont les éléments sont rassemblés dans la liste *elts*. " +"*ctx* est une instance de :class:`Store` si la liste ou le *n*-uplet est la " +"cible d'une affectation (par exemple ``(x, y) = quelque_chose``). Sinon, " +"c'est une instance de :class:`Load`." #: library/ast.rst:243 msgid "A set. ``elts`` holds a list of nodes representing the set's elements." -msgstr "" +msgstr "Ensemble. *elts* est la liste de ses éléments." #: library/ast.rst:258 msgid "" @@ -298,6 +337,11 @@ msgid "" "keys and the values respectively, in matching order (what would be returned " "when calling :code:`dictionary.keys()` and :code:`dictionary.values()`)." msgstr "" +"Dictionnaire. Les listes *keys* et *values* contiennent respectivement les " +"clés et les valeurs. Leurs ordres se correspondent, c'est-à-dire que la " +"valeur associée à l'élément d'indice *i* dans *keys* est à chercher à " +"l'indice *i* de *values*. *keys* et *values* sont donc des équivalents à " +"``dictionnaire.keys()`` et ``dictionnaire.values()``." #: library/ast.rst:262 msgid "" @@ -305,16 +349,21 @@ msgid "" "be expanded goes in the ``values`` list, with a ``None`` at the " "corresponding position in ``keys``." msgstr "" +"Si un dictionnaire littéral contient une expression doublement étoilée à " +"déballer, elle est intégrée dans *values*, et ``None`` est mis à la place " +"correspondante dans *keys*." #: library/ast.rst:280 msgid "Variables" -msgstr "" +msgstr "Variables" #: library/ast.rst:284 msgid "" "A variable name. ``id`` holds the name as a string, and ``ctx`` is one of " "the following types." msgstr "" +"Variable, dont le nom est *id* (une chaîne de caractères). *ctx* est de l'un " +"des trois types :" #: library/ast.rst:292 msgid "" @@ -322,6 +371,9 @@ msgid "" "new value to it, or to delete it. Variable references are given a context to " "distinguish these cases." msgstr "" +"Ces types de contexte distinguent les variables selon qu'elles sont " +"utilisées pour lire la valeur, mettre la variable à une nouvelle valeur, ou " +"supprimer la variable." #: library/ast.rst:325 msgid "" @@ -329,6 +381,10 @@ msgid "" "class:`Name` node. This type must be used when building a :class:`Call` node " "with ``*args``." msgstr "" +"Élément étoilé. *value* est le nœud auquel s'applique l'étoile. Le plus " +"souvent, *value* est une instance de :class:`Name`. Ce type est notamment " +"nécessaire pour les appels de fonction avec déballage d'arguments (par " +"exemple ``fonction(*args)`` ; voir aussi :class:`Call`)." #: library/ast.rst:348 msgid "Expressions" @@ -342,28 +398,40 @@ msgid "" "`Constant`, a :class:`Name`, a :class:`Lambda`, a :class:`Yield` or :class:" "`YieldFrom` node." msgstr "" +"Lorsque une expression, comme l'appel d'une fonction, apparaît comme une " +"instruction à elle seule, sans que la valeur ne soit utilisée ou " +"sauvegardée, l'expression est insérée dans ce conteneur. Le type de *value* " +"peut être l'un des autres nœuds décrits dans cette section, ou bien parmi :" +"class:`Constant`, :class:`Name`, :class:`Lambda`, :class:`Yield` et :class:" +"`YieldFrom`." #: library/ast.rst:371 msgid "" "A unary operation. ``op`` is the operator, and ``operand`` any expression " "node." msgstr "" +"Unité lexicale désignant une opération unaire. L'opérateur est *op*, " +"l'opérande *operand* est un nœud d'expression quelconque." #: library/ast.rst:380 msgid "" "Unary operator tokens. :class:`Not` is the ``not`` keyword, :class:`Invert` " "is the ``~`` operator." msgstr "" +"Unités lexicales désignant des opérations unaires. :class:`Not` correspond " +"au mot-clé ``not``, :class:`Invert` à l'opérateur ``~``." #: library/ast.rst:394 msgid "" "A binary operation (like addition or division). ``op`` is the operator, and " "``left`` and ``right`` are any expression nodes." msgstr "" +"Opération binaire (comme l'addition ou la division). L'opérateur est *op*, " +"les opérandes *left* et *right* sont des nœuds d'expression quelconques." #: library/ast.rst:421 msgid "Binary operator tokens." -msgstr "" +msgstr "Unités lexicales pour les opérations binaires." #: library/ast.rst:426 msgid "" @@ -372,14 +440,21 @@ msgid "" "operator, such as ``a or b or c``, are collapsed into one node with several " "values." msgstr "" +"Opération booléenne, c'est-à-dire ``and`` ou ``or``, entre *op* et les " +"éléments de *values*. Les deux opérateurs sont distingués par le type de " +"*op*, à savoir :class:`And` ou :class:`Or`. Les applications successives du " +"même opérateur (comme ``a or b or c``) sont regroupées dans un nœud unique " +"avec plusieurs éléments dans la liste *values*." #: library/ast.rst:431 msgid "This doesn't include ``not``, which is a :class:`UnaryOp`." msgstr "" +"L'opérateur ``not`` n'est pas implémenté ici, mais bien dans :class:" +"`UnaryOp`." #: library/ast.rst:447 msgid "Boolean operator tokens." -msgstr "" +msgstr "Unités lexicales pour les opérations booléennes." #: library/ast.rst:452 msgid "" @@ -387,32 +462,45 @@ msgid "" "comparison, ``ops`` the list of operators, and ``comparators`` the list of " "values after the first element in the comparison." msgstr "" +"Comparaison de deux valeurs ou plus. *left* est le premier élément de la " +"comparaison, *ops* la liste des opérateurs, et *comparators* la liste des " +"éléments restants de la comparaison." #: library/ast.rst:481 msgid "Comparison operator tokens." -msgstr "" +msgstr "Unités lexicales pour les comparaisons." #: library/ast.rst:486 msgid "" "A function call. ``func`` is the function, which will often be a :class:" "`Name` or :class:`Attribute` object. Of the arguments:" msgstr "" +"Appel d'une fonction. Le nœud *func*, représentant la fonction appelée, est " +"habituellement de type :class:`Name` ou :class:`Attribute`. Les arguments " +"sont contenus dans :" #: library/ast.rst:489 msgid "``args`` holds a list of the arguments passed by position." msgstr "" +"*args*, la liste des arguments passés sans les nommer (arguments " +"positionnels) ;" #: library/ast.rst:490 msgid "" "``keywords`` holds a list of :class:`keyword` objects representing arguments " "passed by keyword." msgstr "" +"*keywords*, la liste des arguments nommés sous forme de nœuds :class:" +"`keyword`." #: library/ast.rst:493 msgid "" "When creating a ``Call`` node, ``args`` and ``keywords`` are required, but " "they can be empty lists. ``starargs`` and ``kwargs`` are optional." msgstr "" +"Les arguments *args* et *keywords* du constructeur de ``Call`` sont " +"obligatoires (mais peuvent être des listes vides). *starargs* (arguments " +"étoilés) et *kwargs* (arguments nommés) sont facultatifs." #: library/ast.rst:517 msgid "" @@ -425,6 +513,8 @@ msgid "" "An expression such as ``a if b else c``. Each field holds a single node, so " "in the following example, all three are :class:`Name` nodes." msgstr "" +"Expression ternaire (``a if b else c``). Chaque champ contient un unique " +"nœud. Dans l'exemple suivant, les trois sont de la classe :class:`Name`." #: library/ast.rst:538 msgid "" @@ -433,6 +523,10 @@ msgid "" "``ctx`` is :class:`Load`, :class:`Store` or :class:`Del` according to how " "the attribute is acted on." msgstr "" +"Accès à un attribut (comme ``d.keys``). *value* est un nœud, souvent de la " +"classe :class:`Name`. *attr* est le nom de l'attribut, sous forme de chaîne " +"de caractères. *ctx* est de classe :class:`Load`, :class:`Store` ou :class:" +"`Del` selon le type de l'action effectuée sur l'attribut." #: library/ast.rst:555 msgid "" @@ -441,10 +535,14 @@ msgid "" "`Assign` node in which the first argument can be multiple nodes, in this " "case both ``target`` and ``value`` must be single nodes." msgstr "" +"Expression d'affectation. Ces nœuds proviennent de l'opérateur « morse » ``:" +"=``. Contrairement à :class:`Assign`, dont le premier argument est une liste " +"qui peut contenir plusieurs cibles, les arguments *target* et *value* sont " +"ici des nœuds simples." #: library/ast.rst:570 msgid "Subscripting" -msgstr "" +msgstr "Indiçage" #: library/ast.rst:574 msgid "" @@ -453,6 +551,12 @@ msgid "" "class:`Tuple` and contain a :class:`Slice`. ``ctx`` is :class:`Load`, :class:" "`Store` or :class:`Del` according to the action performed with the subscript." msgstr "" +"Accès à un indice, par exemple ``liste[1]``. *value* est l'objet où l'indice " +"est pris, donc la plupart du temps une séquence ou une table associative. " +"*slice* est soit un indice, soit une tranche, soit une clé. Les instances " +"de :class:`Tuple` pour *slice* peuvent contenir des objets :class:`Slice`. " +"*ctx* est de type :class:`Load`, :class:`Store` ou :class:`Del` selon " +"l'action appliquée à l'indice." #: library/ast.rst:598 msgid "" @@ -460,10 +564,14 @@ msgid "" "occur only inside the *slice* field of :class:`Subscript`, either directly " "or as an element of :class:`Tuple`." msgstr "" +"Tranches normales (de la forme ``début:fin`` ou ``début:fin:pas``). Les " +"instances de cette classe ne peuvent apparaître que dans le champ *slice* " +"d'un :class:`Subscript`, que ce soit directement ou en tant qu'élément d'un :" +"class:`Tuple`." #: library/ast.rst:615 msgid "Comprehensions" -msgstr "" +msgstr "Compréhensions" #: library/ast.rst:622 msgid "" @@ -471,10 +579,14 @@ msgid "" "comprehensions. ``elt`` (or ``key`` and ``value``) is a single node " "representing the part that will be evaluated for each item." msgstr "" +"Liste, ensemble ou dictionnaire en compréhension, ou expression génératrice. " +"*elt* est l'expression avant le premier ``for``, évaluée à chaque itération. " +"Il est remplacé par *key* (expression pour la clé) et *value* (expression " +"pour la valeur) dans le cas des dictionnaires." #: library/ast.rst:626 msgid "``generators`` is a list of :class:`comprehension` nodes." -msgstr "" +msgstr "*generators* est une liste de nœuds :class:`comprehension`." #: library/ast.rst:668 msgid "" @@ -483,22 +595,32 @@ msgid "" "``iter`` is the object to iterate over. ``ifs`` is a list of test " "expressions: each ``for`` clause can have multiple ``ifs``." msgstr "" +"Une clause ``for`` à l'intérieur d'une compréhension. *iter* est l'objet à " +"parcourir, *target* est la cible de l'affectation qui se produit à chaque " +"itération (la plupart du temps un nœud :class:`Name` ou :class:`Tuple`). " +"*ifs* contient les tests qui décident si l'élément doit être inséré. C'est " +"une liste, car chaque ``for`` peut être suivi de plusieurs ``if``." #: library/ast.rst:673 msgid "" "``is_async`` indicates a comprehension is asynchronous (using an ``async " "for`` instead of ``for``). The value is an integer (0 or 1)." msgstr "" +"*is_async* est une valeur booléenne sous forme d'entier, 0 ou 1, qui indique " +"si la compréhension est asynchrone, c'est-à-dire qu'elle a été écrite avec " +"``async for`` au lieu de ``for``." #: library/ast.rst:739 msgid "Statements" -msgstr "" +msgstr "Instructions" #: library/ast.rst:743 msgid "" "An assignment. ``targets`` is a list of nodes, and ``value`` is a single " "node." msgstr "" +"Affectation. *targets* est une liste de nœuds, *value* est simplement un " +"nœud." #: library/ast.rst:745 msgid "" @@ -506,11 +628,17 @@ msgid "" "Unpacking is represented by putting a :class:`Tuple` or :class:`List` within " "``targets``." msgstr "" +"S'il y a plusieurs nœuds dans *targets*, ils sont tous pris comme des cibles " +"auxquelles est affectée la même expression. Le déballage de séquences est " +"représenté par des nœuds :class:`Tuple` ou :class:`List` comme éléments de " +"*targets*." #: library/ast.rst:1038 library/ast.rst:1264 msgid "" "``type_comment`` is an optional string with the type annotation as a comment." msgstr "" +"Le champ facultatif *type_comment* contient une annotation de type fournie " +"par un commentaire, et ce sous la forme d'une chaîne de caractères." #: library/ast.rst:781 msgid "" @@ -521,6 +649,14 @@ msgid "" "integer set to True for a :class:`Name` node in ``target`` that do not " "appear in between parenthesis and are hence pure names and not expressions." msgstr "" +"Affectation accompagnée d'une annotation de type. La cible *target* est un " +"nœud de type :class:`Name`, :class:`Attribute` ou :class:`Subscript`. " +"*annotation* est le contenu de l'annotation, par exemple un nœud :class:" +"`Constant` ou :class:`Name`. Le champ *value* est facultatif et peut " +"contenir un nœud, la valeur affectée à la cible. *simple* est une valeur " +"booléenne sous forme d'entier, 0 ou 1, qui vaut 1 si et seulement si " +"*target* est de type :class:`Name` et provient d'un nom sans parenthèses, " +"donc un nom simple plutôt qu'une expression." #: library/ast.rst:836 msgid "" @@ -529,12 +665,18 @@ msgid "" "context), ``op`` is :class:`Add`, and ``value`` is a :class:`Constant` with " "value for 1." msgstr "" +"Affectation incrémentale, par exemple ``a += 1``. Dans l'exemple qui suit, " +"*target* est un nœud de type :class:`Name` avec le nom ``'x'`` (de contexte :" +"class:`Store`), *op* est une instance de :class:`Add`, et *value* est un " +"nœud :class:`Constant` contenant la valeur 1." #: library/ast.rst:841 msgid "" "The ``target`` attribute connot be of class :class:`Tuple` or :class:`List`, " "unlike the targets of :class:`Assign`." msgstr "" +"Contrairement aux cibles acceptées par :class:`Assign`, le champ *target* ne " +"peut pas être ici de type :class:`Tuple` ou :class:`List`." #: library/ast.rst:858 msgid "" @@ -542,36 +684,50 @@ msgid "" "normally a :class:`Call` or :class:`Name`, or ``None`` for a standalone " "``raise``. ``cause`` is the optional part for ``y`` in ``raise x from y``." msgstr "" +"Instruction ``raise``. *exc* est l'exception à lever, la plupart du temps un " +"nœud de type :class:`Call` ou :class:`Name`. Ce champ vaut ``None`` dans le " +"cas d'un ``raise`` sans rien d'autre. Le champ facultatif *cause* correspond " +"à la partie après le ``from`` dans ``raise ... from ...``." #: library/ast.rst:875 msgid "" "An assertion. ``test`` holds the condition, such as a :class:`Compare` node. " "``msg`` holds the failure message." msgstr "" +"Assertion. *test* est la condition, par exemple un nœud :class:`Compare`. " +"*msg* est le message d'erreur affiché si le test s'évalue comme faux." #: library/ast.rst:891 msgid "" "Represents a ``del`` statement. ``targets`` is a list of nodes, such as :" "class:`Name`, :class:`Attribute` or :class:`Subscript` nodes." msgstr "" +"Instruction ``del``. Les éléments à supprimer sont rassemblés dans la liste " +"*target*. Ce sont généralement des nœuds de type :class:`Name`, :class:" +"`Attribute` ou :class:`Subscript`." #: library/ast.rst:909 msgid "A ``pass`` statement." -msgstr "" +msgstr "Instruction ``pass``." #: library/ast.rst:920 msgid "" "Other statements which are only applicable inside functions or loops are " "described in other sections." msgstr "" +"Il existe d'autres instructions, qui ne peuvent apparaître que dans certains " +"contextes spécifiques comme l'intérieur d'une fonction ou d'une boucle. " +"Elles sont décrites dans d'autres sections de ce document." #: library/ast.rst:924 msgid "Imports" -msgstr "" +msgstr "Importations" #: library/ast.rst:928 msgid "An import statement. ``names`` is a list of :class:`alias` nodes." msgstr "" +"Instruction ``import``. *names* prend la forme d'une liste de nœuds :class:" +"`alias`." #: library/ast.rst:945 msgid "" @@ -580,28 +736,45 @@ msgid "" "import foo``. ``level`` is an integer holding the level of the relative " "import (0 means absolute import)." msgstr "" +"Instruction ``from ... import ...``. La partie après ``from`` est mise dans " +"*module* comme une simple chaîne de caractères. Dans le cas des importations " +"relatives, comme ``from ..module import quelque_chose``, *module* ne " +"contient pas les points au début. Dans les instructions de la forme ``from . " +"import toto``, *module* vaut ``None``. *level* est le niveau d'importation " +"relative sous forme d'entier (0 pour les importations absolues)." #: library/ast.rst:967 msgid "" "Both parameters are raw strings of the names. ``asname`` can be ``None`` if " "the regular name is to be used." msgstr "" +"Correspond à ``... as ...`` dans une importation. *name* et *asname* sont de " +"simples chaînes de caractères, qui correspondent aux deux parties de ``... " +"as ...``. Dans les instructions sans ``as`` (où le module n'est pas " +"renommé), *asname* vaut ``None``." #: library/ast.rst:984 msgid "Control flow" -msgstr "" +msgstr "Contrôle de l'exécution" #: library/ast.rst:987 msgid "" "Optional clauses such as ``else`` are stored as an empty list if they're not " "present." msgstr "" +"Si une clause facultative comme ``else`` est absente, le champ correspondant " +"dans l'arbre est une liste vide." +# Il faut développer un peu plus que l'original car le lecteur ne comprend pas forcément les termes « body » et « orelse ». La même considération s'applique à bien des descriptions par la suite. #: library/ast.rst:992 msgid "" "An ``if`` statement. ``test`` holds a single node, such as a :class:" "`Compare` node. ``body`` and ``orelse`` each hold a list of nodes." msgstr "" +"Instruction ``if``. La condition, *test*, est un nœud, par exemple une " +"instance de :class:`Compare`. *body* est la liste des instructions du bloc. " +"*orelse* contient les instructions dans le ``else`` (liste vide s'il n'y a " +"pas de ``else``)." #: library/ast.rst:995 msgid "" @@ -609,6 +782,9 @@ msgid "" "appear as extra :class:`If` nodes within the ``orelse`` section of the " "previous one." msgstr "" +"Les clauses ``elif`` ne possèdent pas de représentation particulière. Elles " +"sont simplement mises dans le *orelse* du ``if`` ou ``elif`` précédent, " +"comme nœuds de type :class:`If`." #: library/ast.rst:1030 msgid "" @@ -618,22 +794,38 @@ msgid "" "contain lists of nodes to execute. Those in ``orelse`` are executed if the " "loop finishes normally, rather than via a ``break`` statement." msgstr "" +"Boucle ``for``. Elle porte sur l'itérable donné par le nœud *iter*. La cible " +"des affectations successives est *target*, qui est un nœud de type :class:" +"`Name`, :class:`Tuple` ou :class:`List`. Les instructions du bloc ``for`` " +"forment la liste *body*. Celles de la liste *orelse* proviennent d'une " +"éventuelle clause ``else`` et sont exécutées si la boucle se termine par " +"épuisement de l'itérable, et non pas par un ``break``." #: library/ast.rst:1064 msgid "" "A ``while`` loop. ``test`` holds the condition, such as a :class:`Compare` " "node." msgstr "" +"Boucle ``while``. *test* est la condition évaluée à chaque itération, par " +"exemple un nœud :class:`Compare`. *body* contient les instructions du bloc, " +"et *orelse* celles d'un éventuel bloc ``else``, exécuté lorsque la boucle " +"termine parce que la condition devient fausse et non pas à cause d'une " +"instruction ``break``." #: library/ast.rst:1091 msgid "The ``break`` and ``continue`` statements." -msgstr "" +msgstr "Instructions ``break`` et ``continue``." #: library/ast.rst:1126 msgid "" "``try`` blocks. All attributes are list of nodes to execute, except for " "``handlers``, which is a list of :class:`ExceptHandler` nodes." msgstr "" +"Bloc ``try``. Les nœuds de la liste *body* sont les instructions à exécuter " +"sous contrôle des exceptions. La liste *handlers* contient des nœuds :class:" +"`ExceptHandler`, un par ``except``. Les listes *orelse* et *finalbody* " +"contiennent respectivement les instructions se trouvant dans d'éventuels " +"blocs ``else`` et ``finally``." #: library/ast.rst:1172 msgid "" @@ -642,6 +834,12 @@ msgid "" "clause). ``name`` is a raw string for the name to hold the exception, or " "``None`` if the clause doesn't have ``as foo``. ``body`` is a list of nodes." msgstr "" +"Une clause ``except``. Elle intercepte les exceptions de types donnés par " +"*type*, qui est le plus souvent un nœud :class:`Name` ou bien ``None`` " +"(cette dernière valeur pour les clauses fourre-tout ``except:``). Le nom " +"éventuel de la variable à laquelle affecter l'exception est dans la chaîne " +"de caractères *name* (``None`` s'il n'y a pas de ``as``). Les instructions " +"sous le ``except`` sont dans la liste *body*." #: library/ast.rst:1206 msgid "" @@ -649,6 +847,9 @@ msgid "" "representing the context managers, and ``body`` is the indented block inside " "the context." msgstr "" +"Bloc ``with``. Les gestionnaires de contexte sont stockés dans *items* comme " +"instances de :class:`withitem`. Les instructions sous le ``with`` forment la " +"liste *body*." #: library/ast.rst:1216 msgid "" @@ -657,63 +858,89 @@ msgid "" "`Name`, :class:`Tuple` or :class:`List` for the ``as foo`` part, or ``None`` " "if that isn't used." msgstr "" +"Gestionnaire de contexte dans un bloc ``with``. Le gestionnaire est donné " +"par le nœud *context_expr*, souvent une instance de :class:`Call`. S'il y a " +"affectation avec ``as``, *optional_vars* contient sa cible, qui est un nœud " +"de type :class:`Name`, :class:`Tuple` ou :class:`List`. Sinon, " +"*optional_vars* vaut ``None``." #: library/ast.rst:1249 msgid "Function and class definitions" -msgstr "" +msgstr "Définition de fonctions et de classes" #: library/ast.rst:1253 msgid "A function definition." -msgstr "" +msgstr "Définition d'une fonction." #: library/ast.rst:1255 msgid "``name`` is a raw string of the function name." msgstr "" +"*name* donne le nom de la fonction sous forme d'une chaîne de caractères." #: library/ast.rst:1256 msgid "``args`` is a :class:`arguments` node." msgstr "" +"*args* est un nœud de type :class:`arguments` qui contient les arguments de " +"la signature." #: library/ast.rst:1257 msgid "``body`` is the list of nodes inside the function." -msgstr "" +msgstr "*body* est la liste des instructions dans le corps de la fonction." #: library/ast.rst:1258 msgid "" "``decorator_list`` is the list of decorators to be applied, stored outermost " "first (i.e. the first in the list will be applied last)." msgstr "" +"*decorators_list* est une liste de décorateurs appliqués à la fonction. Ils " +"sont rangés dans leur ordre d'apparition, c'est-à-dire que le premier de la " +"liste est appliqué en dernier." #: library/ast.rst:1260 msgid "``returns`` is the return annotation." -msgstr "" +msgstr "*returns* est l'annotation de renvoi éventuelle." #: library/ast.rst:1269 msgid "" "``lambda`` is a minimal function definition that can be used inside an " "expression. Unlike :class:`FunctionDef`, ``body`` holds a single node." msgstr "" +"Fonction anonyme. Elle est créée avec le mot-clé ``lambda``, limitée à " +"renvoyer une simple expression, et peut être intégrée à une expression plus " +"large. Contrairement à :class:`FunctionDef`, *body* est ici un nœud unique. " +"*args* est une instance de ``arguments`` qui contient les arguments de la " +"signature." #: library/ast.rst:1293 msgid "The arguments for a function." -msgstr "" +msgstr "Arguments d'une fonction." #: library/ast.rst:1295 msgid "" "``posonlyargs``, ``args`` and ``kwonlyargs`` are lists of :class:`arg` nodes." msgstr "" +"*posonlyargs*, *args* et *kwonlyargs* sont des listes de nœuds :class:`arg` " +"qui correspondent respectivement aux arguments obligatoirement positionnels, " +"positionnels ou nommés et obligatoirement nommés." #: library/ast.rst:1296 msgid "" "``vararg`` and ``kwarg`` are single :class:`arg` nodes, referring to the " "``*args, **kwargs`` parameters." msgstr "" +"*varargs* et *kwargs* sont des nœuds :class:`arg` qui apparaissent avec la " +"capture des arguments restants, positionnels (``*arguments_positionnels``) " +"et nommés (``**arguments_nommés``)." #: library/ast.rst:1298 msgid "" "``kw_defaults`` is a list of default values for keyword-only arguments. If " "one is ``None``, the corresponding argument is required." msgstr "" +"*kw_defaults* est la liste des valeurs par défaut pour les arguments " +"obligatoirement nommés. Si l'un des éléments n'est pas un nœud mais " +"``None``, il n'y a pas de valeur par défaut et l'argument correspondant doit " +"être passé obligatoirement à la fonction." #: library/ast.rst:1300 msgid "" @@ -721,6 +948,11 @@ msgid "" "positionally. If there are fewer defaults, they correspond to the last n " "arguments." msgstr "" +"*defaults* est, quant à elle, la liste des valeurs par défauts pour les " +"arguments qui peuvent être passés de manière positionnelle (obligatoirement " +"ou non). S'il y a moins d'éléments dans la liste que d'arguments " +"positionnels, ces éléments donnent les valeurs par défaut des *n* derniers " +"arguments positionnels (avec *n* la longueur de *defaults*)." #: library/ast.rst:1307 msgid "" @@ -733,10 +965,12 @@ msgstr "" msgid "" "``type_comment`` is an optional string with the type annotation as a comment" msgstr "" +"Le champ facultatif *type_comment* est, sous forme de chaîne, une annotation " +"de type fournie par un commentaire." #: library/ast.rst:1357 msgid "A ``return`` statement." -msgstr "" +msgstr "Instruction ``return``, qui renvoie *value*." #: library/ast.rst:1372 msgid "" @@ -744,23 +978,29 @@ msgid "" "they must be wrapped in a :class:`Expr` node if the value sent back is not " "used." msgstr "" +"Expression ``yield`` ou ``yield from``. Ce sont bien des expressions, non " +"pas des instructions. Il faut donc les placer dans un nœud :class:`Expr` si " +"la valeur qu'elles renvoient n'est pas utilisée dans une expression plus " +"large." #: library/ast.rst:1397 msgid "" "``global`` and ``nonlocal`` statements. ``names`` is a list of raw strings." msgstr "" +"Instruction ``global`` ou ``nonlocal``. Elle s'applique aux noms de " +"variables donnés dans *names*, une liste de chaînes de caractères." #: library/ast.rst:1424 msgid "A class definition." -msgstr "" +msgstr "Définition d'une classe." #: library/ast.rst:1426 msgid "``name`` is a raw string for the class name" -msgstr "" +msgstr "*name* est le nom de la classe sous forme de chaîne de caractères ;" #: library/ast.rst:1427 msgid "``bases`` is a list of nodes for explicitly specified base classes." -msgstr "" +msgstr "*bases* est la liste des classes mères données explicitement ;" #: library/ast.rst:1428 msgid "" @@ -768,6 +1008,9 @@ msgid "" "'metaclass'. Other keywords will be passed to the metaclass, as per " "`PEP-3115 `_." msgstr "" +"*keywords* est une liste de nœuds de type :class:`keyword`. Le principal mot-" +"clé qui peut y apparaître est ``metaclass``. Les autres sont passés à la " +"métaclasse (voir la :pep:`3115`) ;" #: library/ast.rst:1431 msgid "" @@ -781,26 +1024,32 @@ msgid "" "``body`` is a list of nodes representing the code within the class " "definition." msgstr "" +"*body* est la liste des instructions contenues dans la définition de classe ;" #: library/ast.rst:1436 msgid "``decorator_list`` is a list of nodes, as in :class:`FunctionDef`." msgstr "" +"*decorators_list* est une liste de nœuds, comme pour :class:`FunctionDef`." #: library/ast.rst:1465 msgid "Async and await" -msgstr "" +msgstr "``async`` et ``await``" #: library/ast.rst:1469 msgid "" "An ``async def`` function definition. Has the same fields as :class:" "`FunctionDef`." msgstr "" +"Fonction déclarée avec ``async def``. Les champs sont les mêmes que dans :" +"class:`FunctionDef`." #: library/ast.rst:1475 msgid "" "An ``await`` expression. ``value`` is what it waits for. Only valid in the " "body of an :class:`AsyncFunctionDef`." msgstr "" +"Expression ``await``, qui attend *value*. Ces nœuds ne peuvent apparaître " +"qu'à l'intérieur de :class:`AsyncFunctionDef`." #: library/ast.rst:1508 msgid "" @@ -808,6 +1057,9 @@ msgid "" "fields as :class:`For` and :class:`With`, respectively. Only valid in the " "body of an :class:`AsyncFunctionDef`." msgstr "" +"Instruction ``async for`` ou ``async with``. Les champs sont les mêmes que " +"ceux de :class:`For` et :class:`With`. Ces nœuds ne peuvent apparaître qu'à " +"l'intérieur de :class:`AsyncFunctionDef`." #: library/ast.rst:1513 msgid "" @@ -817,6 +1069,13 @@ msgid "" "singletons. Changes to one will be reflected in all other occurrences of the " "same value (e.g. :class:`ast.Add`)." msgstr "" +"Lorsqu'une chaîne contenant du code est transformée en arbre syntaxique par :" +"func:`ast.parse`, les nœuds représentants les opérateurs (classes filles de :" +"class:`ast.operator`, :class:`ast.unaryop`, :class:`ast.cmpop`, :class:`ast." +"boolop` et :class:`ast.expr_context`) sont des singletons à l'intérieur de " +"l'arbre renvoyé. Si l'un, par exemple une instance de :class:`ast.Add`, est " +"muté, la modification sera visible sur toutes les autres apparitions de " +"l'opérateur." #: library/ast.rst:1521 msgid ":mod:`ast` Helpers" @@ -827,16 +1086,17 @@ msgid "" "Apart from the node classes, the :mod:`ast` module defines these utility " "functions and classes for traversing abstract syntax trees:" msgstr "" -"À part la classe nœud, le module :mod:`ast` définit ces fonctions et classes " -"utilitaires pour traverser les arbres syntaxiques abstraits :" +"À part les classes de nœuds, le module :mod:`ast` définit plusieurs " +"fonctions et classes utilitaires pour traverser les arbres syntaxiques " +"abstraits." #: library/ast.rst:1528 msgid "" "Parse the source into an AST node. Equivalent to ``compile(source, " "filename, mode, ast.PyCF_ONLY_AST)``." msgstr "" -"Analyse le code source en un nœud AST. Équivalent à ``compile(source, " -"filename, mode, ast.PyCF_ONLY_AST)``." +"Analyse le code source et renvoie un arbre syntaxique. Équivalent à " +"``compile(source, filename, mode, ast.PyCF_ONLY_AST)``." #: library/ast.rst:1531 msgid "" @@ -850,6 +1110,16 @@ msgid "" "the ``type_ignores`` attribute of :class:`Module` (otherwise it is always an " "empty list)." msgstr "" +"Si *type_comments* est mis à ``True``, l'analyseur syntaxique reconnaît les " +"commentaires de type et les ajoute à l'arbre, comme décrit dans la :pep:" +"`484` et la :pep:`526`. Ceci revient à ajouter :data:`ast." +"PyCF_TYPE_COMMENTS` à l'argument *flags* de :func:`compile`. Une erreur de " +"syntaxe est levée si un commentaire de type est placé au mauvais endroit. " +"Les commentaires ``# type: ignore`` sont également détectés et leurs " +"positions dans la source sont placées dans l'attribut *type_ignores* du " +"nœud :class:`Module`. Sans cette option, les commentaires de type sont " +"ignorés tout comme les commentaires ordinaires, et l'attribut *type_comment* " +"des nœuds dont le type possède ce champ sera toujours mis à ``None``." #: library/ast.rst:1541 msgid "" @@ -866,6 +1136,12 @@ msgid "" "use of ``async`` and ``await`` as variable names. The lowest supported " "version is ``(3, 4)``; the highest is ``sys.version_info[0:2]``." msgstr "" +"Si *feature_version* est défini à une version de Python, sous la forme d'un " +"couple ``(version_majeure, version_mineure)``, l'analyseur tentera de lire " +"la source en se conformant à la syntaxe de cette version. Ainsi, avec " +"``feature_version=(3, 4)``, les noms ``async`` et ``await`` peuvent nommer " +"des variables. La version la plus ancienne prise en charge est actuellement " +"``(3, 4)`` ; la plus récente est ``sys.version_info[0:2]``." #: library/ast.rst:1592 msgid "" @@ -873,12 +1149,14 @@ msgid "" "complex string due to stack depth limitations in Python's AST compiler." msgstr "" "Il est possible de faire planter l'interpréteur Python avec des chaînes " -"suffisamment grandes ou complexes lors de la compilation d'un objet AST dû à " -"la limitation de la profondeur de la pile d'appels." +"suffisamment grandes ou complexes lors de la compilation d'un arbre " +"syntaxique en raison de la limitation de la profondeur de la pile d'appels." #: library/ast.rst:1557 msgid "Added ``type_comments``, ``mode='func_type'`` and ``feature_version``." msgstr "" +"ajout des paramètres *type_comments* et *feature_version* ainsi que de la " +"valeur ``'func_type'`` pour *mode*." #: library/ast.rst:1563 msgid "" @@ -886,6 +1164,9 @@ msgid "" "would produce an equivalent :class:`ast.AST` object if parsed back with :" "func:`ast.parse`." msgstr "" +"À partir d'un arbre syntaxique :class:`ast.AST`, reconstruit un code sous " +"forme de chaîne de caractères. S'il est passé à :func:`ast.parse`, le " +"résultat produit un arbre :class:`ast.AST` équivalent à l'original." #: library/ast.rst:1568 msgid "" @@ -899,6 +1180,8 @@ msgid "" "Trying to unparse a highly complex expression would result with :exc:" "`RecursionError`." msgstr "" +"Une :exc:`RecursionError` est levée si l'expression comporte de très " +"nombreux niveaux d'imbrication." #: library/ast.rst:1581 msgid "" @@ -907,11 +1190,11 @@ msgid "" "following Python literal structures: strings, bytes, numbers, tuples, lists, " "dicts, sets, booleans, and ``None``." msgstr "" -"Évalue de manière sûre un nœud expression ou une chaîne de caractères " -"contenant une expression littérale Python ou un conteneur. La chaîne de " -"caractères ou le nœud fourni peut seulement faire partie des littéraux " -"Python suivants : chaînes de caractères, bytes, nombres, *n*-uplets, listes, " -"dictionnaires, ensembles, booléens, et ``None``." +"Évalue de manière sûre un nœud d'expression, ou bien une chaîne de " +"caractères contenant une valeur littérale simple ou un conteneur sous forme " +"littérale. La chaîne de caractères ou le nœud fourni ne doit contenir que " +"des littéraux parmi les types suivants : chaînes de caractères, octets, " +"nombres, *n*-uplets, listes, dictionnaires, ensembles, booléens, et ``None``." #: library/ast.rst:1586 msgid "" @@ -921,18 +1204,18 @@ msgid "" "operators or indexing." msgstr "" "Cela peut être utilisé pour évaluer de manière sûre la chaîne de caractères " -"contenant des valeurs Python de sources non fiable sans avoir besoin " +"contenant des valeurs Python de source non fiable sans avoir besoin " "d'analyser les valeurs elles-mêmes. Cette fonction n'est pas capable " -"d'évaluer des expressions complexes arbitraires, par exemple impliquant des " -"opérateurs ou de l'indexation." +"d'évaluer des expressions arbitrairement complexes, par exemple impliquant " +"des opérateurs ou de l'indiçage." #: library/ast.rst:1596 msgid "Now allows bytes and set literals." -msgstr "Accepte maintenant les littéraux suivants *bytes* et *sets*." +msgstr "accepte maintenant les octets et ensembles littéraux." #: library/ast.rst:1599 msgid "Now supports creating empty sets with ``'set()'``." -msgstr "" +msgstr "accepte ``set()`` pour les ensembles vides." #: library/ast.rst:1605 msgid "" @@ -941,15 +1224,14 @@ msgid "" "`Module` node), or ``None`` if it has no docstring. If *clean* is true, " "clean up the docstring's indentation with :func:`inspect.cleandoc`." msgstr "" -"Renvoie la *docstring* du *node* donné (qui doit être un nœud de type :class:" -"`FunctionDef`, :class:`AsyncFunctionDef`, :class:`ClassDef`, or :class:" -"`Module`), ou ``None`` s'il n'a pas de *docstring*. Si *clean* est vrai, " -"cette fonction nettoie l'indentation de la *docstring* avec :func:`inspect." -"cleandoc`." +"Renvoie la *docstring* du nœud *node* (de type :class:`FunctionDef`, :class:" +"`AsyncFunctionDef`, :class:`ClassDef` or :class:`Module`), ou ``None`` s'il " +"n'a pas de *docstring*. Si *clean* est vrai, cette fonction nettoie " +"l'indentation de la *docstring* avec :func:`inspect.cleandoc`." #: library/ast.rst:1611 msgid ":class:`AsyncFunctionDef` is now supported." -msgstr ":class:`AsyncFunctionDef` est maintenant gérée" +msgstr ":class:`AsyncFunctionDef` est maintenant gérée." #: library/ast.rst:1617 msgid "" @@ -957,6 +1239,10 @@ msgid "" "location information (:attr:`lineno`, :attr:`end_lineno`, :attr:" "`col_offset`, or :attr:`end_col_offset`) is missing, return ``None``." msgstr "" +"Donne la partie de *source* (le code source) qui a donné lieu à *node*. Si " +"l'un des attributs de localisation du nœud (:attr:`lineno`, :attr:" +"`end_lineno`, :attr:`col_offset` et :attr:`end_col_offset`) n'est pas " +"rempli, cette fonction renvoie ``None``." #: library/ast.rst:1621 msgid "" @@ -974,31 +1260,31 @@ msgid "" msgstr "" "Lorsque l'on compile un arbre avec :func:`compile`, le compilateur attend " "les attributs :attr:`lineno` et :attr:`col_offset` pour tous les nœuds qui " -"les supportent. Il est fastidieux de les remplir pour les nœuds générés, " -"cette fonction utilitaire ajoute ces attributs de manière récursive là où " -"ils ne sont pas déjà définis, en les définissant comme les valeurs du nœud " -"parent. Elle fonctionne récursivement en démarrant de *node*." +"les prennent en charge. Il est fastidieux de les remplir pour les nœuds " +"générés par du code. Cette fonction utilitaire ajoute ces attributs de " +"manière récursive là où ils ne sont pas déjà définis, en les définissant " +"comme les valeurs du nœud parent. Elle fonctionne récursivement en démarrant " +"de *node*." #: library/ast.rst:1638 -#, fuzzy msgid "" "Increment the line number and end line number of each node in the tree " "starting at *node* by *n*. This is useful to \"move code\" to a different " "location in a file." msgstr "" -"Incrémente de *n* le numéro de ligne de chaque nœud dans l'arbre en " -"commençant par le nœud *node*. C'est utile pour \"déplacer du code\" à un " -"endroit différent dans un fichier." +"Incrémente de *n* les numéros des lignes de début et ligne de fin de chaque " +"nœud dans l'arbre, en commençant par le nœud *node*. C'est utile pour " +"« déplacer du code » à un endroit différent dans un fichier." #: library/ast.rst:1645 -#, fuzzy msgid "" "Copy source location (:attr:`lineno`, :attr:`col_offset`, :attr:" "`end_lineno`, and :attr:`end_col_offset`) from *old_node* to *new_node* if " "possible, and return *new_node*." msgstr "" -"Copie le code source (:attr:`lineno` et :attr:`col_offset`) de l'ancien nœud " -"*old_node* vers le nouveau nœud *new_node* si possible, et renvoie " +"Copie la position dans la source (attributs :attr:`lineno`, :attr:" +"`col_offset`, :attr:`end_lineno` et :attr:`end_col_offset`) de l'ancien nœud " +"*old_node* vers le nouveau nœud *new_node*, si possible, et renvoie " "*new_node*." #: library/ast.rst:1652 @@ -1006,15 +1292,15 @@ msgid "" "Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields`` " "that is present on *node*." msgstr "" -"Produit un *n*-uplet de ``(fieldname, value)`` pour chaque champ de ``node." -"_fields`` qui est présent dans *node*." +"Produit un *n*-uplet de couples ``(nom_du_champ, valeur)`` pour chaque champ " +"de ``node._fields`` qui est présent dans *node*." #: library/ast.rst:1658 msgid "" "Yield all direct child nodes of *node*, that is, all fields that are nodes " "and all items of fields that are lists of nodes." msgstr "" -"Produit tous les nœuds enfants directs de *node*, c'est à dire, tous les " +"Produit tous les nœuds enfants directs de *node*, c'est-à-dire tous les " "champs qui sont des nœuds et tous les éléments des champs qui sont des " "listes de nœuds." @@ -1037,7 +1323,7 @@ msgid "" msgstr "" "Classe de base pour un visiteur de nœud, qui parcourt l'arbre syntaxique " "abstrait et appelle une fonction de visite pour chacun des nœuds trouvés. " -"Cette fonction peut renvoyer une valeur qui est transmise par la méthode :" +"Cette fonction peut renvoyer une valeur, qui est transmise par la méthode :" "meth:`visit`." #: library/ast.rst:1675 @@ -1055,8 +1341,8 @@ msgid "" "or :meth:`generic_visit` if that method doesn't exist." msgstr "" "Visite un nœud. L'implémentation par défaut appelle la méthode :samp:`self." -"visit_{classname}` où *classname* représente le nom de la classe du nœud, " -"ou :meth:`generic_visit` si cette méthode n'existe pas." +"visit_{classe}` où *classe* représente le nom de la classe du nœud, ou :meth:" +"`generic_visit` si cette méthode n'existe pas." #: library/ast.rst:1686 msgid "This visitor calls :meth:`visit` on all children of the node." @@ -1069,7 +1355,7 @@ msgid "" "visited unless the visitor calls :meth:`generic_visit` or visits them itself." msgstr "" "Notons que les nœuds enfants qui possèdent une méthode de visite spéciale ne " -"seront pas visités à moins que le visiteur n'appelle la méthode :meth:" +"sont pas visités à moins que le visiteur n'appelle la méthode :meth:" "`generic_visit` ou ne les visite lui-même." #: library/ast.rst:1692 @@ -1089,14 +1375,19 @@ msgid "" "not be called in future Python versions. Add the :meth:`visit_Constant` " "method to handle all constant nodes." msgstr "" +"les méthodes :meth:`visit_Num`, :meth:`visit_Str`, :meth:`visit_Bytes`, :" +"meth:`visit_NameConstant` et :meth:`visit_Ellipsis` sont devenues obsolètes " +"et cesseront d'être appelées dans une version ultérieure de Python. Écrivez " +"une méthode :meth:`visit_Constant` pour traiter tous les nœuds qui " +"représentent des valeurs constantes." #: library/ast.rst:1706 msgid "" "A :class:`NodeVisitor` subclass that walks the abstract syntax tree and " "allows modification of nodes." msgstr "" -"Une sous-classe :class:`NodeVisitor` qui traverse l'arbre syntaxique " -"abstrait et permet les modifications des nœuds." +"Une sous-classe de :class:`NodeVisitor` qui traverse l'arbre syntaxique " +"abstrait et permet de modifier les nœuds." #: library/ast.rst:1709 msgid "" @@ -1106,20 +1397,19 @@ msgid "" "location, otherwise it is replaced with the return value. The return value " "may be the original node in which case no replacement takes place." msgstr "" -"Le :class:`NodeTransformer` traverse l'AST et utilise la valeur renvoyée par " -"les méthodes du visiteur pour remplacer ou supprimer l'ancien nœud. Si la " -"valeur renvoyée par la méthode du visiteur est ``None``, le nœud est " -"supprimé de sa position, sinon il est remplacé par la valeur de retour. La " -"valeur de retour peut être le nœud original et dans ce cas, il n'y a pas de " -"remplacement. " +"Le :class:`NodeTransformer` traverse l'arbre syntaxique et utilise la valeur " +"renvoyée par les méthodes du visiteur pour remplacer ou supprimer l'ancien " +"nœud. Si la valeur renvoyée par la méthode du visiteur est ``None``, le nœud " +"est supprimé de sa position, sinon il est remplacé par cette valeur. Elle " +"peut être le nœud original, auquel cas il n'y a pas de remplacement." #: library/ast.rst:1715 msgid "" "Here is an example transformer that rewrites all occurrences of name lookups " "(``foo``) to ``data['foo']``::" msgstr "" -"Voici un exemple du *transformer* qui réécrit les occurrences du " -"dictionnaire (``foo``) en ``data['foo']`` ::" +"Voici un exemple de transformation qui réécrit tous les accès à la valeur " +"d'une variable ``toto`` en ``data['toto']`` ::" #: library/ast.rst:1727 msgid "" @@ -1128,7 +1418,7 @@ msgid "" "method for the node first." msgstr "" "Gardez en tête que si un nœud sur lequel vous travaillez a des nœuds " -"enfants, vous devez transformer également ces nœuds enfant vous-même ou " +"enfants, vous devez transformer également ces nœuds enfants vous-même ou " "appeler d'abord la méthode :meth:`generic_visit` sur le nœud." #: library/ast.rst:1731 @@ -1137,9 +1427,9 @@ msgid "" "statement nodes), the visitor may also return a list of nodes rather than " "just a single node." msgstr "" -"Pour les nœuds qui font partie d'une collection d'instructions (cela " -"s'applique à tous les nœuds instruction), le visiteur peut aussi renvoyer la " -"liste des nœuds plutôt qu'un seul nœud." +"Pour les nœuds qui font partie d'un groupe (notamment toutes les " +"instructions), le visiteur peut aussi renvoyer une liste des nœuds plutôt " +"qu'un seul nœud." #: library/ast.rst:1735 msgid "" @@ -1148,13 +1438,16 @@ msgid "" "`lineno`), :func:`fix_missing_locations` should be called with the new sub-" "tree to recalculate the location information::" msgstr "" +"Si :class:`NodeTransformer` ajoute de nouveaux nœuds à l'original sans leur " +"donner les attributs de position dans la source (:attr:`lineno` et " +"consorts), il faut passer le nouvel arbre (ou la nouvelle partie de l'arbre) " +"à :func:`fix_missing_locations` pour calculer les positions manquantes :" #: library/ast.rst:1743 msgid "Usually you use the transformer like this::" -msgstr "Utilisation typique du *transformer* ::" +msgstr "Utilisation typique des transformations ::" #: library/ast.rst:1750 -#, fuzzy msgid "" "Return a formatted dump of the tree in *node*. This is mainly useful for " "debugging purposes. If *annotate_fields* is true (by default), the returned " @@ -1164,13 +1457,15 @@ msgid "" "dumped by default. If this is wanted, *include_attributes* can be set to " "true." msgstr "" -"Renvoie un *dump* formaté de l'arbre dans *node*. C'est principalement utile " -"à des fins de débogage. La chaîne de caractères renvoyée présente les noms " -"et valeurs des champs. Cela rend le code impossible à évaluer, si l'on " -"souhaite évaluer ce code, l'option *annotate_fields* doit être définie comme " -"``False``. Les attributs comme les numéros de ligne et les décalages de " -"colonne ne sont pas récupérés par défaut. Si l'on souhaite les récupérer, " -"l'option *include_attributes* peut être définie comme ``True``." +"Renvoie une représentation sous forme de chaîne de caractères de l'arbre " +"contenu dans *node*. Ceci est principalement utile à des fins de débogage. " +"Par défaut, les champs sont passés comme paramètres nommés aux constructeurs " +"des classes d'arbre syntaxiques. Cependant, si *annotate_fields* est mis à " +"``False``, les valeurs sont passées, lorsque cela est possible, comme " +"arguments positionnels, rendant la représentation plus compacte. Les " +"attributs comme les numéros de lignes et positions sur les lignes sont " +"masqués par défaut, mais on peut les inclure en mettant *include_attributes* " +"à ``True``." #: library/ast.rst:1758 msgid "" @@ -1181,48 +1476,64 @@ msgid "" "spaces per level. If *indent* is a string (such as ``\"\\t\"``), that " "string is used to indent each level." msgstr "" +"La représentation peut comprendre une indentation afin d'être plus lisible. " +"Si *indent* est une chaîne de caractères (par exemple une tabulation ``\"\\t" +"\"``), elle est insérée au début des lignes en la répétant autant de fois " +"que le niveau d'indentation. Un entier positif équivaut à un certain nombre " +"d'espaces. Un entier strictement négatif produit un effet identique à 0 ou " +"la chaîne vide, c'est-à-dire des retours à la ligne sans indentation. Avec " +"la valeur par défaut de ``None``, la sortie tient sur une seule ligne." #: library/ast.rst:1765 msgid "Added the *indent* option." -msgstr "" +msgstr "ajout du paramètre *indent*." #: library/ast.rst:1772 msgid "Compiler Flags" -msgstr "" +msgstr "Options du compilateur" #: library/ast.rst:1774 msgid "" "The following flags may be passed to :func:`compile` in order to change " "effects on the compilation of a program:" msgstr "" +"Les options suivantes sont prises en charge par la fonction :func:`compile`. " +"Elles permettent de modifier le comportement de la compilation." #: library/ast.rst:1779 msgid "" "Enables support for top-level ``await``, ``async for``, ``async with`` and " "async comprehensions." msgstr "" +"Active la reconnaissance de ``await``, ``async for``, ``async with`` et des " +"compréhensions asynchrones au niveau le plus haut." #: library/ast.rst:1786 msgid "" "Generates and returns an abstract syntax tree instead of returning a " "compiled code object." msgstr "" +"Génère et renvoie un arbre syntaxique au lieu d'un objet de code compilé." #: library/ast.rst:1791 msgid "" "Enables support for :pep:`484` and :pep:`526` style type comments (``# type: " "``, ``# type: ignore ``)." msgstr "" +"Ajoute la prise en charge des commentaires de types tels que définis dans " +"la :pep:`484` et la :pep:`526` (``# type: un_type`` et ``# type: ignore``)." #: library/ast.rst:1800 msgid "Command-Line Usage" -msgstr "Utilisation en ligne de commande." +msgstr "Utilisation en ligne de commande" #: library/ast.rst:1804 msgid "" "The :mod:`ast` module can be executed as a script from the command line. It " "is as simple as:" msgstr "" +"Le module :mod:`ast` peut être exécuté en tant que script en ligne de " +"commande. C'est aussi simple que ceci :" #: library/ast.rst:1811 msgid "The following options are accepted:" @@ -1230,31 +1541,38 @@ msgstr "Les options suivantes sont acceptées :" #: library/ast.rst:1817 msgid "Show the help message and exit." -msgstr "" +msgstr "Affiche un message d'aide et quitte." #: library/ast.rst:1822 msgid "" "Specify what kind of code must be compiled, like the *mode* argument in :" "func:`parse`." msgstr "" +"Précise le type de code à compiler, comme l'argument *mode* de la fonction :" +"func:`parse`." #: library/ast.rst:1827 msgid "Don't parse type comments." -msgstr "" +msgstr "Désactive la reconnaissance des commentaires de type." #: library/ast.rst:1831 msgid "Include attributes such as line numbers and column offsets." msgstr "" +"Affiche les attributs comme les numéros de lignes et les décalages par " +"rapport aux débuts des lignes." #: library/ast.rst:1836 msgid "Indentation of nodes in AST (number of spaces)." -msgstr "" +msgstr "Nombre d'espaces pour chaque niveau d'indentation dans la sortie." #: library/ast.rst:1838 msgid "" "If :file:`infile` is specified its contents are parsed to AST and dumped to " "stdout. Otherwise, the content is read from stdin." msgstr "" +"L'entrée est lue dans le fichier :file:`infile`, s'il est donné, ou l'entrée " +"standard sinon. Le code source est transformé en un arbre syntaxique, qui " +"est affiché sur la sortie standard." #: library/ast.rst:1844 msgid "" @@ -1263,7 +1581,7 @@ msgid "" msgstr "" "`Green Tree Snakes `_, une " "ressource documentaire externe, qui possède plus de détails pour travailler " -"avec des ASTs Python." +"avec des arbres syntaxiques Python." #: library/ast.rst:1847 msgid "" @@ -1272,6 +1590,10 @@ msgid "" "code that generated them. This is helpful for tools that make source code " "transformations." msgstr "" +"`ASTTokens `_ " +"annote les arbres syntaxiques Python avec les positions des lexèmes et les " +"extraits de code source à partir desquels ils sont produits. Ceci est utile " +"pour les outils qui transforment du code source." #: library/ast.rst:1852 msgid "" @@ -1279,6 +1601,9 @@ msgid "" "token-based and parse-tree-based views of python programs by inserting two-" "way links between tokens and ast nodes." msgstr "" +"`leoAst.py `_ unifie les " +"visions des lexèmes et des arbres syntaxiques en insérant des liens " +"bidirectionnels entre les deux." #: library/ast.rst:1856 msgid "" @@ -1286,6 +1611,10 @@ msgid "" "Tree that looks like an ast tree and keeps all formatting details. It's " "useful for building automated refactoring (codemod) applications and linters." msgstr "" +"`LibCST `_ produit à partir du code source " +"des arbres syntaxiques concrets, qui ressemblent à leurs homologues " +"abstraits et conservent tous les détails du formatage. Cette bibliothèque " +"est utile aux outils de réusinage et d'analyse de code." #: library/ast.rst:1861 msgid "" @@ -1294,3 +1623,8 @@ msgid "" "multiple Python versions). Parso is also able to list multiple syntax errors " "in your python file." msgstr "" +"`Parso `_ est un analyseur syntaxique de code " +"Python qui gère la récupération d'erreurs et la génération de code (de " +"l'arbre syntaxique vers le code source), le tout pour les grammaires de " +"différentes versions de Python et en utilisant différentes versions. Il sait " +"également donner plusieurs erreurs de syntaxe en une seule fois."