forked from AFPy/python-docs-fr
51c6b25514
Automerge of PR #1547 by @Seluj78
3037 lines
142 KiB
Plaintext
3037 lines
142 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
||
# For licence information, see README file.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 3\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2021-02-24 17:33+0100\n"
|
||
"PO-Revision-Date: 2020-05-30 21:58+0900\n"
|
||
"Last-Translator: Samuel Giffard <samuel@giffard.co>\n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\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.3.1\n"
|
||
|
||
#: reference/expressions.rst:6
|
||
msgid "Expressions"
|
||
msgstr "Expressions"
|
||
|
||
#: reference/expressions.rst:10
|
||
msgid ""
|
||
"This chapter explains the meaning of the elements of expressions in Python."
|
||
msgstr ""
|
||
"Ce chapitre explique la signification des éléments des expressions en Python."
|
||
|
||
#: reference/expressions.rst:12
|
||
msgid ""
|
||
"**Syntax Notes:** In this and the following chapters, extended BNF notation "
|
||
"will be used to describe syntax, not lexical analysis. When (one "
|
||
"alternative of) a syntax rule has the form"
|
||
msgstr ""
|
||
"**Notes sur la syntaxe :** dans ce chapitre et le suivant, nous utilisons la "
|
||
"notation BNF étendue pour décrire la syntaxe, pas l'analyse lexicale. Quand "
|
||
"une règle de syntaxe est de la forme"
|
||
|
||
#: reference/expressions.rst:19
|
||
msgid ""
|
||
"and no semantics are given, the semantics of this form of ``name`` are the "
|
||
"same as for ``othername``."
|
||
msgstr ""
|
||
"et qu'aucune sémantique n'est donnée, la sémantique de ``name`` est la même "
|
||
"que celle de ``othername``."
|
||
|
||
#: reference/expressions.rst:26
|
||
msgid "Arithmetic conversions"
|
||
msgstr "Conversions arithmétiques"
|
||
|
||
#: reference/expressions.rst:30
|
||
msgid ""
|
||
"When a description of an arithmetic operator below uses the phrase \"the "
|
||
"numeric arguments are converted to a common type\", this means that the "
|
||
"operator implementation for built-in types works as follows:"
|
||
msgstr ""
|
||
"Quand la description d'un opérateur arithmétique ci-dessous utilise la "
|
||
"phrase « les arguments numériques sont convertis vers un type commun », cela "
|
||
"signifie que l'implémentation de l'opérateur fonctionne de la manière "
|
||
"suivante pour les types natifs :"
|
||
|
||
#: reference/expressions.rst:34
|
||
msgid ""
|
||
"If either argument is a complex number, the other is converted to complex;"
|
||
msgstr ""
|
||
"Si l'un des deux arguments est du type nombre complexe, l'autre est converti "
|
||
"en nombre complexe ;"
|
||
|
||
#: reference/expressions.rst:36
|
||
msgid ""
|
||
"otherwise, if either argument is a floating point number, the other is "
|
||
"converted to floating point;"
|
||
msgstr ""
|
||
"sinon, si l'un des arguments est un nombre à virgule flottante, l'autre est "
|
||
"converti en nombre à virgule flottante ;"
|
||
|
||
#: reference/expressions.rst:39
|
||
msgid "otherwise, both must be integers and no conversion is necessary."
|
||
msgstr ""
|
||
"sinon, les deux doivent être des entiers et aucune conversion n'est "
|
||
"nécessaire."
|
||
|
||
#: reference/expressions.rst:41
|
||
msgid ""
|
||
"Some additional rules apply for certain operators (e.g., a string as a left "
|
||
"argument to the '%' operator). Extensions must define their own conversion "
|
||
"behavior."
|
||
msgstr ""
|
||
"Des règles supplémentaires s'appliquent pour certains opérateurs (par "
|
||
"exemple, une chaîne comme opérande de gauche pour l'opérateur ``%``). Les "
|
||
"extensions doivent définir leurs propres règles de conversion."
|
||
|
||
#: reference/expressions.rst:49
|
||
msgid "Atoms"
|
||
msgstr "Atomes"
|
||
|
||
#: reference/expressions.rst:53
|
||
msgid ""
|
||
"Atoms are the most basic elements of expressions. The simplest atoms are "
|
||
"identifiers or literals. Forms enclosed in parentheses, brackets or braces "
|
||
"are also categorized syntactically as atoms. The syntax for atoms is:"
|
||
msgstr ""
|
||
"Les atomes sont les éléments de base des expressions. Les atomes les plus "
|
||
"simples sont les identifiants et les littéraux. Les expressions entre "
|
||
"parenthèses, crochets ou accolades sont aussi classées syntaxiquement comme "
|
||
"des atomes. La syntaxe pour les atomes est :"
|
||
|
||
#: reference/expressions.rst:66
|
||
msgid "Identifiers (Names)"
|
||
msgstr "Identifiants (noms)"
|
||
|
||
#: reference/expressions.rst:70
|
||
msgid ""
|
||
"An identifier occurring as an atom is a name. See section :ref:"
|
||
"`identifiers` for lexical definition and section :ref:`naming` for "
|
||
"documentation of naming and binding."
|
||
msgstr ""
|
||
"Un identifiant qui apparaît en tant qu'atome est un nom. Lisez la section :"
|
||
"ref:`identifiers` pour la définition lexicale et la section :ref:`naming` "
|
||
"pour la documentation sur les noms et les liaisons afférentes."
|
||
|
||
#: reference/expressions.rst:76
|
||
msgid ""
|
||
"When the name is bound to an object, evaluation of the atom yields that "
|
||
"object. When a name is not bound, an attempt to evaluate it raises a :exc:"
|
||
"`NameError` exception."
|
||
msgstr ""
|
||
"Quand un nom est lié à un objet, l'évaluation de l'atome produit cet objet. "
|
||
"Quand le nom n'est pas lié, toute tentative de l'évaluer lève une exception :"
|
||
"exc:`NameError`."
|
||
|
||
#: reference/expressions.rst:84
|
||
msgid ""
|
||
"**Private name mangling:** When an identifier that textually occurs in a "
|
||
"class definition begins with two or more underscore characters and does not "
|
||
"end in two or more underscores, it is considered a :dfn:`private name` of "
|
||
"that class. Private names are transformed to a longer form before code is "
|
||
"generated for them. The transformation inserts the class name, with leading "
|
||
"underscores removed and a single underscore inserted, in front of the name. "
|
||
"For example, the identifier ``__spam`` occurring in a class named ``Ham`` "
|
||
"will be transformed to ``_Ham__spam``. This transformation is independent "
|
||
"of the syntactical context in which the identifier is used. If the "
|
||
"transformed name is extremely long (longer than 255 characters), "
|
||
"implementation defined truncation may happen. If the class name consists "
|
||
"only of underscores, no transformation is done."
|
||
msgstr ""
|
||
"**Transformation des noms privés :** lorsqu'un identificateur qui apparaît "
|
||
"textuellement dans la définition d'une classe commence par deux (ou plus) "
|
||
"caractères de soulignement et ne se termine pas par deux (ou plus) "
|
||
"caractères de soulignement, il est considéré comme un :dfn:`nom privé "
|
||
"<private name>` de cette classe. Les noms privés sont transformés en une "
|
||
"forme plus longue avant que le code ne soit généré pour eux. La "
|
||
"transformation insère le nom de la classe, avec les soulignés enlevés et un "
|
||
"seul souligné inséré devant le nom. Par exemple, l'identificateur ``__spam`` "
|
||
"apparaissant dans une classe nommée ``Ham`` est transformé en "
|
||
"``_Ham__spam``. Cette transformation est indépendante du contexte syntaxique "
|
||
"dans lequel l'identificateur est utilisé. Si le nom transformé est "
|
||
"extrêmement long (plus de 255 caractères), l'implémentation peut le "
|
||
"tronquer. Si le nom de la classe est constitué uniquement de traits de "
|
||
"soulignement, aucune transformation n'est effectuée."
|
||
|
||
#: reference/expressions.rst:100
|
||
msgid "Literals"
|
||
msgstr "Littéraux"
|
||
|
||
#: reference/expressions.rst:104
|
||
msgid "Python supports string and bytes literals and various numeric literals:"
|
||
msgstr ""
|
||
"Python gère les littéraux de chaînes de caractères, de chaînes d'octets et "
|
||
"de plusieurs autres types numériques :"
|
||
|
||
#: reference/expressions.rst:110
|
||
msgid ""
|
||
"Evaluation of a literal yields an object of the given type (string, bytes, "
|
||
"integer, floating point number, complex number) with the given value. The "
|
||
"value may be approximated in the case of floating point and imaginary "
|
||
"(complex) literals. See section :ref:`literals` for details."
|
||
msgstr ""
|
||
"L'évaluation d'un littéral produit un objet du type donné (chaîne de "
|
||
"caractères, chaîne d'octets, entier, nombre à virgule flottante, nombre "
|
||
"complexe) avec la valeur donnée. La valeur peut être approximée dans le cas "
|
||
"des nombres à virgule flottante et des nombres imaginaires (complexes). "
|
||
"Reportez-vous à la section :ref:`literals` pour les détails."
|
||
|
||
#: reference/expressions.rst:119
|
||
msgid ""
|
||
"All literals correspond to immutable data types, and hence the object's "
|
||
"identity is less important than its value. Multiple evaluations of literals "
|
||
"with the same value (either the same occurrence in the program text or a "
|
||
"different occurrence) may obtain the same object or a different object with "
|
||
"the same value."
|
||
msgstr ""
|
||
"Tous les littéraux sont de types immuables et donc l'identifiant de l'objet "
|
||
"est moins important que sa valeur. Des évaluations multiples de littéraux "
|
||
"avec la même valeur (soit la même occurrence dans le texte du programme, "
|
||
"soit une autre occurrence) résultent dans le même objet ou un objet "
|
||
"différent avec la même valeur."
|
||
|
||
#: reference/expressions.rst:129
|
||
msgid "Parenthesized forms"
|
||
msgstr "Formes parenthésées"
|
||
|
||
#: reference/expressions.rst:135
|
||
msgid ""
|
||
"A parenthesized form is an optional expression list enclosed in parentheses:"
|
||
msgstr ""
|
||
"Une forme parenthésée est une liste d'expressions (cette liste est en fait "
|
||
"optionnelle) placée à l'intérieur de parenthèses :"
|
||
|
||
#: reference/expressions.rst:140
|
||
msgid ""
|
||
"A parenthesized expression list yields whatever that expression list yields: "
|
||
"if the list contains at least one comma, it yields a tuple; otherwise, it "
|
||
"yields the single expression that makes up the expression list."
|
||
msgstr ""
|
||
"Une liste d'expressions entre parenthèses produit ce que la liste de ces "
|
||
"expressions produirait : si la liste contient au moins une virgule, elle "
|
||
"produit un *n*-uplet (type *n*-uplet) ; sinon, elle produit l'expression "
|
||
"elle-même (qui constitue donc elle-même la liste d'expressions)."
|
||
|
||
#: reference/expressions.rst:146
|
||
msgid ""
|
||
"An empty pair of parentheses yields an empty tuple object. Since tuples are "
|
||
"immutable, the same rules as for literals apply (i.e., two occurrences of "
|
||
"the empty tuple may or may not yield the same object)."
|
||
msgstr ""
|
||
"Une paire de parenthèses vide produit un objet *n*-uplet vide. Comme les n-"
|
||
"uplets sont immuables, la même règle que pour les littéraux s'applique "
|
||
"(c'est-à-dire que deux occurrences du *n*-uplet vide peuvent, ou pas, "
|
||
"produire le même objet)."
|
||
|
||
#: reference/expressions.rst:154
|
||
msgid ""
|
||
"Note that tuples are not formed by the parentheses, but rather by use of the "
|
||
"comma operator. The exception is the empty tuple, for which parentheses "
|
||
"*are* required --- allowing unparenthesized \"nothing\" in expressions would "
|
||
"cause ambiguities and allow common typos to pass uncaught."
|
||
msgstr ""
|
||
"Notez que les *n*-uplets ne sont pas créés par les parenthèses mais par "
|
||
"l'utilisation de la virgule. L'exception est le *n*-uplet vide, pour lequel "
|
||
"les parenthèses *sont requises* (autoriser que « rien » ne soit pas "
|
||
"parenthésé dans les expressions aurait généré des ambigüités et aurait "
|
||
"permis à certaines coquilles de passer inaperçu)."
|
||
|
||
#: reference/expressions.rst:163
|
||
msgid "Displays for lists, sets and dictionaries"
|
||
msgstr "Agencements des listes, ensembles et dictionnaires"
|
||
|
||
#: reference/expressions.rst:167
|
||
msgid ""
|
||
"For constructing a list, a set or a dictionary Python provides special "
|
||
"syntax called \"displays\", each of them in two flavors:"
|
||
msgstr ""
|
||
"Pour construire une liste, un ensemble ou un dictionnaire, Python fournit "
|
||
"des syntaxes spéciales dites « agencements » (*displays* en anglais), chaque "
|
||
"agencement comportant deux variantes :"
|
||
|
||
#: reference/expressions.rst:170
|
||
msgid "either the container contents are listed explicitly, or"
|
||
msgstr "soit le contenu du conteneur est listé explicitement,"
|
||
|
||
#: reference/expressions.rst:172
|
||
msgid ""
|
||
"they are computed via a set of looping and filtering instructions, called a :"
|
||
"dfn:`comprehension`."
|
||
msgstr ""
|
||
"soit il est calculé à l'aide de la combinaison d'une boucle et "
|
||
"d'instructions de filtrage, appelée une :dfn:`compréhension` (dans le sens "
|
||
"de ce qui sert à définir un concept, par opposition à *extension*)."
|
||
|
||
#: reference/expressions.rst:180
|
||
msgid "Common syntax elements for comprehensions are:"
|
||
msgstr ""
|
||
"Les compréhensions sont constituées des éléments de syntaxe communs "
|
||
"suivants :"
|
||
|
||
#: reference/expressions.rst:188
|
||
msgid ""
|
||
"The comprehension consists of a single expression followed by at least one :"
|
||
"keyword:`!for` clause and zero or more :keyword:`!for` or :keyword:`!if` "
|
||
"clauses. In this case, the elements of the new container are those that "
|
||
"would be produced by considering each of the :keyword:`!for` or :keyword:`!"
|
||
"if` clauses a block, nesting from left to right, and evaluating the "
|
||
"expression to produce an element each time the innermost block is reached."
|
||
msgstr ""
|
||
"Une compréhension est constituée par une seule expression suivie par au "
|
||
"moins une clause :keyword:`!for` et zéro ou plus clauses :keyword:`!for` ou :"
|
||
"keyword:`!if`. Dans ce cas, les éléments du nouveau conteneur sont ceux qui "
|
||
"auraient été produits si l'on avait considéré toutes les clauses :keyword:`!"
|
||
"for` ou :keyword:`!if` comme des blocs, imbriqués de la gauche vers la "
|
||
"droite, et évalué l'expression pour produire un élément à chaque fois que le "
|
||
"bloc le plus imbriqué était atteint."
|
||
|
||
#: reference/expressions.rst:195
|
||
msgid ""
|
||
"However, aside from the iterable expression in the leftmost :keyword:`!for` "
|
||
"clause, the comprehension is executed in a separate implicitly nested scope. "
|
||
"This ensures that names assigned to in the target list don't \"leak\" into "
|
||
"the enclosing scope."
|
||
msgstr ""
|
||
"Cependant, à part l'expression de l'itérable dans la clause :keyword:`!for` "
|
||
"la plus à gauche, la compréhension est exécutée dans une portée séparée, "
|
||
"implicitement imbriquée. Ceci assure que les noms assignés dans la liste "
|
||
"cible ne « fuient » pas en dehors de cette portée."
|
||
|
||
#: reference/expressions.rst:199
|
||
msgid ""
|
||
"The iterable expression in the leftmost :keyword:`!for` clause is evaluated "
|
||
"directly in the enclosing scope and then passed as an argument to the "
|
||
"implicitly nested scope. Subsequent :keyword:`!for` clauses and any filter "
|
||
"condition in the leftmost :keyword:`!for` clause cannot be evaluated in the "
|
||
"enclosing scope as they may depend on the values obtained from the leftmost "
|
||
"iterable. For example: ``[x*y for x in range(10) for y in range(x, x+10)]``."
|
||
msgstr ""
|
||
"L'expression de l'itérable dans la clause :keyword:`!for` la plus à gauche "
|
||
"est évaluée directement dans la portée englobante puis passée en tant "
|
||
"qu'argument à la portée implicite imbriquée. Les clauses :keyword:`!for` "
|
||
"suivantes et les filtres conditionnels de la clause :keyword:`!for` la plus "
|
||
"à gauche ne peuvent pas être évalués dans la portée englobante, car ils "
|
||
"peuvent dépendre de valeurs obtenues à partir de l'itérable le plus à "
|
||
"gauche. Par exemple : ``[x*y for x in range(10) for y in range(x, x+10)]``."
|
||
|
||
#: reference/expressions.rst:206
|
||
msgid ""
|
||
"To ensure the comprehension always results in a container of the appropriate "
|
||
"type, ``yield`` and ``yield from`` expressions are prohibited in the "
|
||
"implicitly nested scope."
|
||
msgstr ""
|
||
"Pour assurer que le résultat de la compréhension soit un conteneur du type "
|
||
"approprié, les expressions ``yield`` et ``yield from`` sont interdites dans "
|
||
"la portée implicite imbriquée."
|
||
|
||
#: reference/expressions.rst:213
|
||
msgid ""
|
||
"Since Python 3.6, in an :keyword:`async def` function, an :keyword:`!async "
|
||
"for` clause may be used to iterate over a :term:`asynchronous iterator`. A "
|
||
"comprehension in an :keyword:`!async def` function may consist of either a :"
|
||
"keyword:`!for` or :keyword:`!async for` clause following the leading "
|
||
"expression, may contain additional :keyword:`!for` or :keyword:`!async for` "
|
||
"clauses, and may also use :keyword:`await` expressions. If a comprehension "
|
||
"contains either :keyword:`!async for` clauses or :keyword:`!await` "
|
||
"expressions it is called an :dfn:`asynchronous comprehension`. An "
|
||
"asynchronous comprehension may suspend the execution of the coroutine "
|
||
"function in which it appears. See also :pep:`530`."
|
||
msgstr ""
|
||
"Depuis Python 3.6, dans une fonction :keyword:`async def`, une clause :"
|
||
"keyword:`!async for` peut être utilisée pour itérer sur un :term:`itérateur "
|
||
"asynchrone <asynchronous iterator>`. Une compréhension dans une fonction :"
|
||
"keyword:`!async def` consiste alors à avoir une clause :keyword:`!for` or :"
|
||
"keyword:`!async for` suivie par des clauses :keyword:`!for` ou :keyword:`!"
|
||
"async for` additionnelles facultatives et, possiblement, des expressions :"
|
||
"keyword:`await`. Si la compréhension contient soit des clauses :keyword:`!"
|
||
"async for`, soit des expressions :keyword:`!await`, elle est appelée :dfn:"
|
||
"`compréhension asynchrone`. Une compréhension asynchrone peut suspendre "
|
||
"l'exécution de la fonction coroutine dans laquelle elle apparaît. Voir aussi "
|
||
"la :pep:`530`."
|
||
|
||
#: reference/expressions.rst:225
|
||
msgid "Asynchronous comprehensions were introduced."
|
||
msgstr "Les compréhensions asynchrones ont été introduites."
|
||
|
||
#: reference/expressions.rst:401
|
||
msgid "``yield`` and ``yield from`` prohibited in the implicitly nested scope."
|
||
msgstr ""
|
||
"``yield`` et ``yield from`` sont interdites dans la portée implicite "
|
||
"imbriquée."
|
||
|
||
#: reference/expressions.rst:235
|
||
msgid "List displays"
|
||
msgstr "Agencements de listes"
|
||
|
||
#: reference/expressions.rst:245
|
||
msgid ""
|
||
"A list display is a possibly empty series of expressions enclosed in square "
|
||
"brackets:"
|
||
msgstr ""
|
||
"Un agencement de liste est une suite (possiblement vide) d'expressions à "
|
||
"l'intérieur de crochets :"
|
||
|
||
#: reference/expressions.rst:251
|
||
msgid ""
|
||
"A list display yields a new list object, the contents being specified by "
|
||
"either a list of expressions or a comprehension. When a comma-separated "
|
||
"list of expressions is supplied, its elements are evaluated from left to "
|
||
"right and placed into the list object in that order. When a comprehension "
|
||
"is supplied, the list is constructed from the elements resulting from the "
|
||
"comprehension."
|
||
msgstr ""
|
||
"Un agencement de liste produit un nouvel objet liste, dont le contenu est "
|
||
"spécifié soit par une liste d'expression soit par une compréhension. Quand "
|
||
"une liste d'expressions (dont les éléments sont séparés par des virgules) "
|
||
"est fournie, ces éléments sont évalués de la gauche vers la droite et placés "
|
||
"dans l'objet liste, dans cet ordre. Quand c'est une compréhension qui est "
|
||
"fournie, la liste est construite à partir des éléments produits par la "
|
||
"compréhension."
|
||
|
||
#: reference/expressions.rst:261
|
||
msgid "Set displays"
|
||
msgstr "Agencements d'ensembles"
|
||
|
||
#: reference/expressions.rst:270
|
||
msgid ""
|
||
"A set display is denoted by curly braces and distinguishable from dictionary "
|
||
"displays by the lack of colons separating keys and values:"
|
||
msgstr ""
|
||
"Un agencement d'ensemble (type *set*) est délimité par des accolades et se "
|
||
"distingue de l'agencement d'un dictionnaire par le fait qu'il n'y a pas de "
|
||
"« deux points » ``:`` pour séparer les clés et les valeurs :"
|
||
|
||
#: reference/expressions.rst:276
|
||
msgid ""
|
||
"A set display yields a new mutable set object, the contents being specified "
|
||
"by either a sequence of expressions or a comprehension. When a comma-"
|
||
"separated list of expressions is supplied, its elements are evaluated from "
|
||
"left to right and added to the set object. When a comprehension is "
|
||
"supplied, the set is constructed from the elements resulting from the "
|
||
"comprehension."
|
||
msgstr ""
|
||
"Un agencement d'ensemble produit un nouvel objet ensemble muable, le contenu "
|
||
"étant spécifié soit par une séquence d'expression, soit par une "
|
||
"compréhension. Quand une liste (dont les éléments sont séparés par des "
|
||
"virgules) est fournie, ses éléments sont évalués de la gauche vers la droite "
|
||
"et ajoutés à l'objet ensemble. Quand une compréhension est fournie, "
|
||
"l'ensemble est construit à partir des éléments produits par la compréhension."
|
||
|
||
#: reference/expressions.rst:282
|
||
msgid ""
|
||
"An empty set cannot be constructed with ``{}``; this literal constructs an "
|
||
"empty dictionary."
|
||
msgstr ""
|
||
"Un ensemble vide ne peut pas être construit par ``{}`` ; cette écriture "
|
||
"construit un dictionnaire vide."
|
||
|
||
#: reference/expressions.rst:289
|
||
msgid "Dictionary displays"
|
||
msgstr "Agencements de dictionnaires"
|
||
|
||
#: reference/expressions.rst:300
|
||
msgid ""
|
||
"A dictionary display is a possibly empty series of key/datum pairs enclosed "
|
||
"in curly braces:"
|
||
msgstr ""
|
||
"Un agencement de dictionnaire est une série (possiblement vide) de couples "
|
||
"clés-valeurs entourée par des accolades :"
|
||
|
||
#: reference/expressions.rst:309
|
||
msgid "A dictionary display yields a new dictionary object."
|
||
msgstr "Un agencement de dictionnaire produit un nouvel objet dictionnaire."
|
||
|
||
#: reference/expressions.rst:311
|
||
msgid ""
|
||
"If a comma-separated sequence of key/datum pairs is given, they are "
|
||
"evaluated from left to right to define the entries of the dictionary: each "
|
||
"key object is used as a key into the dictionary to store the corresponding "
|
||
"datum. This means that you can specify the same key multiple times in the "
|
||
"key/datum list, and the final dictionary's value for that key will be the "
|
||
"last one given."
|
||
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 "
|
||
"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:321
|
||
msgid ""
|
||
"A double asterisk ``**`` denotes :dfn:`dictionary unpacking`. Its operand "
|
||
"must be a :term:`mapping`. Each mapping item is added to the new "
|
||
"dictionary. Later values replace values already set by earlier key/datum "
|
||
"pairs and earlier dictionary unpackings."
|
||
msgstr ""
|
||
"Une double astérisque ``**`` demande de :dfn:`dépaqueter le dictionnaire`. "
|
||
"L'opérande doit être un :term:`tableau de correspondances <mapping>`. Chaque "
|
||
"élément du tableau de correspondances est ajouté au nouveau dictionnaire. "
|
||
"Les valeurs les plus récentes remplacent les valeurs déjà définies par des "
|
||
"couples clés-valeurs antérieurs ou par d'autres dépaquetages de "
|
||
"dictionnaires antérieurs."
|
||
|
||
#: reference/expressions.rst:326
|
||
msgid "Unpacking into dictionary displays, originally proposed by :pep:`448`."
|
||
msgstr ""
|
||
"le dépaquetage peut se faire vers un agencement de dictionnaire, proposé à "
|
||
"l'origine par la :pep:`448`."
|
||
|
||
#: reference/expressions.rst:329
|
||
msgid ""
|
||
"A dict comprehension, in contrast to list and set comprehensions, needs two "
|
||
"expressions separated with a colon followed by the usual \"for\" and \"if\" "
|
||
"clauses. When the comprehension is run, the resulting key and value elements "
|
||
"are inserted in the new dictionary in the order they are produced."
|
||
msgstr ""
|
||
"Une compréhension de dictionnaire, au contraire des compréhensions de listes "
|
||
"ou d'ensembles, requiert deux expressions séparées par une virgule et "
|
||
"suivies par les clauses usuelles \"for\" et \"if\". Quand la compréhension "
|
||
"est exécutée, les éléments clés-valeurs sont insérés dans le nouveau "
|
||
"dictionnaire dans l'ordre dans lequel ils sont produits."
|
||
|
||
#: reference/expressions.rst:337
|
||
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 "
|
||
"excludes all mutable objects.) Clashes between duplicate keys are not "
|
||
"detected; the last datum (textually rightmost in the display) stored for a "
|
||
"given key value prevails."
|
||
msgstr ""
|
||
"Les restrictions relatives aux types des clés sont données dans la section :"
|
||
"ref:`types` (pour résumer, le type de la clé doit être :term:`hachable "
|
||
"<hashable>`, ce qui exclut tous les objets muables). Les collisions entre "
|
||
"les clés dupliquées ne sont pas détectées ; la dernière valeur (celle qui "
|
||
"apparaît le plus à droite dans l'agencement) stockée prévaut pour une clé "
|
||
"donnée."
|
||
|
||
#: reference/expressions.rst:343
|
||
msgid ""
|
||
"Prior to Python 3.8, in dict comprehensions, the evaluation order of key and "
|
||
"value was not well-defined. In CPython, the value was evaluated before the "
|
||
"key. Starting with 3.8, the key is evaluated before the value, as proposed "
|
||
"by :pep:`572`."
|
||
msgstr ""
|
||
"Avant Python 3.8, dans les compréhensions de dictionnaires, l'ordre "
|
||
"d'évaluation entre les clés et les valeurs n'était pas bien défini. Dans "
|
||
"CPython, la valeur était évaluée avant la clé. À partir de la version 3.8, "
|
||
"la clé est évaluée avant la valeur, comme proposé par la :pep:`572`."
|
||
|
||
#: reference/expressions.rst:353
|
||
msgid "Generator expressions"
|
||
msgstr "Expressions génératrices"
|
||
|
||
#: reference/expressions.rst:360
|
||
msgid "A generator expression is a compact generator notation in parentheses:"
|
||
msgstr ""
|
||
"Une expression génératrice est une notation concise pour un générateur, "
|
||
"entourée de parenthèses :"
|
||
|
||
#: reference/expressions.rst:365
|
||
msgid ""
|
||
"A generator expression yields a new generator object. Its syntax is the "
|
||
"same as for comprehensions, except that it is enclosed in parentheses "
|
||
"instead of brackets or curly braces."
|
||
msgstr ""
|
||
"Une expression génératrice produit un nouvel objet générateur. Sa syntaxe "
|
||
"est la même que celle des compréhensions, sauf qu'elle est entourée de "
|
||
"parenthèses au lieu de crochets ou d'accolades."
|
||
|
||
#: reference/expressions.rst:369
|
||
msgid ""
|
||
"Variables used in the generator expression are evaluated lazily when the :"
|
||
"meth:`~generator.__next__` method is called for the generator object (in the "
|
||
"same fashion as normal generators). However, the iterable expression in the "
|
||
"leftmost :keyword:`!for` clause is immediately evaluated, so that an error "
|
||
"produced by it will be emitted at the point where the generator expression "
|
||
"is defined, rather than at the point where the first value is retrieved. "
|
||
"Subsequent :keyword:`!for` clauses and any filter condition in the leftmost :"
|
||
"keyword:`!for` clause cannot be evaluated in the enclosing scope as they may "
|
||
"depend on the values obtained from the leftmost iterable. For example: "
|
||
"``(x*y for x in range(10) for y in range(x, x+10))``."
|
||
msgstr ""
|
||
"Les variables utilisées dans une expression génératrice sont évaluées "
|
||
"paresseusement, au moment où la méthode :meth:`~generator.__next__` de "
|
||
"l'objet générateur est appelée (de la même manière que pour les générateurs "
|
||
"classiques). Cependant, l'expression de l'itérable dans la clause :keyword:`!"
|
||
"for` la plus à gauche est immédiatement évaluée, de manière à ce qu'une "
|
||
"erreur dans cette partie soit signalée à l'endroit où l'expression "
|
||
"génératrice est définie plutôt qu'à l'endroit où la première valeur est "
|
||
"récupérée. Les clauses :keyword:`!for` suivantes ne peuvent pas être "
|
||
"évaluées dans la portée implicite imbriquée car elles peuvent dépendre de "
|
||
"valeurs obtenues à partir de boucles :keyword:`!for` plus à gauche. Par "
|
||
"exemple, ``(x*y for x in range(10) for y in range(x, x+10))``."
|
||
|
||
#: reference/expressions.rst:380
|
||
msgid ""
|
||
"The parentheses can be omitted on calls with only one argument. See "
|
||
"section :ref:`calls` for details."
|
||
msgstr ""
|
||
"Les parenthèses peuvent être omises pour les appels qui ne possèdent qu'un "
|
||
"seul argument. Voir la section :ref:`calls` pour les détails."
|
||
|
||
#: reference/expressions.rst:383
|
||
msgid ""
|
||
"To avoid interfering with the expected operation of the generator expression "
|
||
"itself, ``yield`` and ``yield from`` expressions are prohibited in the "
|
||
"implicitly defined generator."
|
||
msgstr ""
|
||
"Pour éviter d'interférer avec l'opération attendue de l'expression "
|
||
"génératrice elle-même, les expressions ``yield`` et ``yield from`` sont "
|
||
"interdites dans les générateurs définis de manière implicite."
|
||
|
||
#: reference/expressions.rst:387
|
||
msgid ""
|
||
"If a generator expression contains either :keyword:`!async for` clauses or :"
|
||
"keyword:`await` expressions it is called an :dfn:`asynchronous generator "
|
||
"expression`. An asynchronous generator expression returns a new "
|
||
"asynchronous generator object, which is an asynchronous iterator (see :ref:"
|
||
"`async-iterators`)."
|
||
msgstr ""
|
||
"Si une expression génératrice contient une ou des expressions :keyword:`!"
|
||
"async for` ou :keyword:`await`, elle est appelée :dfn:`expression "
|
||
"génératrice asynchrone <asynchronous generator expression>`. Une expression "
|
||
"génératrice asynchrone produit un nouvel objet générateur asynchrone qui est "
|
||
"un itérateur asynchrone (voir :ref:`async-iterators`)."
|
||
|
||
#: reference/expressions.rst:393
|
||
msgid "Asynchronous generator expressions were introduced."
|
||
msgstr "les expressions génératrices asynchrones ont été introduites."
|
||
|
||
#: reference/expressions.rst:396
|
||
msgid ""
|
||
"Prior to Python 3.7, asynchronous generator expressions could only appear "
|
||
"in :keyword:`async def` coroutines. Starting with 3.7, any function can use "
|
||
"asynchronous generator expressions."
|
||
msgstr ""
|
||
"Avant Python 3.7, les expressions génératrices asynchrones ne pouvaient "
|
||
"apparaître que dans les coroutines :keyword:`async def`. À partir de la "
|
||
"version 3.7, toute fonction peut utiliser des expressions génératrices "
|
||
"asynchrones."
|
||
|
||
#: reference/expressions.rst:408
|
||
msgid "Yield expressions"
|
||
msgstr "Expressions ``yield``"
|
||
|
||
#: reference/expressions.rst:420
|
||
msgid ""
|
||
"The yield expression is used when defining a :term:`generator` function or "
|
||
"an :term:`asynchronous generator` function and thus can only be used in the "
|
||
"body of a function definition. Using a yield expression in a function's "
|
||
"body causes that function to be a generator, and using it in an :keyword:"
|
||
"`async def` function's body causes that coroutine function to be an "
|
||
"asynchronous generator. For example::"
|
||
msgstr ""
|
||
"Une expression ``yield`` est utilisée pour définir une fonction :term:"
|
||
"`générateur` ou une fonction :term:`génératrice asynchrone <asynchronous "
|
||
"generator>` et ne peut donc être utilisée que dans le corps de la définition "
|
||
"d'une fonction. L'utilisation d'une expression ``yield`` dans le corps d'une "
|
||
"fonction entraîne que cette fonction devient un générateur et son "
|
||
"utilisation dans le corps d'une fonction :keyword:`async def` entraine que "
|
||
"cette fonction coroutine devient un générateur asynchrone. Par exemple ::"
|
||
|
||
#: reference/expressions.rst:433
|
||
msgid ""
|
||
"Due to their side effects on the containing scope, ``yield`` expressions are "
|
||
"not permitted as part of the implicitly defined scopes used to implement "
|
||
"comprehensions and generator expressions."
|
||
msgstr ""
|
||
"En raison des effets de bords sur la portée contenant, les expressions "
|
||
"``yield`` ne sont pas autorisées dans la portée implicite utilisée dans "
|
||
"l'implémentation des compréhensions et des expressions génératrices."
|
||
|
||
#: reference/expressions.rst:437
|
||
msgid ""
|
||
"Yield expressions prohibited in the implicitly nested scopes used to "
|
||
"implement comprehensions and generator expressions."
|
||
msgstr ""
|
||
"Les expressions `yield` sont interdites dans la portée implicite imbriquée "
|
||
"utilisée dans l'implémentation des compréhensions et des expressions "
|
||
"génératrices."
|
||
|
||
#: reference/expressions.rst:441
|
||
msgid ""
|
||
"Generator functions are described below, while asynchronous generator "
|
||
"functions are described separately in section :ref:`asynchronous-generator-"
|
||
"functions`."
|
||
msgstr ""
|
||
"Les fonctions génératrices sont décrites plus loin alors que les fonctions "
|
||
"générateurs asynchrones sont décrites séparément dans la section :ref:"
|
||
"`asynchronous-generator-functions`."
|
||
|
||
#: reference/expressions.rst:445
|
||
msgid ""
|
||
"When a generator function is called, it returns an iterator known as a "
|
||
"generator. That generator then controls the execution of the generator "
|
||
"function. The execution starts when one of the generator's methods is "
|
||
"called. At that time, the execution proceeds to the first yield expression, "
|
||
"where it is suspended again, returning the value of :token:`expression_list` "
|
||
"to the generator's caller. By suspended, we mean that all local state is "
|
||
"retained, including the current bindings of local variables, the instruction "
|
||
"pointer, the internal evaluation stack, and the state of any exception "
|
||
"handling. When the execution is resumed by calling one of the generator's "
|
||
"methods, the function can proceed exactly as if the yield expression were "
|
||
"just another external call. The value of the yield expression after "
|
||
"resuming depends on the method which resumed the execution. If :meth:"
|
||
"`~generator.__next__` is used (typically via either a :keyword:`for` or the :"
|
||
"func:`next` builtin) then the result is :const:`None`. Otherwise, if :meth:"
|
||
"`~generator.send` is used, then the result will be the value passed in to "
|
||
"that method."
|
||
msgstr ""
|
||
"Lorsqu'une fonction génératrice est appelée, elle renvoie un itérateur que "
|
||
"l'on appelle générateur. Ce générateur contrôle l'exécution de la fonction "
|
||
"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:"
|
||
"`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 (typiquement *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:464
|
||
msgid ""
|
||
"All of this makes generator functions quite similar to coroutines; they "
|
||
"yield multiple times, they have more than one entry point and their "
|
||
"execution can be suspended. The only difference is that a generator "
|
||
"function cannot control where the execution should continue after it yields; "
|
||
"the control is always transferred to the generator's caller."
|
||
msgstr ""
|
||
"Tout ceci rend les fonctions génératrices très similaires aux coroutines : "
|
||
"elles produisent plusieurs objets *via* des expressions ``yield``, elles "
|
||
"possèdent plus qu'un seul point d'entrée et leur exécution peut être "
|
||
"suspendue. La seule différence est qu'une fonction génératrice ne peut pas "
|
||
"contrôler où l'exécution doit se poursuivre après une instruction "
|
||
"``yield`` ; ce contrôle est toujours du ressort de l'appelant au générateur."
|
||
|
||
#: reference/expressions.rst:470
|
||
msgid ""
|
||
"Yield expressions are allowed anywhere in a :keyword:`try` construct. If "
|
||
"the generator is not resumed before it is finalized (by reaching a zero "
|
||
"reference count or by being garbage collected), the generator-iterator's :"
|
||
"meth:`~generator.close` method will be called, allowing any pending :keyword:"
|
||
"`finally` clauses to execute."
|
||
msgstr ""
|
||
"Les expressions ``yield`` sont autorisées partout dans un bloc :keyword:"
|
||
"`try`. Si l'exécution du générateur ne reprend pas avant qu'il ne soit "
|
||
"finalisé (parce que son compteur de référence est tombé à zéro ou parce "
|
||
"qu'il est nettoyé par le ramasse-miettes), la méthode :meth:`~generator."
|
||
"close` du générateur-itérateur est appelée, ce qui permet l'exécution de "
|
||
"toutes les clauses :keyword:`finally` en attente."
|
||
|
||
#: reference/expressions.rst:479
|
||
#, fuzzy
|
||
msgid ""
|
||
"When ``yield from <expr>`` is used, the supplied expression must be an "
|
||
"iterable. The values produced by iterating that iterable are passed directly "
|
||
"to the caller of the current generator's methods. Any values passed in with :"
|
||
"meth:`~generator.send` and any exceptions passed in with :meth:`~generator."
|
||
"throw` are passed to the underlying iterator if it has the appropriate "
|
||
"methods. If this is not the case, then :meth:`~generator.send` will raise :"
|
||
"exc:`AttributeError` or :exc:`TypeError`, while :meth:`~generator.throw` "
|
||
"will just raise the passed in exception immediately."
|
||
msgstr ""
|
||
"L'utilisation de ``yield from <expr>`` traite l'expression passée en "
|
||
"paramètre comme un sous-itérateur. Toutes les valeurs produites par ce sous-"
|
||
"itérateur sont directement passées à l'appelant des méthodes du générateur "
|
||
"courant. Toute valeur passée par :meth:`~generator.send` ou toute exception "
|
||
"passée par :meth:`~generator.throw` est transmise à l'itérateur sous-jacent "
|
||
"s'il possède les méthodes appropriées. Si ce n'est pas le cas, alors :meth:"
|
||
"`~generator.send` lève une :exc:`AttributeError` ou une :exc:`TypeError`, "
|
||
"alors que :meth:`~generator.throw` ne fait que propager l'exception "
|
||
"immédiatement."
|
||
|
||
#: reference/expressions.rst:488
|
||
msgid ""
|
||
"When the underlying iterator is complete, the :attr:`~StopIteration.value` "
|
||
"attribute of the raised :exc:`StopIteration` instance becomes the value of "
|
||
"the yield expression. It can be either set explicitly when raising :exc:"
|
||
"`StopIteration`, or automatically when the subiterator is a generator (by "
|
||
"returning a value from the subgenerator)."
|
||
msgstr ""
|
||
"Quand l'itérateur sous-jacent a terminé, l'attribut :attr:`~StopIteration."
|
||
"value` de l'instance :exc:`StopIteration` qui a été levée devient la valeur "
|
||
"produite par l'expression ``yield``. Elle peut être définie explicitement "
|
||
"quand vous levez :exc:`StopIteration` ou automatiquement que le sous-"
|
||
"itérateur est un générateur (en renvoyant une valeur par le sous-générateur)."
|
||
|
||
#: reference/expressions.rst:494
|
||
msgid "Added ``yield from <expr>`` to delegate control flow to a subiterator."
|
||
msgstr ""
|
||
"``yield from <expr>`` a été ajoutée pour déléguer le contrôle du flot "
|
||
"d'exécution à un sous-itérateur."
|
||
|
||
#: reference/expressions.rst:497
|
||
msgid ""
|
||
"The parentheses may be omitted when the yield expression is the sole "
|
||
"expression on the right hand side of an assignment statement."
|
||
msgstr ""
|
||
"Les parenthèses peuvent être omises quand l'expression ``yield`` est la "
|
||
"seule expression à droite de l'instruction de l'instruction d'assignation."
|
||
|
||
#: reference/expressions.rst:503
|
||
msgid ":pep:`255` - Simple Generators"
|
||
msgstr ":pep:`255` : Générateurs simples"
|
||
|
||
#: reference/expressions.rst:503
|
||
msgid ""
|
||
"The proposal for adding generators and the :keyword:`yield` statement to "
|
||
"Python."
|
||
msgstr ""
|
||
"La proposition d'ajouter à Python des générateurs et l'instruction :keyword:"
|
||
"`yield`."
|
||
|
||
#: reference/expressions.rst:507
|
||
msgid ":pep:`342` - Coroutines via Enhanced Generators"
|
||
msgstr ":pep:`342` -- Coroutines *via* des générateurs améliorés"
|
||
|
||
#: reference/expressions.rst:506
|
||
msgid ""
|
||
"The proposal to enhance the API and syntax of generators, making them usable "
|
||
"as simple coroutines."
|
||
msgstr ""
|
||
"Proposition d'améliorer l'API et la syntaxe des générateurs, de manière à "
|
||
"pouvoir les utiliser comme de simples coroutines."
|
||
|
||
#: reference/expressions.rst:511
|
||
msgid ":pep:`380` - Syntax for Delegating to a Subgenerator"
|
||
msgstr ":pep:`380` -- Syntaxe pour déléguer à un sous-générateur"
|
||
|
||
#: reference/expressions.rst:510
|
||
msgid ""
|
||
"The proposal to introduce the :token:`yield_from` syntax, making delegation "
|
||
"to subgenerators easy."
|
||
msgstr ""
|
||
"Proposition d'introduire la syntaxe :token:`yield_from`, de manière à "
|
||
"déléguer facilement l'exécution à un sous-générateur."
|
||
|
||
#: reference/expressions.rst:514
|
||
msgid ":pep:`525` - Asynchronous Generators"
|
||
msgstr ":pep:`525` : Générateurs asynchrones"
|
||
|
||
#: reference/expressions.rst:514
|
||
msgid ""
|
||
"The proposal that expanded on :pep:`492` by adding generator capabilities to "
|
||
"coroutine functions."
|
||
msgstr ""
|
||
"La proposition qui a amélioré la :pep:`492` en ajoutant des capacités de "
|
||
"générateur pour les coroutines."
|
||
|
||
#: reference/expressions.rst:521
|
||
msgid "Generator-iterator methods"
|
||
msgstr "Méthodes des générateurs-itérateurs"
|
||
|
||
#: reference/expressions.rst:523
|
||
msgid ""
|
||
"This subsection describes the methods of a generator iterator. They can be "
|
||
"used to control the execution of a generator function."
|
||
msgstr ""
|
||
"Cette sous-section décrit les méthodes des générateurs-itérateurs. Elles "
|
||
"peuvent être utilisées pour contrôler l'exécution des fonctions générateurs."
|
||
|
||
#: reference/expressions.rst:526
|
||
msgid ""
|
||
"Note that calling any of the generator methods below when the generator is "
|
||
"already executing raises a :exc:`ValueError` exception."
|
||
msgstr ""
|
||
"Notez que l'appel à une méthode ci-dessous d'un générateur alors que le "
|
||
"générateur est déjà en cours d'exécution lève une exception :exc:"
|
||
"`ValueError`."
|
||
|
||
#: reference/expressions.rst:534
|
||
msgid ""
|
||
"Starts the execution of a generator function or resumes it at the last "
|
||
"executed yield expression. When a generator function is resumed with a :"
|
||
"meth:`~generator.__next__` method, the current yield expression always "
|
||
"evaluates to :const:`None`. The execution then continues to the next yield "
|
||
"expression, where the generator is suspended again, and the value of the :"
|
||
"token:`expression_list` is returned to :meth:`__next__`'s caller. If the "
|
||
"generator exits without yielding another value, a :exc:`StopIteration` "
|
||
"exception is raised."
|
||
msgstr ""
|
||
"Démarre l'exécution d'une fonction générateur ou la reprend à la dernière "
|
||
"expression ``yield`` exécutée. Quand une fonction générateur est reprise par "
|
||
"une méthode :meth:`~generator.__next__`, l'expression ``yield`` en cours "
|
||
"s'évalue toujours à :const:`None`. L'exécution continue ensuite jusqu'à "
|
||
"l'expression ``yield`` suivante, où le générateur est à nouveau suspendu et "
|
||
"la valeur de :token:`expression_list` est renvoyée à la méthode :meth:"
|
||
"`__next__` de l'appelant. Si le générateur termine sans donner une autre "
|
||
"valeur, une exception :exc:`StopIteration` est levée."
|
||
|
||
#: reference/expressions.rst:543
|
||
msgid ""
|
||
"This method is normally called implicitly, e.g. by a :keyword:`for` loop, or "
|
||
"by the built-in :func:`next` function."
|
||
msgstr ""
|
||
"Cette méthode est normalement appelée implicitement, par exemple par une "
|
||
"boucle :keyword:`for` ou par la fonction native :func:`next`."
|
||
|
||
#: reference/expressions.rst:549
|
||
msgid ""
|
||
"Resumes the execution and \"sends\" a value into the generator function. "
|
||
"The *value* argument becomes the result of the current yield expression. "
|
||
"The :meth:`send` method returns the next value yielded by the generator, or "
|
||
"raises :exc:`StopIteration` if the generator exits without yielding another "
|
||
"value. When :meth:`send` is called to start the generator, it must be "
|
||
"called with :const:`None` as the argument, because there is no yield "
|
||
"expression that could receive the value."
|
||
msgstr ""
|
||
"Reprend l'exécution et « envoie » une valeur à la fonction générateur. "
|
||
"L'argument *value* devient le résultat de l'expression ``yield`` courante. "
|
||
"La méthode :meth:`send` renvoie la valeur suivante produite par le "
|
||
"générateur ou lève :exc:`StopIteration` si le générateur termine sans "
|
||
"produire de nouvelle valeur. Quand :meth:`send` est utilisée pour démarrer "
|
||
"le générateur, elle doit avoir :const:`None` comme argument, car il n'y a "
|
||
"aucune expression ``yield`` qui peut recevoir la valeur."
|
||
|
||
#: reference/expressions.rst:560
|
||
msgid ""
|
||
"Raises an exception of type ``type`` at the point where the generator was "
|
||
"paused, and returns the next value yielded by the generator function. If "
|
||
"the generator exits without yielding another value, a :exc:`StopIteration` "
|
||
"exception is raised. If the generator function does not catch the passed-in "
|
||
"exception, or raises a different exception, then that exception propagates "
|
||
"to the caller."
|
||
msgstr ""
|
||
"Lève une exception de type ``type`` à l'endroit où le générateur est en "
|
||
"pause et renvoie la valeur suivante produite par la fonction générateur. Si "
|
||
"le générateur termine sans produire de nouvelle valeur, une exception :exc:"
|
||
"`StopIteration` est levée. Si la fonction génératrice ne gère pas "
|
||
"l'exception passée ou lève une autre exception, alors cette exception est "
|
||
"propagée vers l'appelant."
|
||
|
||
#: reference/expressions.rst:571
|
||
msgid ""
|
||
"Raises a :exc:`GeneratorExit` at the point where the generator function was "
|
||
"paused. If the generator function then exits gracefully, is already closed, "
|
||
"or raises :exc:`GeneratorExit` (by not catching the exception), close "
|
||
"returns to its caller. If the generator yields a value, a :exc:"
|
||
"`RuntimeError` is raised. If the generator raises any other exception, it "
|
||
"is propagated to the caller. :meth:`close` does nothing if the generator "
|
||
"has already exited due to an exception or normal exit."
|
||
msgstr ""
|
||
"Lève une :exc:`GeneratorExit` à l'endroit où la fonction génératrice a été "
|
||
"mise en pause. Si la fonction génératrice termine, est déjà fermée ou lève :"
|
||
"exc:`GeneratorExit` (parce qu'elle ne gère pas l'exception), *close* revient "
|
||
"vers l'appelant. Si le générateur produit une valeur, une :exc:"
|
||
"`RuntimeError` est levée. Si le générateur lève une autre exception, elle "
|
||
"est propagée à l'appelant. La méthode :meth:`close` ne fait rien si le "
|
||
"générateur a déjà terminé en raison d'une exception ou d'une fin normale."
|
||
|
||
#: reference/expressions.rst:582
|
||
msgid "Examples"
|
||
msgstr "Exemples"
|
||
|
||
#: reference/expressions.rst:584
|
||
msgid ""
|
||
"Here is a simple example that demonstrates the behavior of generators and "
|
||
"generator functions::"
|
||
msgstr ""
|
||
"Voici un exemple simple qui montre le comportement des générateurs et des "
|
||
"fonctions génératrices ::"
|
||
|
||
#: reference/expressions.rst:611
|
||
msgid ""
|
||
"For examples using ``yield from``, see :ref:`pep-380` in \"What's New in "
|
||
"Python.\""
|
||
msgstr ""
|
||
"Pour des exemples d'utilisation de ``yield from``, lisez la :ref:`pep-380` "
|
||
"dans « Les nouveautés de Python »."
|
||
|
||
#: reference/expressions.rst:617
|
||
msgid "Asynchronous generator functions"
|
||
msgstr "Fonctions génératrices asynchrones"
|
||
|
||
#: reference/expressions.rst:619
|
||
msgid ""
|
||
"The presence of a yield expression in a function or method defined using :"
|
||
"keyword:`async def` further defines the function as an :term:`asynchronous "
|
||
"generator` function."
|
||
msgstr ""
|
||
"La présence d'une expression *yield* dans une fonction ou une méthode "
|
||
"définie en utilisant :keyword:`async def` transforme cette fonction en "
|
||
"fonction :term:`générateur asynchrone <asynchronous generator>`."
|
||
|
||
#: reference/expressions.rst:623
|
||
msgid ""
|
||
"When an asynchronous generator function is called, it returns an "
|
||
"asynchronous iterator known as an asynchronous generator object. That object "
|
||
"then controls the execution of the generator function. An asynchronous "
|
||
"generator object is typically used in an :keyword:`async for` statement in a "
|
||
"coroutine function analogously to how a generator object would be used in a :"
|
||
"keyword:`for` statement."
|
||
msgstr ""
|
||
"Quand une fonction génératrice asynchrone est appelée, elle renvoie un "
|
||
"itérateur asynchrone, autrement appelé objet générateur asynchrone. Cet "
|
||
"objet contrôle l'exécution de la fonction génératrice. Un objet générateur "
|
||
"asynchrone est typiquement utilisé dans une instruction :keyword:`async for` "
|
||
"à l'intérieur d'une fonction coroutine de la même manière qu'un objet "
|
||
"générateur serait utilisé dans une instruction :keyword:`for`."
|
||
|
||
#: reference/expressions.rst:630
|
||
msgid ""
|
||
"Calling one of the asynchronous generator's methods returns an :term:"
|
||
"`awaitable` object, and the execution starts when this object is awaited on. "
|
||
"At that time, the execution proceeds to the first yield expression, where it "
|
||
"is suspended again, returning the value of :token:`expression_list` to the "
|
||
"awaiting coroutine. As with a generator, suspension means that all local "
|
||
"state is retained, including the current bindings of local variables, the "
|
||
"instruction pointer, the internal evaluation stack, and the state of any "
|
||
"exception handling. When the execution is resumed by awaiting on the next "
|
||
"object returned by the asynchronous generator's methods, the function can "
|
||
"proceed exactly as if the yield expression were just another external call. "
|
||
"The value of the yield expression after resuming depends on the method which "
|
||
"resumed the execution. If :meth:`~agen.__anext__` is used then the result "
|
||
"is :const:`None`. Otherwise, if :meth:`~agen.asend` is used, then the result "
|
||
"will be the value passed in to that method."
|
||
msgstr ""
|
||
"L'appel d'une méthode du générateur asynchrone renvoie un objet :term:"
|
||
"`awaitable` et l'exécution commence au moment où l'on atteint une "
|
||
"instruction ``await`` le concernant. À ce moment, l'exécution se déroule "
|
||
"jusqu'à la première expression ``yield``, où elle est suspendue et renvoie "
|
||
"la valeur de :token:`expression_list` à la coroutine en attente. Comme pour "
|
||
"un générateur, la suspension signifie que tous les états locaux sont "
|
||
"conservés, y compris les liaisons 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 parce que l'appelant "
|
||
"a atteint une instruction ``await`` sur l'objet suivant retourné par les "
|
||
"méthodes du générateur asynchrone, 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`` au moment de la reprise dépend de la méthode qui a "
|
||
"relancé l'exécution. Si c'est :meth:`~agen.__anext__` qui a été utilisée, "
|
||
"alors le résultat est :const:`None`. Sinon, si c'est :meth:`~agen.asend` qui "
|
||
"a été utilisée, alors le résultat est la valeur transmise à cette méthode."
|
||
|
||
#: reference/expressions.rst:646
|
||
msgid ""
|
||
"In an asynchronous generator function, yield expressions are allowed "
|
||
"anywhere in a :keyword:`try` construct. However, if an asynchronous "
|
||
"generator is not resumed before it is finalized (by reaching a zero "
|
||
"reference count or by being garbage collected), then a yield expression "
|
||
"within a :keyword:`!try` construct could result in a failure to execute "
|
||
"pending :keyword:`finally` clauses. In this case, it is the responsibility "
|
||
"of the event loop or scheduler running the asynchronous generator to call "
|
||
"the asynchronous generator-iterator's :meth:`~agen.aclose` method and run "
|
||
"the resulting coroutine object, thus allowing any pending :keyword:`!"
|
||
"finally` clauses to execute."
|
||
msgstr ""
|
||
"Dans une fonction génératrice asynchrone, les expressions ``yield`` sont "
|
||
"autorisées n'importe où dans une construction :keyword:`try`. Cependant, si "
|
||
"l'exécution d'un générateur asynchrone n'a pas repris avant que le "
|
||
"générateur ne soit finalisé (parce que son compteur de référence a atteint "
|
||
"zéro ou parce qu'il est nettoyé par le ramasse-miettes), alors une "
|
||
"expression ``yield`` dans une construction :keyword:`!try` pourrait ne pas "
|
||
"atteindre la clause :keyword:`finally` en attente. Dans ce cas, c'est la "
|
||
"responsabilité de la boucle d'événements ou du programmateur exécutant le "
|
||
"générateur asynchrone d'appeler la méthode :meth:`~agen.aclose` du "
|
||
"générateur asynchrone et d'exécuter l'objet coroutine résultant, permettant "
|
||
"ainsi à toute clause :keyword:`!finally` en attente d'être exécutée."
|
||
|
||
#: reference/expressions.rst:657
|
||
msgid ""
|
||
"To take care of finalization, an event loop should define a *finalizer* "
|
||
"function which takes an asynchronous generator-iterator and presumably "
|
||
"calls :meth:`~agen.aclose` and executes the coroutine. This *finalizer* may "
|
||
"be registered by calling :func:`sys.set_asyncgen_hooks`. When first iterated "
|
||
"over, an asynchronous generator-iterator will store the registered "
|
||
"*finalizer* to be called upon finalization. For a reference example of a "
|
||
"*finalizer* method see the implementation of ``asyncio.Loop."
|
||
"shutdown_asyncgens`` in :source:`Lib/asyncio/base_events.py`."
|
||
msgstr ""
|
||
"Pour effectuer correctement la finalisation, une boucle d'événements doit "
|
||
"définir une fonction *finalizer* qui prend un générateur-itérateur "
|
||
"asynchrone, appelle sans doute :meth:`~agen.aclose` et exécute la coroutine. "
|
||
"Ce *finalizer* peut s'enregistrer en appelant :func:`sys."
|
||
"set_asyncgen_hooks`. Lors de la première itération, un générateur-itérateur "
|
||
"asynchrone stocke le *finalizer* enregistré à appeler lors de la "
|
||
"finalisation. Pour un exemple de référence relatif à une méthode de "
|
||
"*finalizer*, regardez l'implémentation de ``asyncio.Loop."
|
||
"shutdown_asyncgens`` dans :source:`Lib/asyncio/base_events.py`."
|
||
|
||
#: reference/expressions.rst:666
|
||
msgid ""
|
||
"The expression ``yield from <expr>`` is a syntax error when used in an "
|
||
"asynchronous generator function."
|
||
msgstr ""
|
||
"L'expression ``yield from <expr>`` produit une erreur de syntaxe quand elle "
|
||
"est utilisée dans une fonction génératrice asynchrone."
|
||
|
||
#: reference/expressions.rst:673
|
||
msgid "Asynchronous generator-iterator methods"
|
||
msgstr "Méthodes des générateurs-itérateurs asynchrones"
|
||
|
||
#: reference/expressions.rst:675
|
||
msgid ""
|
||
"This subsection describes the methods of an asynchronous generator iterator, "
|
||
"which are used to control the execution of a generator function."
|
||
msgstr ""
|
||
"Cette sous-section décrit les méthodes des générateurs-itérateurs "
|
||
"asynchrones. Elles sont utilisées pour contrôler l’exécution des fonctions "
|
||
"génératrices."
|
||
|
||
#: reference/expressions.rst:683
|
||
msgid ""
|
||
"Returns an awaitable which when run starts to execute the asynchronous "
|
||
"generator or resumes it at the last executed yield expression. When an "
|
||
"asynchronous generator function is resumed with an :meth:`~agen.__anext__` "
|
||
"method, the current yield expression always evaluates to :const:`None` in "
|
||
"the returned awaitable, which when run will continue to the next yield "
|
||
"expression. The value of the :token:`expression_list` of the yield "
|
||
"expression is the value of the :exc:`StopIteration` exception raised by the "
|
||
"completing coroutine. If the asynchronous generator exits without yielding "
|
||
"another value, the awaitable instead raises a :exc:`StopAsyncIteration` "
|
||
"exception, signalling that the asynchronous iteration has completed."
|
||
msgstr ""
|
||
"Renvoie un *awaitable* qui, quand il a la main, démarre l'exécution du "
|
||
"générateur asynchrone ou reprend son exécution à l'endroit de la dernière "
|
||
"expression ``yield`` exécutée. Quand une fonction générateur asynchrone est "
|
||
"reprise par une méthode :meth:`~agen.__anext__`, l’expression ``yield`` en "
|
||
"cours s’évalue toujours à :const:`None` dans le *awaitable* renvoyé, et elle "
|
||
"continue son exécution jusqu’à l’expression ``yield`` suivante. La valeur "
|
||
"de :token:`expression_list` de l'expression ``yield`` est la valeur de "
|
||
"l'exception :exc:`StopIteration` levée par la coroutine qui termine. Si le "
|
||
"générateur asynchrone termine sans produire d'autre valeur, le *awaitable* "
|
||
"lève une exception :exc:`StopAsyncIteration` qui signale que l'itération "
|
||
"asynchrone est terminée."
|
||
|
||
#: reference/expressions.rst:695
|
||
msgid ""
|
||
"This method is normally called implicitly by a :keyword:`async for` loop."
|
||
msgstr ""
|
||
"Cette méthode est normalement appelée implicitement par une boucle :keyword:"
|
||
"`async for`."
|
||
|
||
#: reference/expressions.rst:700
|
||
msgid ""
|
||
"Returns an awaitable which when run resumes the execution of the "
|
||
"asynchronous generator. As with the :meth:`~generator.send()` method for a "
|
||
"generator, this \"sends\" a value into the asynchronous generator function, "
|
||
"and the *value* argument becomes the result of the current yield expression. "
|
||
"The awaitable returned by the :meth:`asend` method will return the next "
|
||
"value yielded by the generator as the value of the raised :exc:"
|
||
"`StopIteration`, or raises :exc:`StopAsyncIteration` if the asynchronous "
|
||
"generator exits without yielding another value. When :meth:`asend` is "
|
||
"called to start the asynchronous generator, it must be called with :const:"
|
||
"`None` as the argument, because there is no yield expression that could "
|
||
"receive the value."
|
||
msgstr ""
|
||
"Renvoie un *awaitable* qui, lorsqu'il a la main, reprend l'exécution du "
|
||
"générateur asynchrone. Comme pour la méthode :meth:`~generator.send()` d'un "
|
||
"générateur, elle « envoie » une valeur *value* à la fonction générateur "
|
||
"asynchrone et cet argument devient le résultat de l'expression ``yield`` "
|
||
"courante. Le *awaitable* renvoyé par la méthode :meth:`asend` renvoie la "
|
||
"valeur suivante produite par le générateur comme valeur de l'exception :exc:"
|
||
"`StopIteration` levée ou lève :exc:`StopAsyncIteration` si le générateur "
|
||
"asynchrone termine sans produire de nouvelle valeur. Quand :meth:`asend` est "
|
||
"appelée pour démarrer le générateur asynchrone, l'argument doit être :const:"
|
||
"`None` car il n'y a pas d'expression ``yield`` pour recevoir la valeur."
|
||
|
||
#: reference/expressions.rst:715
|
||
msgid ""
|
||
"Returns an awaitable that raises an exception of type ``type`` at the point "
|
||
"where the asynchronous generator was paused, and returns the next value "
|
||
"yielded by the generator function as the value of the raised :exc:"
|
||
"`StopIteration` exception. If the asynchronous generator exits without "
|
||
"yielding another value, a :exc:`StopAsyncIteration` exception is raised by "
|
||
"the awaitable. If the generator function does not catch the passed-in "
|
||
"exception, or raises a different exception, then when the awaitable is run "
|
||
"that exception propagates to the caller of the awaitable."
|
||
msgstr ""
|
||
"Renvoie un *awaitable* qui lève une exception du type ``type`` à l'endroit "
|
||
"où le générateur asynchrone a été mis en pause et renvoie la valeur suivante "
|
||
"produite par la fonction génératrice comme valeur de l'exception :exc:"
|
||
"`StopIteration` qui a été levée. Si le générateur asynchrone termine sans "
|
||
"produire de nouvelle valeur, une exception :exc:`StopAsyncIteration` est "
|
||
"levée par le *awaitable*. Si la fonction génératrice ne traite pas "
|
||
"l'exception reçue ou lève une autre exception alors, quand le *awaitable* "
|
||
"est lancé, cette exception est propagée vers l'appelant du *awaitable*."
|
||
|
||
#: reference/expressions.rst:730
|
||
msgid ""
|
||
"Returns an awaitable that when run will throw a :exc:`GeneratorExit` into "
|
||
"the asynchronous generator function at the point where it was paused. If the "
|
||
"asynchronous generator function then exits gracefully, is already closed, or "
|
||
"raises :exc:`GeneratorExit` (by not catching the exception), then the "
|
||
"returned awaitable will raise a :exc:`StopIteration` exception. Any further "
|
||
"awaitables returned by subsequent calls to the asynchronous generator will "
|
||
"raise a :exc:`StopAsyncIteration` exception. If the asynchronous generator "
|
||
"yields a value, a :exc:`RuntimeError` is raised by the awaitable. If the "
|
||
"asynchronous generator raises any other exception, it is propagated to the "
|
||
"caller of the awaitable. If the asynchronous generator has already exited "
|
||
"due to an exception or normal exit, then further calls to :meth:`aclose` "
|
||
"will return an awaitable that does nothing."
|
||
msgstr ""
|
||
"Renvoie un *awaitable* qui, quand il s'exécute, lève une exception :exc:"
|
||
"`GeneratorExit` dans la fonction génératrice asynchrone à l'endroit où le "
|
||
"générateur était en pause. Si la fonction génératrice asynchrone termine "
|
||
"normalement, est déjà fermée ou lève :exc:`GeneratorExit` (parce qu'elle ne "
|
||
"gère pas l'exception), alors le *awaitable* renvoyé lève une exception :exc:"
|
||
"`StopIteration`. Tout nouveau *awaitable* produit par un appel postérieur au "
|
||
"générateur asynchrone lève une exception :exc:`StopAsyncIteration`. Si le "
|
||
"générateur asynchrone produit une valeur, une :exc:`RuntimeError` est levée "
|
||
"par le *awaitable*. Si le générateur asynchrone lève une autre exception, "
|
||
"elle est propagée à l'appelant du *awaitable*. Si le générateur asynchrone a "
|
||
"déjà terminé (soit par une exception, soit normalement), alors tout nouvel "
|
||
"appel à :meth:`aclose` renvoie un *awaitable* qui ne fait rien."
|
||
|
||
#: reference/expressions.rst:746
|
||
msgid "Primaries"
|
||
msgstr "Primaires"
|
||
|
||
#: reference/expressions.rst:750
|
||
msgid ""
|
||
"Primaries represent the most tightly bound operations of the language. Their "
|
||
"syntax is:"
|
||
msgstr ""
|
||
"Les primaires (*primary* dans la grammaire formelle ci-dessous) représentent "
|
||
"les opérations qui se lient au plus proche dans le langage. Leur syntaxe "
|
||
"est :"
|
||
|
||
#: reference/expressions.rst:760
|
||
msgid "Attribute references"
|
||
msgstr "Références à des attributs"
|
||
|
||
#: reference/expressions.rst:766
|
||
msgid "An attribute reference is a primary followed by a period and a name:"
|
||
msgstr ""
|
||
"Une référence à un attribut (*attributeref* dans la grammaire formelle ci-"
|
||
"dessous) est une primaire suivie par un point et un nom :"
|
||
|
||
#: reference/expressions.rst:776
|
||
msgid ""
|
||
"The primary must evaluate to an object of a type that supports attribute "
|
||
"references, which most objects do. This object is then asked to produce the "
|
||
"attribute whose name is the identifier. This production can be customized "
|
||
"by overriding the :meth:`__getattr__` method. If this attribute is not "
|
||
"available, the exception :exc:`AttributeError` is raised. Otherwise, the "
|
||
"type and value of the object produced is determined by the object. Multiple "
|
||
"evaluations of the same attribute reference may yield different objects."
|
||
msgstr ""
|
||
"La primaire doit s'évaluer à un objet d'un type qui gère les références aux "
|
||
"attributs, ce qui est le cas de la plupart des objets. Cet objet doit alors "
|
||
"produire l'attribut dont le nom est « identifier ». Cette production peut "
|
||
"être personnalisée en surchargeant la méthode :meth:`__getattr__`. Si "
|
||
"l'attribut n'est pas disponible, une exception :exc:`AttributeError` est "
|
||
"levée. Sinon, le type et la valeur de l'objet produit sont déterminés par "
|
||
"l'objet. Plusieurs évaluations successives d'une référence à un même "
|
||
"attribut peuvent produire différents objets."
|
||
|
||
#: reference/expressions.rst:788
|
||
msgid "Subscriptions"
|
||
msgstr "Sélections"
|
||
|
||
#: reference/expressions.rst:803
|
||
#, fuzzy
|
||
msgid ""
|
||
"Subscription of a sequence (string, tuple or list) or mapping (dictionary) "
|
||
"object usually selects an item from the collection:"
|
||
msgstr ""
|
||
"Une sélection (*subscription* dans la grammaire formelle ci-dessous) désigne "
|
||
"un élément dans un objet séquence (chaîne, *n*-uplet ou liste) ou tableau de "
|
||
"correspondances (dictionnaire) :"
|
||
|
||
#: reference/expressions.rst:809
|
||
msgid ""
|
||
"The primary must evaluate to an object that supports subscription (lists or "
|
||
"dictionaries for example). User-defined objects can support subscription by "
|
||
"defining a :meth:`__getitem__` method."
|
||
msgstr ""
|
||
"La primaire doit s'appliquer à un objet qui gère les sélections (une liste "
|
||
"ou un dictionnaire par exemple). Les objets définis par l'utilisateur "
|
||
"peuvent gérer les sélections en définissant une méthode :meth:`__getitem__`."
|
||
|
||
#: reference/expressions.rst:813
|
||
msgid ""
|
||
"For built-in objects, there are two types of objects that support "
|
||
"subscription:"
|
||
msgstr "Pour les objets natifs, deux types d'objets gèrent la sélection :"
|
||
|
||
#: reference/expressions.rst:815
|
||
msgid ""
|
||
"If the primary is a mapping, the expression list must evaluate to an object "
|
||
"whose value is one of the keys of the mapping, and the subscription selects "
|
||
"the value in the mapping that corresponds to that key. (The expression list "
|
||
"is a tuple except if it has exactly one item.)"
|
||
msgstr ""
|
||
"Si la primaire est un tableau de correspondances, la liste d'expressions "
|
||
"(*expression_list* dans la grammaire formelle ci-dessous) doit pouvoir être "
|
||
"évaluée comme un objet dont la valeur est une des clés du tableau de "
|
||
"correspondances et la sélection désigne la valeur qui correspond à cette clé "
|
||
"(la liste d'expressions est un *n*-uplet sauf si elle comporte exactement un "
|
||
"élément)."
|
||
|
||
#: reference/expressions.rst:820
|
||
msgid ""
|
||
"If the primary is a sequence, the expression list must evaluate to an "
|
||
"integer or a slice (as discussed in the following section)."
|
||
msgstr ""
|
||
"Si la primaire est une séquence, la liste d'expressions (*expression_list* "
|
||
"dans la grammaire) doit pouvoir être évaluée comme un entier ou une tranche "
|
||
"(comme expliqué dans la section suivante)."
|
||
|
||
#: reference/expressions.rst:823
|
||
msgid ""
|
||
"The formal syntax makes no special provision for negative indices in "
|
||
"sequences; however, built-in sequences all provide a :meth:`__getitem__` "
|
||
"method that interprets negative indices by adding the length of the sequence "
|
||
"to the index (so that ``x[-1]`` selects the last item of ``x``). The "
|
||
"resulting value must be a nonnegative integer less than the number of items "
|
||
"in the sequence, and the subscription selects the item whose index is that "
|
||
"value (counting from zero). Since the support for negative indices and "
|
||
"slicing occurs in the object's :meth:`__getitem__` method, subclasses "
|
||
"overriding this method will need to explicitly add that support."
|
||
msgstr ""
|
||
"La syntaxe formelle ne traite pas des cas d'indices négatifs dans les "
|
||
"séquences ; cependant, toutes les séquences natives possèdent une méthode :"
|
||
"meth:`__getitem__` qui interprète les indices négatifs en ajoutant la "
|
||
"longueur de la séquence à l'indice (de manière à ce que ``x[-1]`` "
|
||
"sélectionne le dernier élément de ``x``). La valeur résultante doit être un "
|
||
"entier positif ou nul, inférieur au nombre d'éléments dans la séquence ; la "
|
||
"sélection désigne alors l'élément dont l'indice est cette valeur (en "
|
||
"comptant à partir de zéro). Comme la gestion des indices négatifs et des "
|
||
"tranches est faite par la méthode :meth:`__getitem__`, les sous-classes qui "
|
||
"surchargent cette méthode doivent aussi savoir les gérer, de manière "
|
||
"explicite."
|
||
|
||
#: reference/expressions.rst:837
|
||
msgid ""
|
||
"A string's items are characters. A character is not a separate data type "
|
||
"but a string of exactly one character."
|
||
msgstr ""
|
||
"Les éléments des chaînes sont des caractères. Un caractère n'est pas un type "
|
||
"en tant que tel, c'est une chaîne de longueur un."
|
||
|
||
#: reference/expressions.rst:840
|
||
msgid ""
|
||
"Subscription of certain :term:`classes <class>` or :term:`types <type>` "
|
||
"creates a :ref:`generic alias <types-genericalias>`. In this case, user-"
|
||
"defined classes can support subscription by providing a :meth:"
|
||
"`__class_getitem__` classmethod."
|
||
msgstr ""
|
||
|
||
#: reference/expressions.rst:849
|
||
msgid "Slicings"
|
||
msgstr "Tranches"
|
||
|
||
#: reference/expressions.rst:863
|
||
msgid ""
|
||
"A slicing selects a range of items in a sequence object (e.g., a string, "
|
||
"tuple or list). Slicings may be used as expressions or as targets in "
|
||
"assignment or :keyword:`del` statements. The syntax for a slicing:"
|
||
msgstr ""
|
||
"Une tranche (*slicing* dans la grammaire formelle ci-dessous) sélectionne un "
|
||
"intervalle d'éléments d'un objet séquence (par exemple une chaîne, un n-"
|
||
"uplet ou une liste, respectivement les types *string*, *tuple* et *list*). "
|
||
"Les tranches peuvent être utilisées comme des expressions ou des cibles dans "
|
||
"les assignations ou les instructions :keyword:`del`. La syntaxe est la "
|
||
"suivante :"
|
||
|
||
#: reference/expressions.rst:876
|
||
msgid ""
|
||
"There is ambiguity in the formal syntax here: anything that looks like an "
|
||
"expression list also looks like a slice list, so any subscription can be "
|
||
"interpreted as a slicing. Rather than further complicating the syntax, this "
|
||
"is disambiguated by defining that in this case the interpretation as a "
|
||
"subscription takes priority over the interpretation as a slicing (this is "
|
||
"the case if the slice list contains no proper slice)."
|
||
msgstr ""
|
||
"Il existe une ambigüité dans la syntaxe formelle ci-dessus : tout ce qui "
|
||
"ressemble à une liste d'expressions (*expression_list* vue avant) ressemble "
|
||
"aussi à une liste de tranches (*slice_list* dans la grammaire ci-dessus). En "
|
||
"conséquence, toute sélection (*subscription* dans la grammaire) peut être "
|
||
"interprétée comme une tranche. Plutôt que de compliquer encore la syntaxe, "
|
||
"l'ambigüité est levée en disant que, dans ce cas, l'interprétation en tant "
|
||
"que sélection (*subscription*) est prioritaire sur l'interprétation en tant "
|
||
"que tranche (c'est le cas si la liste de tranches (*slice_list*) ne contient "
|
||
"aucune tranche en tant que telle)."
|
||
|
||
#: reference/expressions.rst:888
|
||
msgid ""
|
||
"The semantics for a slicing are as follows. The primary is indexed (using "
|
||
"the same :meth:`__getitem__` method as normal subscription) with a key that "
|
||
"is constructed from the slice list, as follows. If the slice list contains "
|
||
"at least one comma, the key is a tuple containing the conversion of the "
|
||
"slice items; otherwise, the conversion of the lone slice item is the key. "
|
||
"The conversion of a slice item that is an expression is that expression. "
|
||
"The conversion of a proper slice is a slice object (see section :ref:"
|
||
"`types`) whose :attr:`~slice.start`, :attr:`~slice.stop` and :attr:`~slice."
|
||
"step` attributes are the values of the expressions given as lower bound, "
|
||
"upper bound and stride, respectively, substituting ``None`` for missing "
|
||
"expressions."
|
||
msgstr ""
|
||
"La sémantique pour une tranche est définie comme suit. La primaire est "
|
||
"indicée (en utilisant la même méthode :meth:`__getitem__` que pour les "
|
||
"sélections normales) avec une clé qui est construite à partir de la liste de "
|
||
"tranches (*slice_list* dans la grammaire), de cette manière : si la liste de "
|
||
"tranches contient au moins une virgule (``,``), la clé est un *n*-uplet "
|
||
"contenant la conversion des éléments de la tranche ; sinon, la conversion du "
|
||
"seul élément de la tranche est la clé. La conversion d'un élément de tranche "
|
||
"qui est une expression est cette expression. La conversion d'une tranche en "
|
||
"tant que telle est un objet *slice* (voir la section :ref:`types`) dont les "
|
||
"attributs :attr:`~slice.start`, :attr:`~slice.stop` et :attr:`~slice.step` "
|
||
"sont les valeurs des expressions données pour la borne inférieure "
|
||
"(*lower_bound* dans la grammaire), la borne supérieure (*upper_bound* dans "
|
||
"la grammaire) et le pas (*stride* dans la grammaire), respectivement. En cas "
|
||
"d'expression manquante, la valeur par défaut est ``None``."
|
||
|
||
#: reference/expressions.rst:912
|
||
msgid "Calls"
|
||
msgstr "Appels"
|
||
|
||
#: reference/expressions.rst:914
|
||
msgid ""
|
||
"A call calls a callable object (e.g., a :term:`function`) with a possibly "
|
||
"empty series of :term:`arguments <argument>`:"
|
||
msgstr ""
|
||
"Un appel (*call* dans la grammaire ci-dessous) appelle un objet appelable "
|
||
"(par exemple, une :term:`fonction <function>`) avec, possiblement, une liste "
|
||
"d'\\ :term:`arguments <argument>` :"
|
||
|
||
#: reference/expressions.rst:931
|
||
msgid ""
|
||
"An optional trailing comma may be present after the positional and keyword "
|
||
"arguments but does not affect the semantics."
|
||
msgstr ""
|
||
"Une virgule finale (optionnelle) peut être présente, après les arguments "
|
||
"positionnels et par mots-clés, mais elle n'affecte pas la sémantique."
|
||
|
||
#: reference/expressions.rst:937
|
||
msgid ""
|
||
"The primary must evaluate to a callable object (user-defined functions, "
|
||
"built-in functions, methods of built-in objects, class objects, methods of "
|
||
"class instances, and all objects having a :meth:`__call__` method are "
|
||
"callable). All argument expressions are evaluated before the call is "
|
||
"attempted. Please refer to section :ref:`function` for the syntax of "
|
||
"formal :term:`parameter` lists."
|
||
msgstr ""
|
||
"La primaire doit s'évaluer à un objet appelable (une fonction définie par "
|
||
"l'utilisateur, une fonction native, une méthode d'objet natif, un objet de "
|
||
"classe, une méthode d'instance de classe ou tout objet possédant une "
|
||
"méthode :meth:`__call__` est un appelable). Toutes les expressions des "
|
||
"arguments sont évaluées avant que l'appel ne soit exécuté. Référez-vous à la "
|
||
"section :ref:`function` pour la syntaxe des listes de :term:`paramètres "
|
||
"<parameter>` formels."
|
||
|
||
#: reference/expressions.rst:945
|
||
msgid ""
|
||
"If keyword arguments are present, they are first converted to positional "
|
||
"arguments, as follows. First, a list of unfilled slots is created for the "
|
||
"formal parameters. If there are N positional arguments, they are placed in "
|
||
"the first N slots. Next, for each keyword argument, the identifier is used "
|
||
"to determine the corresponding slot (if the identifier is the same as the "
|
||
"first formal parameter name, the first slot is used, and so on). If the "
|
||
"slot is already filled, a :exc:`TypeError` exception is raised. Otherwise, "
|
||
"the value of the argument is placed in the slot, filling it (even if the "
|
||
"expression is ``None``, it fills the slot). When all arguments have been "
|
||
"processed, the slots that are still unfilled are filled with the "
|
||
"corresponding default value from the function definition. (Default values "
|
||
"are calculated, once, when the function is defined; thus, a mutable object "
|
||
"such as a list or dictionary used as default value will be shared by all "
|
||
"calls that don't specify an argument value for the corresponding slot; this "
|
||
"should usually be avoided.) If there are any unfilled slots for which no "
|
||
"default value is specified, a :exc:`TypeError` exception is raised. "
|
||
"Otherwise, the list of filled slots is used as the argument list for the "
|
||
"call."
|
||
msgstr ""
|
||
"Si des arguments par mots-clés sont présents, ils sont d'abord convertis en "
|
||
"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, la "
|
||
"valeur de l'argument est placée 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:965
|
||
msgid ""
|
||
"An implementation may provide built-in functions whose positional parameters "
|
||
"do not have names, even if they are 'named' for the purpose of "
|
||
"documentation, and which therefore cannot be supplied by keyword. In "
|
||
"CPython, this is the case for functions implemented in C that use :c:func:"
|
||
"`PyArg_ParseTuple` to parse their arguments."
|
||
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:"
|
||
"`PyArg_ParseTuple` pour analyser leurs arguments en font partie."
|
||
|
||
#: reference/expressions.rst:971
|
||
msgid ""
|
||
"If there are more positional arguments than there are formal parameter "
|
||
"slots, a :exc:`TypeError` exception is raised, unless a formal parameter "
|
||
"using the syntax ``*identifier`` is present; in this case, that formal "
|
||
"parameter receives a tuple containing the excess positional arguments (or an "
|
||
"empty tuple if there were no excess positional arguments)."
|
||
msgstr ""
|
||
"S'il y a plus d'arguments positionnels que de *slots* de paramètres formels, "
|
||
"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 *n*-uplet contenant les arguments positionnels en supplément (ou "
|
||
"un *n*-uplet vide s'il n'y avait pas d'arguments positionnel en trop)."
|
||
|
||
#: reference/expressions.rst:977
|
||
msgid ""
|
||
"If any keyword argument does not correspond to a formal parameter name, a :"
|
||
"exc:`TypeError` exception is raised, unless a formal parameter using the "
|
||
"syntax ``**identifier`` is present; in this case, that formal parameter "
|
||
"receives a dictionary containing the excess keyword arguments (using the "
|
||
"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 "
|
||
"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 "
|
||
"dictionnaire), ou un (nouveau) dictionnaire vide s'il n'y a pas d'argument "
|
||
"par mot-clé en trop."
|
||
|
||
#: reference/expressions.rst:988
|
||
msgid ""
|
||
"If the syntax ``*expression`` appears in the function call, ``expression`` "
|
||
"must evaluate to an :term:`iterable`. Elements from these iterables are "
|
||
"treated as if they were additional positional arguments. For the call "
|
||
"``f(x1, x2, *y, x3, x4)``, if *y* evaluates to a sequence *y1*, ..., *yM*, "
|
||
"this is equivalent to a call with M+4 positional arguments *x1*, *x2*, "
|
||
"*y1*, ..., *yM*, *x3*, *x4*."
|
||
msgstr ""
|
||
"Si la syntaxe ``*expression`` apparaît dans l'appel de la fonction, "
|
||
"``expression`` doit pouvoir s'évaluer à un :term:`itérable <iterable>`. Les "
|
||
"éléments de ces itérables sont traités comme s'ils étaient des arguments "
|
||
"positionnels supplémentaires. Pour l'appel ``f(x1, x2, *y, x3, x4)``, si *y* "
|
||
"s'évalue comme une séquence *y1*, ..., *yM*, c'est équivalent à un appel "
|
||
"avec M+4 arguments positionnels *x1*, *x2*, *y1*, ..., *yM*, *x3*, *x4*."
|
||
|
||
#: reference/expressions.rst:995
|
||
msgid ""
|
||
"A consequence of this is that although the ``*expression`` syntax may appear "
|
||
"*after* explicit keyword arguments, it is processed *before* the keyword "
|
||
"arguments (and any ``**expression`` arguments -- see below). So::"
|
||
msgstr ""
|
||
"Une conséquence est que bien que la syntaxe ``*expression`` puisse "
|
||
"apparaître *après* les arguments par mots-clés explicites, ils sont traités "
|
||
"*avant* les arguments par mots-clés (et avant tout argument ``**expression`` "
|
||
"-- voir ci-dessous). Ainsi ::"
|
||
|
||
#: reference/expressions.rst:1011
|
||
msgid ""
|
||
"It is unusual for both keyword arguments and the ``*expression`` syntax to "
|
||
"be used in the same call, so in practice this confusion does not arise."
|
||
msgstr ""
|
||
"Il est inhabituel que les syntaxes d'arguments par mots-clés et "
|
||
"``*expression`` soient utilisés simultanément dans un même appel, ce qui "
|
||
"fait que la confusion reste hypothétique."
|
||
|
||
#: reference/expressions.rst:1017
|
||
msgid ""
|
||
"If the syntax ``**expression`` appears in the function call, ``expression`` "
|
||
"must evaluate to a :term:`mapping`, the contents of which are treated as "
|
||
"additional keyword arguments. If a keyword is already present (as an "
|
||
"explicit keyword argument, or from another unpacking), a :exc:`TypeError` "
|
||
"exception is raised."
|
||
msgstr ""
|
||
"Si la syntaxe ``**expression`` apparaît dans un appel de fonction, "
|
||
"``expression`` doit pouvoir s'évaluer comme un :term:`tableau de "
|
||
"correspondances <mapping>`, 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."
|
||
|
||
#: reference/expressions.rst:1023
|
||
msgid ""
|
||
"Formal parameters using the syntax ``*identifier`` or ``**identifier`` "
|
||
"cannot be used as positional argument slots or as keyword argument names."
|
||
msgstr ""
|
||
"Les paramètres formels qui utilisent la syntaxe ``*identifier`` ou "
|
||
"``**identifier`` ne peuvent pas être utilisés comme arguments positionnels "
|
||
"ou comme noms d'arguments par mots-clés."
|
||
|
||
#: reference/expressions.rst:1026
|
||
msgid ""
|
||
"Function calls accept any number of ``*`` and ``**`` unpackings, positional "
|
||
"arguments may follow iterable unpackings (``*``), and keyword arguments may "
|
||
"follow dictionary unpackings (``**``). Originally proposed by :pep:`448`."
|
||
msgstr ""
|
||
"Les appels de fonction acceptent n'importe quel nombre de dépaquetages par "
|
||
"``*`` ou ``**``. Des arguments positionnels peuvent suivre les dépaquetages "
|
||
"d'itérables (``*``) et les arguments par mots-clés peuvent suivre les "
|
||
"dépaquetages de dictionnaires (``**``). Proposé pour la première fois par "
|
||
"la :pep:`448`."
|
||
|
||
#: reference/expressions.rst:1032
|
||
msgid ""
|
||
"A call always returns some value, possibly ``None``, unless it raises an "
|
||
"exception. How this value is computed depends on the type of the callable "
|
||
"object."
|
||
msgstr ""
|
||
"Un appel renvoie toujours une valeur, possiblement ``None``, à moins qu'il "
|
||
"ne lève une exception. La façon dont celle valeur est calculée dépend du "
|
||
"type de l'objet appelable."
|
||
|
||
#: reference/expressions.rst:1036
|
||
msgid "If it is---"
|
||
msgstr "Si c'est ---"
|
||
|
||
#: reference/expressions.rst:1049
|
||
msgid "a user-defined function:"
|
||
msgstr "une fonction définie par l'utilisateur :"
|
||
|
||
#: reference/expressions.rst:1045
|
||
msgid ""
|
||
"The code block for the function is executed, passing it the argument list. "
|
||
"The first thing the code block will do is bind the formal parameters to the "
|
||
"arguments; this is described in section :ref:`function`. When the code "
|
||
"block executes a :keyword:`return` statement, this specifies the return "
|
||
"value of the function call."
|
||
msgstr ""
|
||
"le bloc de code de la fonction est exécuté, il reçoit la liste des "
|
||
"arguments. La première chose que le bloc de code fait est de lier les "
|
||
"paramètres formels aux arguments ; ceci est décrit dans la section :ref:"
|
||
"`function`. Quand le bloc de code exécute l'instruction :keyword:`return`, "
|
||
"cela spécifie la valeur de retour de l'appel de la fonction."
|
||
|
||
#: reference/expressions.rst:1063
|
||
msgid "a built-in function or method:"
|
||
msgstr "une fonction ou une méthode native :"
|
||
|
||
#: reference/expressions.rst:1062
|
||
msgid ""
|
||
"The result is up to the interpreter; see :ref:`built-in-funcs` for the "
|
||
"descriptions of built-in functions and methods."
|
||
msgstr ""
|
||
"le résultat dépend de l'interpréteur ; lisez :ref:`built-in-funcs` pour une "
|
||
"description des fonctions et méthodes natives."
|
||
|
||
#: reference/expressions.rst:1070
|
||
msgid "a class object:"
|
||
msgstr "un objet classe :"
|
||
|
||
#: reference/expressions.rst:1070
|
||
msgid "A new instance of that class is returned."
|
||
msgstr "une nouvelle instance de cette classe est renvoyée."
|
||
|
||
#: reference/expressions.rst:1080
|
||
msgid "a class instance method:"
|
||
msgstr "une méthode d'instance de classe :"
|
||
|
||
#: reference/expressions.rst:1078
|
||
msgid ""
|
||
"The corresponding user-defined function is called, with an argument list "
|
||
"that is one longer than the argument list of the call: the instance becomes "
|
||
"the first argument."
|
||
msgstr ""
|
||
"la fonction correspondante définie par l'utilisateur est appelée, avec la "
|
||
"liste d'arguments qui est plus grande d'un élément que la liste des "
|
||
"arguments de l'appel : l'instance est placée en tête des arguments."
|
||
|
||
#: reference/expressions.rst:1089
|
||
msgid "a class instance:"
|
||
msgstr "une instance de classe :"
|
||
|
||
#: reference/expressions.rst:1087
|
||
msgid ""
|
||
"The class must define a :meth:`__call__` method; the effect is then the same "
|
||
"as if that method was called."
|
||
msgstr ""
|
||
"la classe doit définir une méthode :meth:`__call__` ; l'effet est le même "
|
||
"que si cette méthode était appelée."
|
||
|
||
#: reference/expressions.rst:1860
|
||
msgid "Await expression"
|
||
msgstr "Expression ``await``"
|
||
|
||
#: reference/expressions.rst:1097
|
||
msgid ""
|
||
"Suspend the execution of :term:`coroutine` on an :term:`awaitable` object. "
|
||
"Can only be used inside a :term:`coroutine function`."
|
||
msgstr ""
|
||
"Suspend l'exécution de la :term:`coroutine` sur un objet :term:`awaitable`. "
|
||
"Ne peut être utilisée qu'à l'intérieur d'une :term:`coroutine function`."
|
||
|
||
#: reference/expressions.rst:1109
|
||
msgid "The power operator"
|
||
msgstr "L'opérateur puissance"
|
||
|
||
#: reference/expressions.rst:1115
|
||
msgid ""
|
||
"The power operator binds more tightly than unary operators on its left; it "
|
||
"binds less tightly than unary operators on its right. The syntax is:"
|
||
msgstr ""
|
||
"L'opérateur puissance est plus prioritaire que les opérateurs unaires sur sa "
|
||
"gauche ; il est moins prioritaire que les opérateurs unaires sur sa droite. "
|
||
"La syntaxe est :"
|
||
|
||
#: reference/expressions.rst:1121
|
||
msgid ""
|
||
"Thus, in an unparenthesized sequence of power and unary operators, the "
|
||
"operators are evaluated from right to left (this does not constrain the "
|
||
"evaluation order for the operands): ``-1**2`` results in ``-1``."
|
||
msgstr ""
|
||
"Ainsi, dans une séquence sans parenthèse de puissance et d'opérateurs "
|
||
"unaires, les opérateurs sont évalués de droite à gauche (ceci ne contraint "
|
||
"pas l'ordre d'évaluation des opérandes) : ``-1**2`` donne ``-1``."
|
||
|
||
#: reference/expressions.rst:1125
|
||
msgid ""
|
||
"The power operator has the same semantics as the built-in :func:`pow` "
|
||
"function, when called with two arguments: it yields its left argument raised "
|
||
"to the power of its right argument. The numeric arguments are first "
|
||
"converted to a common type, and the result is of that type."
|
||
msgstr ""
|
||
"L'opérateur puissance possède la même sémantique que la fonction native :"
|
||
"func:`pow` lorsqu'elle est appelée avec deux arguments : il produit son "
|
||
"argument de gauche élevé à la puissance de son argument de droite. Les "
|
||
"arguments numériques sont d'abord convertis vers un type commun et le "
|
||
"résultat est de ce type."
|
||
|
||
#: reference/expressions.rst:1130
|
||
msgid ""
|
||
"For int operands, the result has the same type as the operands unless the "
|
||
"second argument is negative; in that case, all arguments are converted to "
|
||
"float and a float result is delivered. For example, ``10**2`` returns "
|
||
"``100``, but ``10**-2`` returns ``0.01``."
|
||
msgstr ""
|
||
"Pour les opérandes entiers, le résultat est du même type à moins que le "
|
||
"deuxième argument ne soit négatif ; dans ce cas, tous les arguments sont "
|
||
"convertis en nombres à virgule flottante et le résultat est un nombre à "
|
||
"virgule flottante. Par exemple, ``10**2`` renvoie ``100`` mais ``10**-2`` "
|
||
"renvoie ``0.01``."
|
||
|
||
#: reference/expressions.rst:1135
|
||
msgid ""
|
||
"Raising ``0.0`` to a negative power results in a :exc:`ZeroDivisionError`. "
|
||
"Raising a negative number to a fractional power results in a :class:"
|
||
"`complex` number. (In earlier versions it raised a :exc:`ValueError`.)"
|
||
msgstr ""
|
||
"Élever ``0.0`` à une puissance négative entraîne une :exc:"
|
||
"`ZeroDivisionError`. Élever un nombre négatif à une puissance fractionnaire "
|
||
"renvoie un nombre :class:`complexe <complex>` (dans les versions "
|
||
"antérieures, cela levait une :exc:`ValueError`)."
|
||
|
||
#: reference/expressions.rst:1143
|
||
msgid "Unary arithmetic and bitwise operations"
|
||
msgstr "Arithmétique unaire et opérations sur les bits"
|
||
|
||
#: reference/expressions.rst:1149
|
||
msgid "All unary arithmetic and bitwise operations have the same priority:"
|
||
msgstr ""
|
||
"Toute l'arithmétique unaire et les opérations sur les bits ont la même "
|
||
"priorité :"
|
||
|
||
#: reference/expressions.rst:1160
|
||
msgid ""
|
||
"The unary ``-`` (minus) operator yields the negation of its numeric argument."
|
||
msgstr ""
|
||
"L'opérateur unaire ``-`` (moins) produit l'opposé de son argument numérique."
|
||
|
||
#: reference/expressions.rst:1167
|
||
msgid "The unary ``+`` (plus) operator yields its numeric argument unchanged."
|
||
msgstr ""
|
||
"L'opérateur unaire ``+`` (plus) produit son argument numérique inchangé."
|
||
|
||
#: reference/expressions.rst:1173
|
||
msgid ""
|
||
"The unary ``~`` (invert) operator yields the bitwise inversion of its "
|
||
"integer argument. The bitwise inversion of ``x`` is defined as ``-(x+1)``. "
|
||
"It only applies to integral numbers."
|
||
msgstr ""
|
||
"L'opérateur unaire ``~`` (inversion) produit l'inversion bit à bit de son "
|
||
"argument entier. L'inversion bit à bit de ``x`` est définie comme ``-(x"
|
||
"+1)``. Elle s'applique uniquement aux nombres entiers."
|
||
|
||
#: reference/expressions.rst:1179
|
||
msgid ""
|
||
"In all three cases, if the argument does not have the proper type, a :exc:"
|
||
"`TypeError` exception is raised."
|
||
msgstr ""
|
||
"Dans ces trois cas, si l'argument n'est pas du bon type, une exception :exc:"
|
||
"`TypeError` est levée."
|
||
|
||
#: reference/expressions.rst:1186
|
||
msgid "Binary arithmetic operations"
|
||
msgstr "Opérations arithmétiques binaires"
|
||
|
||
#: reference/expressions.rst:1190
|
||
msgid ""
|
||
"The binary arithmetic operations have the conventional priority levels. "
|
||
"Note that some of these operations also apply to certain non-numeric types. "
|
||
"Apart from the power operator, there are only two levels, one for "
|
||
"multiplicative operators and one for additive operators:"
|
||
msgstr ""
|
||
"Les opérations arithmétiques binaires suivent les conventions pour les "
|
||
"priorités. Notez que certaines de ces opérations s'appliquent aussi à des "
|
||
"types non numériques. À part l'opérateur puissance, il n'y a que deux "
|
||
"niveaux, le premier pour les opérateurs multiplicatifs et le second pour les "
|
||
"opérateurs additifs :"
|
||
|
||
#: reference/expressions.rst:1205
|
||
msgid ""
|
||
"The ``*`` (multiplication) operator yields the product of its arguments. "
|
||
"The arguments must either both be numbers, or one argument must be an "
|
||
"integer and the other must be a sequence. In the former case, the numbers "
|
||
"are converted to a common type and then multiplied together. In the latter "
|
||
"case, sequence repetition is performed; a negative repetition factor yields "
|
||
"an empty sequence."
|
||
msgstr ""
|
||
"L'opérateur ``*`` (multiplication) produit le produit de ses arguments. Les "
|
||
"deux arguments doivent être des nombres ou alors le premier argument doit "
|
||
"être un entier et l'autre doit être une séquence. Dans le premier cas, les "
|
||
"nombres sont convertis dans un type commun puis sont multipliés entre eux. "
|
||
"Dans le dernier cas, la séquence est répétée ; une répétition négative "
|
||
"produit une séquence vide."
|
||
|
||
#: reference/expressions.rst:1215
|
||
msgid ""
|
||
"The ``@`` (at) operator is intended to be used for matrix multiplication. "
|
||
"No builtin Python types implement this operator."
|
||
msgstr ""
|
||
"L'opérateur ``@`` (prononcé *at* en anglais) a vocation à multiplier des "
|
||
"matrices. Aucun type Python natif n'implémente cet opérateur."
|
||
|
||
#: reference/expressions.rst:1226
|
||
msgid ""
|
||
"The ``/`` (division) and ``//`` (floor division) operators yield the "
|
||
"quotient of their arguments. The numeric arguments are first converted to a "
|
||
"common type. Division of integers yields a float, while floor division of "
|
||
"integers results in an integer; the result is that of mathematical division "
|
||
"with the 'floor' function applied to the result. Division by zero raises "
|
||
"the :exc:`ZeroDivisionError` exception."
|
||
msgstr ""
|
||
"Les opérateurs ``/`` (division) et ``//`` (division entière ou *floor "
|
||
"division* en anglais) produisent le quotient de leurs arguments. Les "
|
||
"arguments numériques sont d'abord convertis vers un type commun. La division "
|
||
"d'entiers produit un nombre à virgule flottante alors que la division "
|
||
"entière d'entiers produit un entier ; le résultat est celui de la division "
|
||
"mathématique suivie de la fonction ``floor`` appliquée au résultat. Une "
|
||
"division par zéro lève une exception :exc:`ZeroDivisionError`."
|
||
|
||
#: reference/expressions.rst:1237
|
||
msgid ""
|
||
"The ``%`` (modulo) operator yields the remainder from the division of the "
|
||
"first argument by the second. The numeric arguments are first converted to "
|
||
"a common type. A zero right argument raises the :exc:`ZeroDivisionError` "
|
||
"exception. The arguments may be floating point numbers, e.g., ``3.14%0.7`` "
|
||
"equals ``0.34`` (since ``3.14`` equals ``4*0.7 + 0.34``.) The modulo "
|
||
"operator always yields a result with the same sign as its second operand (or "
|
||
"zero); the absolute value of the result is strictly smaller than the "
|
||
"absolute value of the second operand [#]_."
|
||
msgstr ""
|
||
"L'opérateur ``%`` (modulo) produit le reste de la division entière du "
|
||
"premier argument par le second. Les arguments numériques sont d'abord "
|
||
"convertis vers un type commun. Un zéro en second argument lève une "
|
||
"exception :exc:`ZeroDivisionError`. Les arguments peuvent être des nombres à "
|
||
"virgule flottante, par exemple ``3.14%0.7`` vaut ``0.34`` (puisque ``3.14`` "
|
||
"égale ``4*0.7+0.34``). L'opérateur modulo produit toujours un résultat du "
|
||
"même signe que le second opérande (ou zéro) ; la valeur absolue du résultat "
|
||
"est strictement inférieure à la valeur absolue du second opérande [#]_."
|
||
|
||
#: reference/expressions.rst:1246
|
||
msgid ""
|
||
"The floor division and modulo operators are connected by the following "
|
||
"identity: ``x == (x//y)*y + (x%y)``. Floor division and modulo are also "
|
||
"connected with the built-in function :func:`divmod`: ``divmod(x, y) == (x//"
|
||
"y, x%y)``. [#]_."
|
||
msgstr ""
|
||
"Les opérateurs division entière et modulo sont liés par la relation "
|
||
"suivante : ``x == (x//y)*y + (x%y)``. La division entière et le module sont "
|
||
"aussi liés à la fonction native :func:`divmod` : ``divmod(x, y) == (x//y, x"
|
||
"%y)`` [#]_."
|
||
|
||
#: reference/expressions.rst:1251
|
||
msgid ""
|
||
"In addition to performing the modulo operation on numbers, the ``%`` "
|
||
"operator is also overloaded by string objects to perform old-style string "
|
||
"formatting (also known as interpolation). The syntax for string formatting "
|
||
"is described in the Python Library Reference, section :ref:`old-string-"
|
||
"formatting`."
|
||
msgstr ""
|
||
"En plus de calculer le modulo sur les nombres, l'opérateur ``%`` est aussi "
|
||
"surchargé par les objets chaînes de caractères pour effectuer le formatage "
|
||
"de chaîne « à l'ancienne ». La syntaxe pour le formatage de chaînes est "
|
||
"décrit dans la référence de la bibliothèque Python, dans la section :ref:"
|
||
"`old-string-formatting`."
|
||
|
||
#: reference/expressions.rst:1256
|
||
msgid ""
|
||
"The floor division operator, the modulo operator, and the :func:`divmod` "
|
||
"function are not defined for complex numbers. Instead, convert to a "
|
||
"floating point number using the :func:`abs` function if appropriate."
|
||
msgstr ""
|
||
"L'opérateur de division entière, l'opérateur modulo et la fonction :func:"
|
||
"`divmod` ne sont pas définis pour les nombres complexes. À la place, vous "
|
||
"pouvez, si cela a du sens pour ce que vous voulez faire, les convertir vers "
|
||
"des nombres à virgule flottante en utilisant la fonction :func:`abs`."
|
||
|
||
#: reference/expressions.rst:1265
|
||
msgid ""
|
||
"The ``+`` (addition) operator yields the sum of its arguments. The "
|
||
"arguments must either both be numbers or both be sequences of the same "
|
||
"type. In the former case, the numbers are converted to a common type and "
|
||
"then added together. In the latter case, the sequences are concatenated."
|
||
msgstr ""
|
||
"L'opérateur ``+`` (addition) produit la somme de ses arguments. Les "
|
||
"arguments doivent être tous les deux des nombres ou des séquences du même "
|
||
"type. Dans le premier cas, les nombres sont convertis vers un type commun "
|
||
"puis sont additionnés entre eux. Dans le dernier cas, les séquences sont "
|
||
"concaténées."
|
||
|
||
#: reference/expressions.rst:1275
|
||
msgid ""
|
||
"The ``-`` (subtraction) operator yields the difference of its arguments. "
|
||
"The numeric arguments are first converted to a common type."
|
||
msgstr ""
|
||
"L'opérateur ``-`` (soustraction) produit la différence entre ses arguments. "
|
||
"Les arguments numériques sont d'abord convertis vers un type commun."
|
||
|
||
#: reference/expressions.rst:1282
|
||
msgid "Shifting operations"
|
||
msgstr "Opérations de décalage"
|
||
|
||
#: reference/expressions.rst:1289
|
||
msgid ""
|
||
"The shifting operations have lower priority than the arithmetic operations:"
|
||
msgstr ""
|
||
"Les opérations de décalage sont moins prioritaires que les opérations "
|
||
"arithmétiques :"
|
||
|
||
#: reference/expressions.rst:1294
|
||
msgid ""
|
||
"These operators accept integers as arguments. They shift the first argument "
|
||
"to the left or right by the number of bits given by the second argument."
|
||
msgstr ""
|
||
"Ces opérateurs prennent des entiers comme arguments. Ils décalent le premier "
|
||
"argument vers la gauche ou vers la droite du nombre de bits donné par le "
|
||
"deuxième argument."
|
||
|
||
#: reference/expressions.rst:1299
|
||
msgid ""
|
||
"A right shift by *n* bits is defined as floor division by ``pow(2,n)``. A "
|
||
"left shift by *n* bits is defined as multiplication with ``pow(2,n)``."
|
||
msgstr ""
|
||
"Un décalage à droite de *n* bits est défini comme la division entière par "
|
||
"``pow(2,n)``. Un décalage à gauche de *n* bits est défini comme la "
|
||
"multiplication par ``pow(2,n)``."
|
||
|
||
#: reference/expressions.rst:1306
|
||
msgid "Binary bitwise operations"
|
||
msgstr "Opérations binaires bit à bit"
|
||
|
||
#: reference/expressions.rst:1310
|
||
msgid "Each of the three bitwise operations has a different priority level:"
|
||
msgstr ""
|
||
"Chacune des trois opérations binaires bit à bit possède une priorité "
|
||
"différente :"
|
||
|
||
#: reference/expressions.rst:1321
|
||
msgid ""
|
||
"The ``&`` operator yields the bitwise AND of its arguments, which must be "
|
||
"integers."
|
||
msgstr ""
|
||
"L'opérateur ``&`` produit le ET logique de ses arguments, qui doivent être "
|
||
"des entiers."
|
||
|
||
#: reference/expressions.rst:1329
|
||
msgid ""
|
||
"The ``^`` operator yields the bitwise XOR (exclusive OR) of its arguments, "
|
||
"which must be integers."
|
||
msgstr ""
|
||
"L'opérateur ``^`` produit le OU EXCLUSIF (XOR) logique de ses arguments, qui "
|
||
"doivent être des entiers."
|
||
|
||
#: reference/expressions.rst:1337
|
||
msgid ""
|
||
"The ``|`` operator yields the bitwise (inclusive) OR of its arguments, which "
|
||
"must be integers."
|
||
msgstr ""
|
||
"L'opérateur ``|`` produit le OU logique de ses arguments, qui doivent être "
|
||
"des entiers."
|
||
|
||
#: reference/expressions.rst:1344
|
||
msgid "Comparisons"
|
||
msgstr "Comparaisons"
|
||
|
||
#: reference/expressions.rst:1356
|
||
msgid ""
|
||
"Unlike C, all comparison operations in Python have the same priority, which "
|
||
"is lower than that of any arithmetic, shifting or bitwise operation. Also "
|
||
"unlike C, expressions like ``a < b < c`` have the interpretation that is "
|
||
"conventional in mathematics:"
|
||
msgstr ""
|
||
"Au contraire du C, toutes les opérations de comparaison en Python possèdent "
|
||
"la même priorité, qui est plus faible que celle des opérations "
|
||
"arithmétiques, décalages ou binaires bit à bit. Toujours contrairement au C, "
|
||
"les expressions telles que ``a < b < c`` sont interprétées comme elles le "
|
||
"seraient conventionnellement en mathématiques :"
|
||
|
||
#: reference/expressions.rst:1366
|
||
msgid "Comparisons yield boolean values: ``True`` or ``False``."
|
||
msgstr ""
|
||
"Les comparaisons produisent des valeurs booléennes : ``True`` ou ``False``."
|
||
|
||
#: reference/expressions.rst:1370
|
||
msgid ""
|
||
"Comparisons can be chained arbitrarily, e.g., ``x < y <= z`` is equivalent "
|
||
"to ``x < y and y <= z``, except that ``y`` is evaluated only once (but in "
|
||
"both cases ``z`` is not evaluated at all when ``x < y`` is found to be "
|
||
"false)."
|
||
msgstr ""
|
||
"Les comparaisons peuvent être enchaînées arbitrairement, par exemple ``x < y "
|
||
"<= z`` est équivalent à ``x < y and y <= z``, sauf que ``y`` est évalué "
|
||
"seulement une fois (mais dans les deux cas, ``z`` n'est pas évalué du tout "
|
||
"si ``x < y`` s'avère être faux)."
|
||
|
||
#: reference/expressions.rst:1374
|
||
msgid ""
|
||
"Formally, if *a*, *b*, *c*, ..., *y*, *z* are expressions and *op1*, "
|
||
"*op2*, ..., *opN* are comparison operators, then ``a op1 b op2 c ... y opN "
|
||
"z`` is equivalent to ``a op1 b and b op2 c and ... y opN z``, except that "
|
||
"each expression is evaluated at most once."
|
||
msgstr ""
|
||
"Formellement, si *a*, *b*, *c*, ..., *y*, *z* sont des expressions et *op1*, "
|
||
"*op2*, ..., *opN* sont des opérateurs de comparaison, alors ``a op1 b op2 "
|
||
"c ... y opN z`` est équivalent à ``a op1 b and b op2 c and ... y opN z``, "
|
||
"sauf que chaque expression est évaluée au maximum une fois."
|
||
|
||
#: reference/expressions.rst:1379
|
||
msgid ""
|
||
"Note that ``a op1 b op2 c`` doesn't imply any kind of comparison between *a* "
|
||
"and *c*, so that, e.g., ``x < y > z`` is perfectly legal (though perhaps not "
|
||
"pretty)."
|
||
msgstr ""
|
||
"Notez que ``a op1 b op2 c`` n'implique aucune comparaison entre *a* et *c*. "
|
||
"Ainsi, par exemple, ``x < y > z`` est parfaitement légal (mais peut-être pas "
|
||
"très élégant)."
|
||
|
||
#: reference/expressions.rst:1384
|
||
msgid "Value comparisons"
|
||
msgstr "Comparaisons de valeurs"
|
||
|
||
#: reference/expressions.rst:1386
|
||
msgid ""
|
||
"The operators ``<``, ``>``, ``==``, ``>=``, ``<=``, and ``!=`` compare the "
|
||
"values of two objects. The objects do not need to have the same type."
|
||
msgstr ""
|
||
"Les opérateurs ``<``, ``>``, ``==``, ``>=``, ``<=`` et ``!=`` comparent les "
|
||
"valeurs de deux objets. Les objets n'ont pas besoin d'être du même type."
|
||
|
||
#: reference/expressions.rst:1389
|
||
msgid ""
|
||
"Chapter :ref:`objects` states that objects have a value (in addition to type "
|
||
"and identity). The value of an object is a rather abstract notion in "
|
||
"Python: For example, there is no canonical access method for an object's "
|
||
"value. Also, there is no requirement that the value of an object should be "
|
||
"constructed in a particular way, e.g. comprised of all its data attributes. "
|
||
"Comparison operators implement a particular notion of what the value of an "
|
||
"object is. One can think of them as defining the value of an object "
|
||
"indirectly, by means of their comparison implementation."
|
||
msgstr ""
|
||
"Le chapitre :ref:`objects` indique que les objets ont une valeur (en plus "
|
||
"d'un type et d'un identifiant). La valeur d'un objet est une notion plutôt "
|
||
"abstraite en Python : par exemple, il n'existe pas de méthode canonique pour "
|
||
"accéder à la valeur d'un objet. De la même manière, il n'y a aucune "
|
||
"obligation concernant la construction de la valeur d'un objet, par exemple "
|
||
"qu'elle prenne en compte toutes les données de ses attributs. Les opérateurs "
|
||
"de comparaison implémentent une notion particulière de ce qu'est la valeur "
|
||
"d'un objet. Vous pouvez vous le représenter comme une définition indirecte "
|
||
"de la valeur d'un objet, *via* l'implémentation de leur comparaison."
|
||
|
||
#: reference/expressions.rst:1398
|
||
msgid ""
|
||
"Because all types are (direct or indirect) subtypes of :class:`object`, they "
|
||
"inherit the default comparison behavior from :class:`object`. Types can "
|
||
"customize their comparison behavior by implementing :dfn:`rich comparison "
|
||
"methods` like :meth:`__lt__`, described in :ref:`customization`."
|
||
msgstr ""
|
||
"Comme tous les types sont des sous-types (directs ou indirects) de la "
|
||
"classe :class:`object`, ils héritent du comportement de comparaison par "
|
||
"défaut de :class:`object`. Les types peuvent personnaliser le comportement "
|
||
"des comparaisons en implémentant des :dfn:`méthodes de comparaisons riches`, "
|
||
"comme :meth:`__lt__`, décrites dans :ref:`customization`."
|
||
|
||
#: reference/expressions.rst:1404
|
||
msgid ""
|
||
"The default behavior for equality comparison (``==`` and ``!=``) is based on "
|
||
"the identity of the objects. Hence, equality comparison of instances with "
|
||
"the same identity results in equality, and equality comparison of instances "
|
||
"with different identities results in inequality. A motivation for this "
|
||
"default behavior is the desire that all objects should be reflexive (i.e. "
|
||
"``x is y`` implies ``x == y``)."
|
||
msgstr ""
|
||
"Le comportement par défaut pour le test d'égalité (``==`` et ``!=``) se base "
|
||
"sur les identifiants des objets. Ainsi, un test d'égalité entre deux "
|
||
"instances qui ont le même identifiant est vrai, un test d'égalité entre deux "
|
||
"instances qui ont des identifiants différents est faux. La raison de ce "
|
||
"choix est que Python souhaite que tous les objets soient réflexifs, c'est-à-"
|
||
"dire que ``x is y`` implique ``x == y``."
|
||
|
||
#: reference/expressions.rst:1411
|
||
msgid ""
|
||
"A default order comparison (``<``, ``>``, ``<=``, and ``>=``) is not "
|
||
"provided; an attempt raises :exc:`TypeError`. A motivation for this default "
|
||
"behavior is the lack of a similar invariant as for equality."
|
||
msgstr ""
|
||
"La relation d'ordre (``<``, ``>``, ``<=`` et ``>=``) n'est pas fournie par "
|
||
"défaut ; une tentative se solde par une :exc:`TypeError`. La raison de ce "
|
||
"choix est qu'il n'existe pas d'invariant similaire à celui de l'égalité."
|
||
|
||
#: reference/expressions.rst:1415
|
||
msgid ""
|
||
"The behavior of the default equality comparison, that instances with "
|
||
"different identities are always unequal, may be in contrast to what types "
|
||
"will need that have a sensible definition of object value and value-based "
|
||
"equality. Such types will need to customize their comparison behavior, and "
|
||
"in fact, a number of built-in types have done that."
|
||
msgstr ""
|
||
"Le comportement du test d'égalité par défaut, à savoir que les instances "
|
||
"avec des identités différentes ne sont jamais égales, peut être en "
|
||
"contradiction avec les types qui définissent la « valeur » d'un objet et se "
|
||
"basent sur cette « valeur » pour l'égalité. De tels types doivent "
|
||
"personnaliser leurs tests de comparaison et, en fait, c'est ce qu'ont fait "
|
||
"un certain nombre de types natifs."
|
||
|
||
#: reference/expressions.rst:1421
|
||
msgid ""
|
||
"The following list describes the comparison behavior of the most important "
|
||
"built-in types."
|
||
msgstr ""
|
||
"La liste suivante décrit le comportement des tests d'égalité pour les types "
|
||
"natifs les plus importants."
|
||
|
||
#: reference/expressions.rst:1424
|
||
msgid ""
|
||
"Numbers of built-in numeric types (:ref:`typesnumeric`) and of the standard "
|
||
"library types :class:`fractions.Fraction` and :class:`decimal.Decimal` can "
|
||
"be compared within and across their types, with the restriction that complex "
|
||
"numbers do not support order comparison. Within the limits of the types "
|
||
"involved, they compare mathematically (algorithmically) correct without loss "
|
||
"of precision."
|
||
msgstr ""
|
||
"Beaucoup de types numériques natifs (:ref:`typesnumeric`) et de types de la "
|
||
"bibliothèque standard :class:`fractions.Fraction` ainsi que :class:`decimal."
|
||
"decimal` peuvent être comparés, au sein de leur propre classe ou avec "
|
||
"d'autres objets de classes différentes. Une exception notable concerne les "
|
||
"nombres complexes qui ne gèrent pas la relation d'ordre. Dans les limites "
|
||
"des types concernés, la comparaison mathématique équivaut à la comparaison "
|
||
"algorithmique, sans perte de précision."
|
||
|
||
#: reference/expressions.rst:1431
|
||
msgid ""
|
||
"The not-a-number values ``float('NaN')`` and ``decimal.Decimal('NaN')`` are "
|
||
"special. Any ordered comparison of a number to a not-a-number value is "
|
||
"false. A counter-intuitive implication is that not-a-number values are not "
|
||
"equal to themselves. For example, if ``x = float('NaN')``, ``3 < x``, ``x < "
|
||
"3`` and ``x == x`` are all false, while ``x != x`` is true. This behavior "
|
||
"is compliant with IEEE 754."
|
||
msgstr ""
|
||
"Les valeurs non numériques ``float('NaN')`` et ``decimal.Decimal('NaN')`` "
|
||
"sont spéciales : toute comparaison entre un nombre et une valeur non "
|
||
"numérique est fausse. Une implication contre-intuitive à cela est que les "
|
||
"valeurs non numériques ne sont pas égales à elles-mêmes. Par exemple, avec "
|
||
"``x = float('NaN')``, les expressions ``3 < x``, ``x < 3`` et ``x == x`` "
|
||
"sont toutes fausses, mais l’expression ``x != x`` est vraie. Ce comportement "
|
||
"est en accord avec IEEE 754."
|
||
|
||
#: reference/expressions.rst:1438
|
||
msgid ""
|
||
"``None`` and ``NotImplemented`` are singletons. :PEP:`8` advises that "
|
||
"comparisons for singletons should always be done with ``is`` or ``is not``, "
|
||
"never the equality operators."
|
||
msgstr ""
|
||
"``None`` et ``NotImplemented`` sont des singletons. :PEP:`8` conseille de "
|
||
"toujours comparer les singletons en utilisant soit ``is`` soit ``is not``, "
|
||
"jamais les autres opérateurs."
|
||
|
||
#: reference/expressions.rst:1442
|
||
msgid ""
|
||
"Binary sequences (instances of :class:`bytes` or :class:`bytearray`) can be "
|
||
"compared within and across their types. They compare lexicographically "
|
||
"using the numeric values of their elements."
|
||
msgstr ""
|
||
"Les séquences binaires (instances du type :class:`bytes` ou :class:"
|
||
"`bytearray`) peuvent être comparées au sein de la classe et entre classes. "
|
||
"La comparaison est lexicographique, en utilisant la valeur numérique des "
|
||
"éléments."
|
||
|
||
#: reference/expressions.rst:1446
|
||
msgid ""
|
||
"Strings (instances of :class:`str`) compare lexicographically using the "
|
||
"numerical Unicode code points (the result of the built-in function :func:"
|
||
"`ord`) of their characters. [#]_"
|
||
msgstr ""
|
||
"Les chaînes de caractères (instances de :class:`str`) respectent l'ordre "
|
||
"lexicographique en utilisant la valeur Unicode (le résultat de la fonction "
|
||
"native :func:`ord`) des caractères [#]_."
|
||
|
||
#: reference/expressions.rst:1450
|
||
msgid "Strings and binary sequences cannot be directly compared."
|
||
msgstr ""
|
||
"Les chaînes de caractères et les séquences binaires ne peuvent pas être "
|
||
"comparées directement."
|
||
|
||
#: reference/expressions.rst:1452
|
||
msgid ""
|
||
"Sequences (instances of :class:`tuple`, :class:`list`, or :class:`range`) "
|
||
"can be compared only within each of their types, with the restriction that "
|
||
"ranges do not support order comparison. Equality comparison across these "
|
||
"types results in inequality, and ordering comparison across these types "
|
||
"raises :exc:`TypeError`."
|
||
msgstr ""
|
||
"Les séquences (instances de :class:`tuple`, :class:`list` ou :class:`range`) "
|
||
"peuvent être comparées uniquement entre instances de même type, en sachant "
|
||
"que les intervalles (*range*) ne gèrent pas la relation d'ordre. Le test "
|
||
"d'égalité entre ces types renvoie faux et une comparaison entre instances de "
|
||
"types différents lève une :exc:`TypeError`."
|
||
|
||
#: reference/expressions.rst:1458
|
||
msgid ""
|
||
"Sequences compare lexicographically using comparison of corresponding "
|
||
"elements. The built-in containers typically assume identical objects are "
|
||
"equal to themselves. That lets them bypass equality tests for identical "
|
||
"objects to improve performance and to maintain their internal invariants."
|
||
msgstr ""
|
||
"Les séquences se comparent lexicographiquement en comparant les éléments "
|
||
"correspondants. Les conteneurs natifs supposent généralement que les objets "
|
||
"identiques sont égaux à eux-mêmes. Cela leur permet d'économiser les tests "
|
||
"d’égalité pour des objets identiques afin d’améliorer les performances et de "
|
||
"conserver leurs invariants internes."
|
||
|
||
#: reference/expressions.rst:1463
|
||
msgid ""
|
||
"Lexicographical comparison between built-in collections works as follows:"
|
||
msgstr ""
|
||
"L'ordre lexicographique pour les collections natives fonctionne comme suit :"
|
||
|
||
#: reference/expressions.rst:1465
|
||
msgid ""
|
||
"For two collections to compare equal, they must be of the same type, have "
|
||
"the same length, and each pair of corresponding elements must compare equal "
|
||
"(for example, ``[1,2] == (1,2)`` is false because the type is not the same)."
|
||
msgstr ""
|
||
"Deux collections sont égales si elles sont du même type, ont la même "
|
||
"longueur et si les éléments correspondants de chaque paire sont égaux. Par "
|
||
"exemple, ``[1,2] == (1,2)`` est faux car les types sont différents."
|
||
|
||
#: reference/expressions.rst:1470
|
||
msgid ""
|
||
"Collections that support order comparison are ordered the same as their "
|
||
"first unequal elements (for example, ``[1,2,x] <= [1,2,y]`` has the same "
|
||
"value as ``x <= y``). If a corresponding element does not exist, the "
|
||
"shorter collection is ordered first (for example, ``[1,2] < [1,2,3]`` is "
|
||
"true)."
|
||
msgstr ""
|
||
"Les collections qui gèrent la relation d'ordre sont ordonnées comme leur "
|
||
"premier élément différent (par exemple, ``[1,2,x] <= [1,2,y]`` a la même "
|
||
"valeur que ``x <= y``). Si un élément n'a pas de correspondant, la "
|
||
"collection la plus courte est la plus petite (par exemple, ``[1,2] < "
|
||
"[1,2,3]`` est vrai)."
|
||
|
||
#: reference/expressions.rst:1476
|
||
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 "
|
||
"enforces reflexivity."
|
||
msgstr ""
|
||
"Les tableaux de correspondances (instances de :class:`dict`) sont égales si "
|
||
"et seulement si toutes leurs paires `(clé, valeur)` sont égales. L'égalité "
|
||
"des clés et des valeurs met en œuvre la réflexivité."
|
||
|
||
#: reference/expressions.rst:1480
|
||
msgid ""
|
||
"Order comparisons (``<``, ``>``, ``<=``, and ``>=``) raise :exc:`TypeError`."
|
||
msgstr ""
|
||
"Les comparaisons (``<``, ``>``, ``<=`` et ``>=``) lèvent :exc:`TypeError`."
|
||
|
||
#: reference/expressions.rst:1482
|
||
msgid ""
|
||
"Sets (instances of :class:`set` or :class:`frozenset`) can be compared "
|
||
"within and across their types."
|
||
msgstr ""
|
||
"Les ensembles (instances de :class:`set` ou :class:`frozenset`) peuvent être "
|
||
"comparés au sein de leur propre type et entre types différents."
|
||
|
||
#: reference/expressions.rst:1485
|
||
msgid ""
|
||
"They define order comparison operators to mean subset and superset tests. "
|
||
"Those relations do not define total orderings (for example, the two sets "
|
||
"``{1,2}`` and ``{2,3}`` are not equal, nor subsets of one another, nor "
|
||
"supersets of one another). Accordingly, sets are not appropriate arguments "
|
||
"for functions which depend on total ordering (for example, :func:`min`, :"
|
||
"func:`max`, and :func:`sorted` produce undefined results given a list of "
|
||
"sets as inputs)."
|
||
msgstr ""
|
||
"Les opérateurs d'inclusion et de sur-ensemble sont définis. Ces relations ne "
|
||
"sont pas des relations d'ordre total (par exemple, les deux ensembles ``{1,2}"
|
||
"`` et ``{2,3}`` ne sont pas égaux, l'un n'est pas inclus dans l'autre, l'un "
|
||
"n'est pas un sur-ensemble de l'autre). Ainsi, les ensembles ne sont pas des "
|
||
"arguments appropriés pour les fonctions qui dépendent d'un ordre total (par "
|
||
"exemple, les fonctions :func:`min`, :func:`max` et :func:`sorted` produisent "
|
||
"des résultats indéfinis si on leur donne des listes d'ensembles en entrée)."
|
||
|
||
#: reference/expressions.rst:1493
|
||
msgid "Comparison of sets enforces reflexivity of its elements."
|
||
msgstr "La comparaison des ensembles met en œuvre la réflexivité des éléments."
|
||
|
||
#: reference/expressions.rst:1495
|
||
msgid ""
|
||
"Most other built-in types have no comparison methods implemented, so they "
|
||
"inherit the default comparison behavior."
|
||
msgstr ""
|
||
"La plupart des autres types natifs n'implémentent pas de méthodes de "
|
||
"comparaisons, ils héritent donc du comportement par défaut."
|
||
|
||
#: reference/expressions.rst:1498
|
||
msgid ""
|
||
"User-defined classes that customize their comparison behavior should follow "
|
||
"some consistency rules, if possible:"
|
||
msgstr ""
|
||
"Les classes allogènes qui particularisent les opérations de comparaison "
|
||
"doivent, si possible, respecter quelques règles pour la cohérence :"
|
||
|
||
#: reference/expressions.rst:1501
|
||
msgid ""
|
||
"Equality comparison should be reflexive. In other words, identical objects "
|
||
"should compare equal:"
|
||
msgstr ""
|
||
"Le test d'égalité doit être réflexif. En d'autres termes, des objets "
|
||
"identiques doivent être égaux :"
|
||
|
||
#: reference/expressions.rst:1504
|
||
msgid "``x is y`` implies ``x == y``"
|
||
msgstr "``x is y`` implique ``x == y``"
|
||
|
||
#: reference/expressions.rst:1506
|
||
msgid ""
|
||
"Comparison should be symmetric. In other words, the following expressions "
|
||
"should have the same result:"
|
||
msgstr ""
|
||
"La comparaison doit être symétrique. En d'autres termes, les expressions "
|
||
"suivantes doivent donner le même résultat :"
|
||
|
||
#: reference/expressions.rst:1509
|
||
msgid "``x == y`` and ``y == x``"
|
||
msgstr "``x == y`` et ``y == x``"
|
||
|
||
#: reference/expressions.rst:1511
|
||
msgid "``x != y`` and ``y != x``"
|
||
msgstr "``x != y`` et ``y != x``"
|
||
|
||
#: reference/expressions.rst:1513
|
||
msgid "``x < y`` and ``y > x``"
|
||
msgstr "``x < y`` et ``y > x``"
|
||
|
||
#: reference/expressions.rst:1515
|
||
msgid "``x <= y`` and ``y >= x``"
|
||
msgstr "``x <= y`` et ``y >= x``"
|
||
|
||
#: reference/expressions.rst:1517
|
||
msgid ""
|
||
"Comparison should be transitive. The following (non-exhaustive) examples "
|
||
"illustrate that:"
|
||
msgstr ""
|
||
"La comparaison doit être transitive. Les exemples suivants (liste non "
|
||
"exhaustive) illustrent ce concept :"
|
||
|
||
#: reference/expressions.rst:1520
|
||
msgid "``x > y and y > z`` implies ``x > z``"
|
||
msgstr "``x > y and y > z`` implique ``x > z``"
|
||
|
||
#: reference/expressions.rst:1522
|
||
msgid "``x < y and y <= z`` implies ``x < z``"
|
||
msgstr "``x < y and y <= z`` implique ``x < z``"
|
||
|
||
#: reference/expressions.rst:1524
|
||
msgid ""
|
||
"Inverse comparison should result in the boolean negation. In other words, "
|
||
"the following expressions should have the same result:"
|
||
msgstr ""
|
||
"Si vous inversez la comparaison, cela doit en produire la négation "
|
||
"booléenne. En d'autres termes, les expressions suivantes doivent produire le "
|
||
"même résultat :"
|
||
|
||
#: reference/expressions.rst:1527
|
||
msgid "``x == y`` and ``not x != y``"
|
||
msgstr "``x == y`` et ``not x != y``"
|
||
|
||
#: reference/expressions.rst:1529
|
||
msgid "``x < y`` and ``not x >= y`` (for total ordering)"
|
||
msgstr "``x < y`` et ``not x >= y`` (pour une relation d'ordre total)"
|
||
|
||
#: reference/expressions.rst:1531
|
||
msgid "``x > y`` and ``not x <= y`` (for total ordering)"
|
||
msgstr "``x > y`` et ``not x <= y`` (pour une relation d'ordre total)"
|
||
|
||
#: reference/expressions.rst:1533
|
||
msgid ""
|
||
"The last two expressions apply to totally ordered collections (e.g. to "
|
||
"sequences, but not to sets or mappings). See also the :func:`~functools."
|
||
"total_ordering` decorator."
|
||
msgstr ""
|
||
"Ces deux dernières expressions s'appliquent pour les collections totalement "
|
||
"ordonnées (par exemple, les séquences mais pas les ensembles ou les tableaux "
|
||
"de correspondances). Regardez aussi le décorateur :func:`~functools."
|
||
"total_ordering`."
|
||
|
||
#: reference/expressions.rst:1537
|
||
msgid ""
|
||
"The :func:`hash` result should be consistent with equality. Objects that are "
|
||
"equal should either have the same hash value, or be marked as unhashable."
|
||
msgstr ""
|
||
"Le résultat de :func:`hash` doit être cohérent avec l'égalité. Les objets "
|
||
"qui sont égaux doivent avoir la même empreinte ou être marqués comme non-"
|
||
"hachables."
|
||
|
||
#: reference/expressions.rst:1541
|
||
msgid ""
|
||
"Python does not enforce these consistency rules. In fact, the not-a-number "
|
||
"values are an example for not following these rules."
|
||
msgstr ""
|
||
"Python ne vérifie pas ces règles de cohérence. En fait, l'utilisation de "
|
||
"valeurs non numériques est un exemple de non-respect de ces règles."
|
||
|
||
#: reference/expressions.rst:1550
|
||
msgid "Membership test operations"
|
||
msgstr "Opérations de tests d’appartenance à un ensemble"
|
||
|
||
#: reference/expressions.rst:1552
|
||
msgid ""
|
||
"The operators :keyword:`in` and :keyword:`not in` test for membership. ``x "
|
||
"in s`` evaluates to ``True`` if *x* is a member of *s*, and ``False`` "
|
||
"otherwise. ``x not in s`` returns the negation of ``x in s``. All built-in "
|
||
"sequences and set types support this as well as dictionary, for which :"
|
||
"keyword:`!in` tests whether the dictionary has a given key. For container "
|
||
"types such as list, tuple, set, frozenset, dict, or collections.deque, the "
|
||
"expression ``x in y`` is equivalent to ``any(x is e or x == e for e in y)``."
|
||
msgstr ""
|
||
"Les opérateurs :keyword:`in` et :keyword:`not in` testent l’appartenance. "
|
||
"``x in s`` s’évalue à ``True`` si *x* appartient à *s* et à ``False`` sinon. "
|
||
"``x not in s`` renvoie la négation de ``x in s``. Tous les types séquences "
|
||
"et ensembles natifs gèrent ces opérateurs, ainsi que les dictionnaires pour "
|
||
"lesquels :keyword:`!in` teste si dictionnaire possède une clé donnée. Pour "
|
||
"les types conteneurs tels que les listes, *n*-uplets (*tuple*), ensembles "
|
||
"(*set*), ensembles figés (*frozen set*), dictionnaires (*dict*) ou "
|
||
"*collections.deque*, l’expression ``x in y`` est équivalente à ``any(x is e "
|
||
"or x == e for e in y)``."
|
||
|
||
#: reference/expressions.rst:1560
|
||
msgid ""
|
||
"For the string and bytes types, ``x in y`` is ``True`` if and only if *x* is "
|
||
"a substring of *y*. An equivalent test is ``y.find(x) != -1``. Empty "
|
||
"strings are always considered to be a substring of any other string, so ``"
|
||
"\"\" in \"abc\"`` will return ``True``."
|
||
msgstr ""
|
||
"Pour les chaînes de caractères et chaînes d'octets, ``x in y`` vaut ``True`` "
|
||
"si et seulement si *x* est une sous-chaîne de *y*. Un test équivalent est "
|
||
"``y.find(x) != -1``. Une chaîne vide est considérée comme une sous-chaîne de "
|
||
"toute autre chaîne, ainsi ``\"\" in \"abc\"`` renvoie ``True``."
|
||
|
||
#: reference/expressions.rst:1565
|
||
msgid ""
|
||
"For user-defined classes which define the :meth:`__contains__` method, ``x "
|
||
"in y`` returns ``True`` if ``y.__contains__(x)`` returns a true value, and "
|
||
"``False`` otherwise."
|
||
msgstr ""
|
||
"Pour les classes allogènes qui définissent la méthode :meth:`__contains__`, "
|
||
"``x in y`` renvoie ``True`` si ``y.__contains__(x)`` renvoie vrai, et "
|
||
"``False`` sinon."
|
||
|
||
#: reference/expressions.rst:1569
|
||
msgid ""
|
||
"For user-defined classes which do not define :meth:`__contains__` but do "
|
||
"define :meth:`__iter__`, ``x in y`` is ``True`` if some value ``z``, for "
|
||
"which the expression ``x is z or x == z`` is true, is produced while "
|
||
"iterating over ``y``. If an exception is raised during the iteration, it is "
|
||
"as if :keyword:`in` raised that exception."
|
||
msgstr ""
|
||
"Pour les classes allogènes qui ne définissent pas :meth:`__contains__` mais "
|
||
"qui définissent :meth:`__iter__`, ``x in y`` vaut ``True`` s'il existe une "
|
||
"valeur ``z`` telle que l'expression ``x is z or x == z`` renvoie vrai lors "
|
||
"de l'itération sur ``y``. Si une exception est levée pendant l'itération, "
|
||
"c'est comme si :keyword:`in` avait levé cette exception."
|
||
|
||
#: reference/expressions.rst:1575
|
||
msgid ""
|
||
"Lastly, the old-style iteration protocol is tried: if a class defines :meth:"
|
||
"`__getitem__`, ``x in y`` is ``True`` if and only if there is a non-negative "
|
||
"integer index *i* such that ``x is y[i] or x == y[i]``, and no lower integer "
|
||
"index raises the :exc:`IndexError` exception. (If any other exception is "
|
||
"raised, it is as if :keyword:`in` raised that exception)."
|
||
msgstr ""
|
||
"Enfin, le protocole d'itération « à l'ancienne » est essayé : si la classe "
|
||
"définit :meth:`__getitem__`, ``x in y`` est ``True`` si et seulement si il "
|
||
"existe un entier positif ou nul *i*, représentant l'indice, tel que ``x is "
|
||
"y[i] or x == y[i]`` et qu'aucun indice inférieur ne lève d'exception :exc:"
|
||
"`IndexError` (si toute autre exception est levée, c'est comme si :keyword:"
|
||
"`in` avait levé cette exception)."
|
||
|
||
#: reference/expressions.rst:1587
|
||
msgid ""
|
||
"The operator :keyword:`not in` is defined to have the inverse truth value "
|
||
"of :keyword:`in`."
|
||
msgstr ""
|
||
"L'opérateur :keyword:`not in` est défini comme produisant le contraire de :"
|
||
"keyword:`in`."
|
||
|
||
#: reference/expressions.rst:1600
|
||
msgid "Identity comparisons"
|
||
msgstr "Comparaisons d'identifiants"
|
||
|
||
#: reference/expressions.rst:1602
|
||
msgid ""
|
||
"The operators :keyword:`is` and :keyword:`is not` test for an object's "
|
||
"identity: ``x is y`` is true if and only if *x* and *y* are the same "
|
||
"object. An Object's identity is determined using the :meth:`id` function. "
|
||
"``x is not y`` yields the inverse truth value. [#]_"
|
||
msgstr ""
|
||
"Les opérateurs :keyword:`is` et :keyword:`is not` testent l'égalité des "
|
||
"identifiants des objets : ``x is y`` est vrai si et seulement si *x* et *y* "
|
||
"sont le même objet. L'identifiant d'un objet est déterminé en utilisant la "
|
||
"fonction :meth:`id`. ``x is not y`` renvoie le résultat contraire de "
|
||
"l'égalité des identifiants [#]_."
|
||
|
||
#: reference/expressions.rst:1614
|
||
msgid "Boolean operations"
|
||
msgstr "Opérations booléennes"
|
||
|
||
#: reference/expressions.rst:1625
|
||
msgid ""
|
||
"In the context of Boolean operations, and also when expressions are used by "
|
||
"control flow statements, the following values are interpreted as false: "
|
||
"``False``, ``None``, numeric zero of all types, and empty strings and "
|
||
"containers (including strings, tuples, lists, dictionaries, sets and "
|
||
"frozensets). All other values are interpreted as true. User-defined "
|
||
"objects can customize their truth value by providing a :meth:`__bool__` "
|
||
"method."
|
||
msgstr ""
|
||
"Dans le contexte des opérations booléennes et quand des expressions sont "
|
||
"utilisées par des instructions de contrôle du flux d'exécution, les valeurs "
|
||
"suivantes sont considérées comme fausses : ``False``, ``None``, zéro quel "
|
||
"que soit le type, la chaîne vide et tout conteneur vide (y compris les "
|
||
"chaînes, *n*-uplets, listes, dictionnaires, ensembles, ensembles figés). "
|
||
"Toutes les autres valeurs sont considérées comme vraies. Les objets "
|
||
"allogènes peuvent personnaliser leur table de vérité en implémentant une "
|
||
"méthode :meth:`__bool__`."
|
||
|
||
#: reference/expressions.rst:1634
|
||
msgid ""
|
||
"The operator :keyword:`not` yields ``True`` if its argument is false, "
|
||
"``False`` otherwise."
|
||
msgstr ""
|
||
"L'opérateur :keyword:`not` produit ``True`` si son argument est faux, "
|
||
"``False`` sinon."
|
||
|
||
#: reference/expressions.rst:1639
|
||
msgid ""
|
||
"The expression ``x and y`` first evaluates *x*; if *x* is false, its value "
|
||
"is returned; otherwise, *y* is evaluated and the resulting value is returned."
|
||
msgstr ""
|
||
"L'expression ``x and y`` commence par évaluer *x* ; si *x* est faux, sa "
|
||
"valeur est renvoyée ; sinon, *y* est évalué et la valeur résultante est "
|
||
"renvoyée."
|
||
|
||
#: reference/expressions.rst:1644
|
||
msgid ""
|
||
"The expression ``x or y`` first evaluates *x*; if *x* is true, its value is "
|
||
"returned; otherwise, *y* is evaluated and the resulting value is returned."
|
||
msgstr ""
|
||
"L'expression ``x or y`` commence par évaluer *x* ; si *x* est vrai, sa "
|
||
"valeur est renvoyée ; sinon, *y* est évalué et la valeur résultante est "
|
||
"renvoyée."
|
||
|
||
#: reference/expressions.rst:1647
|
||
msgid ""
|
||
"Note that neither :keyword:`and` nor :keyword:`or` restrict the value and "
|
||
"type they return to ``False`` and ``True``, but rather return the last "
|
||
"evaluated argument. This is sometimes useful, e.g., if ``s`` is a string "
|
||
"that should be replaced by a default value if it is empty, the expression "
|
||
"``s or 'foo'`` yields the desired value. Because :keyword:`not` has to "
|
||
"create a new value, it returns a boolean value regardless of the type of its "
|
||
"argument (for example, ``not 'foo'`` produces ``False`` rather than ``''``.)"
|
||
msgstr ""
|
||
"Notez que ni :keyword:`and` ni :keyword:`or` ne restreignent la valeur et le "
|
||
"type qu'ils renvoient à ``False`` et ``True`` : ils renvoient le dernier "
|
||
"argument évalué. Ceci peut être utile, par exemple : si une chaîne ``s`` "
|
||
"doit être remplacée par une valeur par défaut si elle est vide, l'expression "
|
||
"``s or 'truc'`` produit la valeur voulue. Comme :keyword:`not` doit créer "
|
||
"une nouvelle valeur, il renvoie une valeur booléenne quel que soit le type "
|
||
"de son argument (par exemple, ``not 'truc'`` produit ``False`` plutôt que "
|
||
"``''``."
|
||
|
||
#: reference/expressions.rst:1657
|
||
msgid "Assignment expressions"
|
||
msgstr "Expressions d'affectation"
|
||
|
||
#: reference/expressions.rst:1662
|
||
msgid ""
|
||
"An assignment expression (sometimes also called a \"named expression\" or "
|
||
"\"walrus\") assigns an :token:`expression` to an :token:`identifier`, while "
|
||
"also returning the value of the :token:`expression`."
|
||
msgstr ""
|
||
|
||
#: reference/expressions.rst:1666
|
||
msgid "One common use case is when handling matched regular expressions:"
|
||
msgstr ""
|
||
|
||
#: reference/expressions.rst:1673
|
||
msgid "Or, when processing a file stream in chunks:"
|
||
msgstr ""
|
||
|
||
#: reference/expressions.rst:1680
|
||
msgid "See :pep:`572` for more details about assignment expressions."
|
||
msgstr ""
|
||
"Voir la :pep:`572` pour plus de détails sur les expressions d’affectation."
|
||
|
||
#: reference/expressions.rst:1687
|
||
msgid "Conditional expressions"
|
||
msgstr "Expressions conditionnelles"
|
||
|
||
#: reference/expressions.rst:1700
|
||
msgid ""
|
||
"Conditional expressions (sometimes called a \"ternary operator\") have the "
|
||
"lowest priority of all Python operations."
|
||
msgstr ""
|
||
"Les expressions conditionnelles (parfois appelées « opérateur ternaire ») "
|
||
"sont les moins prioritaires de toutes les opérations Python."
|
||
|
||
#: reference/expressions.rst:1703
|
||
msgid ""
|
||
"The expression ``x if C else y`` first evaluates the condition, *C* rather "
|
||
"than *x*. If *C* is true, *x* is evaluated and its value is returned; "
|
||
"otherwise, *y* is evaluated and its value is returned."
|
||
msgstr ""
|
||
"L'expression ``x if C else y`` commence par évaluer la condition *C*. Si *C* "
|
||
"est vrai, alors *x* est évalué et sa valeur est renvoyée ; sinon, *y* est "
|
||
"évalué et sa valeur est renvoyée."
|
||
|
||
#: reference/expressions.rst:1707
|
||
msgid "See :pep:`308` for more details about conditional expressions."
|
||
msgstr ""
|
||
"Voir la :pep:`308` pour plus de détails sur les expressions conditionnelles."
|
||
|
||
#: reference/expressions.rst:1714
|
||
msgid "Lambdas"
|
||
msgstr "Expressions lambda"
|
||
|
||
#: reference/expressions.rst:1726
|
||
msgid ""
|
||
"Lambda expressions (sometimes called lambda forms) are used to create "
|
||
"anonymous functions. The expression ``lambda parameters: expression`` yields "
|
||
"a function object. The unnamed object behaves like a function object "
|
||
"defined with:"
|
||
msgstr ""
|
||
"Les expressions lambda sont utilisées pour créer des fonctions anonymes. "
|
||
"L'expression ``lambda parameters: expression`` produit un objet fonction. "
|
||
"Cet objet anonyme se comporte comme un objet fonction défini par :"
|
||
|
||
#: reference/expressions.rst:1735
|
||
msgid ""
|
||
"See section :ref:`function` for the syntax of parameter lists. Note that "
|
||
"functions created with lambda expressions cannot contain statements or "
|
||
"annotations."
|
||
msgstr ""
|
||
"Voir la section :ref:`function` pour la syntaxe des listes de paramètres. "
|
||
"Notez que les fonctions créées par des expressions lambda ne peuvent pas "
|
||
"contenir d'instructions ou d'annotations."
|
||
|
||
#: reference/expressions.rst:1743
|
||
msgid "Expression lists"
|
||
msgstr "Listes d'expressions"
|
||
|
||
#: reference/expressions.rst:1757
|
||
msgid ""
|
||
"Except when part of a list or set display, an expression list containing at "
|
||
"least one comma yields a tuple. The length of the tuple is the number of "
|
||
"expressions in the list. The expressions are evaluated from left to right."
|
||
msgstr ""
|
||
"Sauf lorsqu'elle fait partie d'un agencement de liste ou d'ensemble, une "
|
||
"liste d'expressions qui contient au moins une virgule produit un *n*-uplet. "
|
||
"La longueur du *n*-uplet est le nombre d'expressions dans la liste. Les "
|
||
"expressions sont évaluées de la gauche vers la droite."
|
||
|
||
#: reference/expressions.rst:1766
|
||
msgid ""
|
||
"An asterisk ``*`` denotes :dfn:`iterable unpacking`. Its operand must be "
|
||
"an :term:`iterable`. The iterable is expanded into a sequence of items, "
|
||
"which are included in the new tuple, list, or set, at the site of the "
|
||
"unpacking."
|
||
msgstr ""
|
||
"Un astérisque ``*`` indique :dfn:`dépaquetage d'itérable` (*iterable "
|
||
"unpacking* en anglais). Son opérande doit être un :term:`iterable`. "
|
||
"L'itérable est développé en une séquence d'éléments qui sont inclus dans un "
|
||
"nouvel objet *n*-uplet, liste ou ensemble à l'emplacement du dépaquetage."
|
||
|
||
#: reference/expressions.rst:1771
|
||
msgid ""
|
||
"Iterable unpacking in expression lists, originally proposed by :pep:`448`."
|
||
msgstr ""
|
||
"dépaquetage d'itérables dans les listes d'expressions, proposé à l'origine "
|
||
"par la :pep:`448`."
|
||
|
||
#: reference/expressions.rst:1776
|
||
msgid ""
|
||
"The trailing comma is required only to create a single tuple (a.k.a. a "
|
||
"*singleton*); it is optional in all other cases. A single expression "
|
||
"without a trailing comma doesn't create a tuple, but rather yields the value "
|
||
"of that expression. (To create an empty tuple, use an empty pair of "
|
||
"parentheses: ``()``.)"
|
||
msgstr ""
|
||
"La virgule finale est nécessaire pour créer un singleton (c'est-à-dire un n-"
|
||
"uplet composé d'un seul élément) : elle est optionnelle dans tous les autres "
|
||
"cas. Une expression seule sans virgule finale ne crée pas un *n*-uplet mais "
|
||
"produit la valeur de cette expression (pour créer un *n*-uplet vide, "
|
||
"utilisez une paire de parenthèses vide : ``()``)."
|
||
|
||
#: reference/expressions.rst:1786
|
||
msgid "Evaluation order"
|
||
msgstr "Ordre d'évaluation"
|
||
|
||
#: reference/expressions.rst:1790
|
||
msgid ""
|
||
"Python evaluates expressions from left to right. Notice that while "
|
||
"evaluating an assignment, the right-hand side is evaluated before the left-"
|
||
"hand side."
|
||
msgstr ""
|
||
"Python évalue les expressions de la gauche vers la droite. Remarquez que "
|
||
"lors de l'évaluation d'une assignation, la partie droite de l'assignation "
|
||
"est évaluée avant la partie gauche."
|
||
|
||
#: reference/expressions.rst:1793
|
||
msgid ""
|
||
"In the following lines, expressions will be evaluated in the arithmetic "
|
||
"order of their suffixes::"
|
||
msgstr ""
|
||
"Dans les lignes qui suivent, les expressions sont évaluées suivant l'ordre "
|
||
"arithmétique de leurs suffixes ::"
|
||
|
||
#: reference/expressions.rst:1807
|
||
msgid "Operator precedence"
|
||
msgstr "Priorités des opérateurs"
|
||
|
||
#: reference/expressions.rst:1812
|
||
msgid ""
|
||
"The following table summarizes the operator precedence in Python, from "
|
||
"lowest precedence (least binding) to highest precedence (most binding). "
|
||
"Operators in the same box have the same precedence. Unless the syntax is "
|
||
"explicitly given, operators are binary. Operators in the same box group "
|
||
"left to right (except for exponentiation, which groups from right to left)."
|
||
msgstr ""
|
||
"Le tableau suivant résume les priorités des opérateurs en Python, du moins "
|
||
"prioritaire au plus prioritaire. 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 cases regroupent "
|
||
"de la gauche vers la droite (sauf pour la puissance qui regroupe de la "
|
||
"droite vers la gauche)."
|
||
|
||
#: reference/expressions.rst:1818
|
||
msgid ""
|
||
"Note that comparisons, membership tests, and identity tests, all have the "
|
||
"same precedence and have a left-to-right chaining feature as described in "
|
||
"the :ref:`comparisons` section."
|
||
msgstr ""
|
||
"Notez que les comparaisons, les tests d'appartenance et les tests "
|
||
"d'identifiants possèdent tous la même priorité et s'enchaînent de la gauche "
|
||
"vers la droite comme décrit dans la section :ref:`comparisons`."
|
||
|
||
#: reference/expressions.rst:1824
|
||
msgid "Operator"
|
||
msgstr "Opérateur"
|
||
|
||
#: reference/expressions.rst:1824
|
||
msgid "Description"
|
||
msgstr "Description"
|
||
|
||
#: reference/expressions.rst:1826
|
||
msgid "``:=``"
|
||
msgstr "``:=``"
|
||
|
||
#: reference/expressions.rst:1826
|
||
msgid "Assignment expression"
|
||
msgstr "Expression d'affectation"
|
||
|
||
#: reference/expressions.rst:1828
|
||
msgid ":keyword:`lambda`"
|
||
msgstr ":keyword:`lambda`"
|
||
|
||
#: reference/expressions.rst:1828
|
||
msgid "Lambda expression"
|
||
msgstr "Expression lambda"
|
||
|
||
#: reference/expressions.rst:1830
|
||
msgid ":keyword:`if <if_expr>` -- :keyword:`!else`"
|
||
msgstr ":keyword:`if <if_expr>` -- :keyword:`!else`"
|
||
|
||
#: reference/expressions.rst:1830
|
||
msgid "Conditional expression"
|
||
msgstr "Expressions conditionnelle"
|
||
|
||
#: reference/expressions.rst:1832
|
||
msgid ":keyword:`or`"
|
||
msgstr ":keyword:`or`"
|
||
|
||
#: reference/expressions.rst:1832
|
||
msgid "Boolean OR"
|
||
msgstr "OR (booléen)"
|
||
|
||
#: reference/expressions.rst:1834
|
||
msgid ":keyword:`and`"
|
||
msgstr ":keyword:`and`"
|
||
|
||
#: reference/expressions.rst:1834
|
||
msgid "Boolean AND"
|
||
msgstr "AND (booléen)"
|
||
|
||
#: reference/expressions.rst:1836
|
||
msgid ":keyword:`not` ``x``"
|
||
msgstr ":keyword:`not` ``x``"
|
||
|
||
#: reference/expressions.rst:1836
|
||
msgid "Boolean NOT"
|
||
msgstr "NOT (booléen)"
|
||
|
||
#: reference/expressions.rst:1838
|
||
msgid ""
|
||
":keyword:`in`, :keyword:`not in`, :keyword:`is`, :keyword:`is not`, ``<``, "
|
||
"``<=``, ``>``, ``>=``, ``!=``, ``==``"
|
||
msgstr ""
|
||
":keyword:`in`, :keyword:`not in`, :keyword:`is`, :keyword:`is not`, ``<``, "
|
||
"``<=``, ``>``, ``>=``, ``!=``, ``==``"
|
||
|
||
#: reference/expressions.rst:1838
|
||
msgid "Comparisons, including membership tests and identity tests"
|
||
msgstr ""
|
||
"Comparaisons, y compris les tests d'appartenance et les tests d'identifiants"
|
||
|
||
#: reference/expressions.rst:1842
|
||
msgid "``|``"
|
||
msgstr "``|``"
|
||
|
||
#: reference/expressions.rst:1842
|
||
msgid "Bitwise OR"
|
||
msgstr "OR (bit à bit)"
|
||
|
||
#: reference/expressions.rst:1844
|
||
msgid "``^``"
|
||
msgstr "``^``"
|
||
|
||
#: reference/expressions.rst:1844
|
||
msgid "Bitwise XOR"
|
||
msgstr "XOR (bit à bit)"
|
||
|
||
#: reference/expressions.rst:1846
|
||
msgid "``&``"
|
||
msgstr "``&``"
|
||
|
||
#: reference/expressions.rst:1846
|
||
msgid "Bitwise AND"
|
||
msgstr "AND (bit à bit)"
|
||
|
||
#: reference/expressions.rst:1848
|
||
msgid "``<<``, ``>>``"
|
||
msgstr "``<<``, ``>>``"
|
||
|
||
#: reference/expressions.rst:1848
|
||
msgid "Shifts"
|
||
msgstr "décalages"
|
||
|
||
#: reference/expressions.rst:1850
|
||
msgid "``+``, ``-``"
|
||
msgstr "``+``, ``-``"
|
||
|
||
#: reference/expressions.rst:1850
|
||
msgid "Addition and subtraction"
|
||
msgstr "Addition et soustraction"
|
||
|
||
#: reference/expressions.rst:1852
|
||
msgid "``*``, ``@``, ``/``, ``//``, ``%``"
|
||
msgstr "``*``, ``@``, ``/``, ``//``, ``%``"
|
||
|
||
#: reference/expressions.rst:1852
|
||
msgid ""
|
||
"Multiplication, matrix multiplication, division, floor division, remainder "
|
||
"[#]_"
|
||
msgstr ""
|
||
"Multiplication, multiplication de matrices, division, division entière, "
|
||
"reste [#]_"
|
||
|
||
#: reference/expressions.rst:1856
|
||
msgid "``+x``, ``-x``, ``~x``"
|
||
msgstr "``+x``, ``-x``, ``~x``"
|
||
|
||
#: reference/expressions.rst:1856
|
||
msgid "Positive, negative, bitwise NOT"
|
||
msgstr "NOT (positif, négatif, bit à bit)"
|
||
|
||
#: reference/expressions.rst:1858
|
||
msgid "``**``"
|
||
msgstr "``**``"
|
||
|
||
#: reference/expressions.rst:1858
|
||
msgid "Exponentiation [#]_"
|
||
msgstr "Puissance [#]_"
|
||
|
||
#: reference/expressions.rst:1860
|
||
msgid ":keyword:`await` ``x``"
|
||
msgstr ":keyword:`await` ``x``"
|
||
|
||
#: reference/expressions.rst:1862
|
||
msgid "``x[index]``, ``x[index:index]``, ``x(arguments...)``, ``x.attribute``"
|
||
msgstr ""
|
||
"``x[indice]``, ``x[indice:indice]``, ``x(arguments...)``, ``x.attribut``"
|
||
|
||
#: reference/expressions.rst:1862
|
||
msgid "Subscription, slicing, call, attribute reference"
|
||
msgstr "indiçage, tranches, appel, référence à un attribut"
|
||
|
||
#: reference/expressions.rst:1865
|
||
msgid "``(expressions...)``,"
|
||
msgstr "``(expressions...)``,"
|
||
|
||
#: reference/expressions.rst:1867
|
||
msgid "``[expressions...]``, ``{key: value...}``, ``{expressions...}``"
|
||
msgstr "``[expressions...]``, ``{key: value...}``, ``{expressions...}``"
|
||
|
||
#: reference/expressions.rst:1865
|
||
msgid ""
|
||
"Binding or parenthesized expression, list display, dictionary display, set "
|
||
"display"
|
||
msgstr ""
|
||
"Expression de liaison ou parenthèse, affichage de liste, affichage de "
|
||
"dictionnaire, affichage de *set*"
|
||
|
||
#: reference/expressions.rst:1874
|
||
msgid "Footnotes"
|
||
msgstr "Notes"
|
||
|
||
#: reference/expressions.rst:1875
|
||
msgid ""
|
||
"While ``abs(x%y) < abs(y)`` is true mathematically, for floats it may not be "
|
||
"true numerically due to roundoff. For example, and assuming a platform on "
|
||
"which a Python float is an IEEE 754 double-precision number, in order that "
|
||
"``-1e-100 % 1e100`` have the same sign as ``1e100``, the computed result is "
|
||
"``-1e-100 + 1e100``, which is numerically exactly equal to ``1e100``. The "
|
||
"function :func:`math.fmod` returns a result whose sign matches the sign of "
|
||
"the first argument instead, and so returns ``-1e-100`` in this case. Which "
|
||
"approach is more appropriate depends on the application."
|
||
msgstr ""
|
||
"Bien que ``abs(x%y) < abs(y)`` soit vrai mathématiquement, ce n'est pas "
|
||
"toujours vrai pour les nombres à virgule flottante en raison des arrondis. "
|
||
"Par exemple, en supposant que Python tourne sur une plateforme où les "
|
||
"*float* sont des nombres à double précision IEEE 754, afin que ``-1e-100 % "
|
||
"1e100`` soit du même signe que ``1e100``, le résultat calculé est ``-1e-100 "
|
||
"+ 1e100``, qui vaut exactement ``1e100`` dans ce standard. Or, la fonction :"
|
||
"func:`math.fmod` renvoie un résultat dont le signe est le signe du premier "
|
||
"argument, c'est-à-dire ``-1e-100`` dans ce cas. La meilleure approche dépend "
|
||
"de l'application."
|
||
|
||
#: reference/expressions.rst:1884
|
||
msgid ""
|
||
"If x is very close to an exact integer multiple of y, it's possible for ``x//"
|
||
"y`` to be one larger than ``(x-x%y)//y`` due to rounding. In such cases, "
|
||
"Python returns the latter result, in order to preserve that ``divmod(x,y)[0] "
|
||
"* y + x % y`` be very close to ``x``."
|
||
msgstr ""
|
||
"Si x est très proche d'un multiple entier de y, il est possible que ``x/y`` "
|
||
"soit supérieur de un par rapport à ``(x-x%y)//y`` en raison des arrondis. "
|
||
"Dans de tels cas, Python renvoie le second résultat afin d'avoir ``divmod(x,"
|
||
"y)[0] * y + x % y`` le plus proche de ``x``."
|
||
|
||
#: reference/expressions.rst:1889
|
||
msgid ""
|
||
"The Unicode standard distinguishes between :dfn:`code points` (e.g. U+0041) "
|
||
"and :dfn:`abstract characters` (e.g. \"LATIN CAPITAL LETTER A\"). While most "
|
||
"abstract characters in Unicode are only represented using one code point, "
|
||
"there is a number of abstract characters that can in addition be represented "
|
||
"using a sequence of more than one code point. For example, the abstract "
|
||
"character \"LATIN CAPITAL LETTER C WITH CEDILLA\" can be represented as a "
|
||
"single :dfn:`precomposed character` at code position U+00C7, or as a "
|
||
"sequence of a :dfn:`base character` at code position U+0043 (LATIN CAPITAL "
|
||
"LETTER C), followed by a :dfn:`combining character` at code position U+0327 "
|
||
"(COMBINING CEDILLA)."
|
||
msgstr ""
|
||
"Le standard Unicode distingue les :dfn:`points codes` (*code points* en "
|
||
"anglais, par exemple *U+0041*) et les :dfn:`caractères abstraits` (*abstract "
|
||
"characters* en anglais, par exemple « LATIN CAPITAL LETTER A »). Bien que la "
|
||
"plupart des caractères abstraits de l'Unicode ne sont représentés que par un "
|
||
"seul point code, il y a un certain nombre de caractères abstraits qui "
|
||
"peuvent être représentés par une séquence de plus qu'un point code. Par "
|
||
"exemple, le caractère abstrait « LATIN CAPITAL LETTER C WITH CEDILLA » peut "
|
||
"être représenté comme un unique :dfn:`caractère précomposé` au point code *U"
|
||
"+00C7*, ou en tant que séquence d'un :dfn:`caractère de base` à la position "
|
||
"*U+0043* (LATIN CAPITAL LETTER C) du code, suivi par un :dfn:`caractère "
|
||
"combiné` à la position *U+0327* (*COMBINING CEDILLA*) du code."
|
||
|
||
#: reference/expressions.rst:1900
|
||
msgid ""
|
||
"The comparison operators on strings compare at the level of Unicode code "
|
||
"points. This may be counter-intuitive to humans. For example, ``\"\\u00C7\" "
|
||
"== \"\\u0043\\u0327\"`` is ``False``, even though both strings represent the "
|
||
"same abstract character \"LATIN CAPITAL LETTER C WITH CEDILLA\"."
|
||
msgstr ""
|
||
"Les opérateurs de comparaison des chaînes opèrent au niveau des points codes "
|
||
"Unicode. Cela peut être déroutant pour des humains. Par exemple, ``"
|
||
"\"\\u00C7\" == \"\\u0043\\u0327\"`` renvoie ``False``, bien que les deux "
|
||
"chaînes représentent le même caractère abstrait \"LATIN CAPITAL LETTER C "
|
||
"WITH CEDILLA\"."
|
||
|
||
#: reference/expressions.rst:1905
|
||
msgid ""
|
||
"To compare strings at the level of abstract characters (that is, in a way "
|
||
"intuitive to humans), use :func:`unicodedata.normalize`."
|
||
msgstr ""
|
||
"Pour comparer des chaînes au niveau des caractères abstraits (afin d'avoir "
|
||
"quelque chose d'intuitif pour les humains), utilisez :func:`unicodedata."
|
||
"normalize`."
|
||
|
||
#: reference/expressions.rst:1908
|
||
msgid ""
|
||
"Due to automatic garbage-collection, free lists, and the dynamic nature of "
|
||
"descriptors, you may notice seemingly unusual behaviour in certain uses of "
|
||
"the :keyword:`is` operator, like those involving comparisons between "
|
||
"instance methods, or constants. Check their documentation for more info."
|
||
msgstr ""
|
||
"En raison du ramasse-miettes automatique et de la nature dynamique des "
|
||
"descripteurs, vous pouvez être confronté à un comportement semblant bizarre "
|
||
"lors de certaines utilisations de l'opérateur :keyword:`is`, par exemple si "
|
||
"cela implique des comparaisons entre des méthodes d'instances ou des "
|
||
"constantes. Allez vérifier dans la documentation pour plus d'informations."
|
||
|
||
#: reference/expressions.rst:1913
|
||
msgid ""
|
||
"The ``%`` operator is also used for string formatting; the same precedence "
|
||
"applies."
|
||
msgstr ""
|
||
"L'opérateur ``%`` est aussi utilisé pour formater les chaînes de "
|
||
"caractères ; il y possède la même priorité."
|
||
|
||
#: reference/expressions.rst:1916
|
||
msgid ""
|
||
"The power operator ``**`` binds less tightly than an arithmetic or bitwise "
|
||
"unary operator on its right, that is, ``2**-1`` is ``0.5``."
|
||
msgstr ""
|
||
"L'opérateur puissance ``**`` est moins prioritaire qu'un opérateur unaire "
|
||
"arithmétique ou bit à bit sur sa droite. Ainsi, ``2**-1`` vaut ``0.5``."
|