forked from AFPy/python-docs-fr
1242 lines
56 KiB
Plaintext
1242 lines
56 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 1990-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
#, fuzzy
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 2.7\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
|
||
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:6
|
||
msgid "Simple statements"
|
||
msgstr "Les instructions simples"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:10
|
||
msgid ""
|
||
"Simple statements are comprised within a single logical line. Several simple "
|
||
"statements may occur on a single line separated by semicolons. The syntax "
|
||
"for simple statements is:"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:35
|
||
msgid "Expression statements"
|
||
msgstr "Les expressions"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:41
|
||
msgid ""
|
||
"Expression statements are used (mostly interactively) to compute and write a "
|
||
"value, or (usually) to call a procedure (a function that returns no "
|
||
"meaningful result; in Python, procedures return the value ``None``). Other "
|
||
"uses of expression statements are allowed and occasionally useful. The "
|
||
"syntax for an expression statement is:"
|
||
msgstr ""
|
||
"Les expressions sont utilisées (généralement de manière interactive) comme "
|
||
"instructions pour calculer et écrire des valeurs, appeler une procédure (une "
|
||
"fonction dont le résultat renvoyé n'a pas d'importance ; en Python, les "
|
||
"procédures renvoient la valeur ``None``). D'autres utilisations des "
|
||
"expressions sont autorisées et parfois utiles. La syntaxe pour une "
|
||
"expression en tant qu'instruction est :"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:50
|
||
msgid ""
|
||
"An expression statement evaluates the expression list (which may be a single "
|
||
"expression)."
|
||
msgstr ""
|
||
"Ce genre d'instruction évalue la liste d'expressions (qui peut se limiter à "
|
||
"une seule expression)."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:62
|
||
msgid ""
|
||
"In interactive mode, if the value is not ``None``, it is converted to a "
|
||
"string using the built-in :func:`repr` function and the resulting string is "
|
||
"written to standard output (see section :ref:`print`) on a line by itself. "
|
||
"(Expression statements yielding ``None`` are not written, so that procedure "
|
||
"calls do not cause any output.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:72
|
||
msgid "Assignment statements"
|
||
msgstr "Les assignations"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:82
|
||
msgid ""
|
||
"Assignment statements are used to (re)bind names to values and to modify "
|
||
"attributes or items of mutable objects:"
|
||
msgstr ""
|
||
"Les assignations sont utilisées pour lier ou relier des noms à des valeurs "
|
||
"et modifier des attributs ou des éléments d'objets muables :"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:95 ../Doc/reference/simple_stmts.rst:267
|
||
msgid ""
|
||
"(See section :ref:`primaries` for the syntax definitions for the last three "
|
||
"symbols.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:100
|
||
msgid ""
|
||
"An assignment statement evaluates the expression list (remember that this "
|
||
"can be a single expression or a comma-separated list, the latter yielding a "
|
||
"tuple) and assigns the single resulting object to each of the target lists, "
|
||
"from left to right."
|
||
msgstr ""
|
||
"Une assignation évalue la liste d'expressions (gardez en mémoire que ce peut "
|
||
"être une simple expression ou une liste dont les éléments sont séparés par "
|
||
"des virgules, cette dernière produisant un n-uplet) et assigne l'unique "
|
||
"objet résultant à chaque liste cible, de la gauche vers la droite."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:109
|
||
msgid ""
|
||
"Assignment is defined recursively depending on the form of the target "
|
||
"(list). When a target is part of a mutable object (an attribute reference, "
|
||
"subscription or slicing), the mutable object must ultimately perform the "
|
||
"assignment and decide about its validity, and may raise an exception if the "
|
||
"assignment is unacceptable. The rules observed by various types and the "
|
||
"exceptions raised are given with the definition of the object types (see "
|
||
"section :ref:`types`)."
|
||
msgstr ""
|
||
"Une assignation est définie récursivement en fonction de la forme de la "
|
||
"cible (une liste). Quand la cible est une partie d'un objet muable (une "
|
||
"référence à un attribut, une sélection ou une tranche), l'objet muable doit "
|
||
"effectuer l'assignation au final et décider de sa validité, voire lever une "
|
||
"exception si l'assignation n'est pas acceptable. Les règles suivies par les "
|
||
"différents types et les exceptions levées sont données dans les définitions "
|
||
"des types d'objets (voir la section :ref:`types`)."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:118
|
||
msgid ""
|
||
"Assignment of an object to a target list is recursively defined as follows."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:120
|
||
msgid ""
|
||
"If the target list is a single target: The object is assigned to that target."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:122
|
||
msgid ""
|
||
"If the target list is a comma-separated list of targets: The object must be "
|
||
"an iterable with the same number of items as there are targets in the target "
|
||
"list, and the items are assigned, from left to right, to the corresponding "
|
||
"targets."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:126
|
||
msgid ""
|
||
"Assignment of an object to a single target is recursively defined as follows."
|
||
msgstr ""
|
||
"L'assignation d'un objet vers une cible unique est définie récursivement "
|
||
"comme suit."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:128
|
||
msgid "If the target is an identifier (name):"
|
||
msgstr "Si la cible est une variable (un nom) :"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:132
|
||
msgid ""
|
||
"If the name does not occur in a :keyword:`global` statement in the current "
|
||
"code block: the name is bound to the object in the current local namespace."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:135
|
||
msgid ""
|
||
"Otherwise: the name is bound to the object in the current global namespace."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:139
|
||
msgid ""
|
||
"The name is rebound if it was already bound. This may cause the reference "
|
||
"count for the object previously bound to the name to reach zero, causing the "
|
||
"object to be deallocated and its destructor (if it has one) to be called."
|
||
msgstr ""
|
||
"Le lien du nom est modifié si le nom était déjà lié. Ceci peut faire que le "
|
||
"compteur de références de l'objet auquel le nom était précédemment lié tombe "
|
||
"à zéro, entrainant la dé-allocation de l'objet et l'appel de son destructeur "
|
||
"(s'il existe)."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:143
|
||
msgid ""
|
||
"If the target is a target list enclosed in parentheses or in square "
|
||
"brackets: The object must be an iterable with the same number of items as "
|
||
"there are targets in the target list, and its items are assigned, from left "
|
||
"to right, to the corresponding targets."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:150
|
||
msgid ""
|
||
"If the target is an attribute reference: The primary expression in the "
|
||
"reference is evaluated. It should yield an object with assignable "
|
||
"attributes; if this is not the case, :exc:`TypeError` is raised. That "
|
||
"object is then asked to assign the assigned object to the given attribute; "
|
||
"if it cannot perform the assignment, it raises an exception (usually but not "
|
||
"necessarily :exc:`AttributeError`)."
|
||
msgstr ""
|
||
"Si la cible est une référence à un attribut : l'expression primaire de la "
|
||
"référence est évaluée. Elle doit produire un objet avec des attributs que "
|
||
"l'on peut assigner : si ce n'est pas le cas, une :exc:`TypeError` est levée. "
|
||
"Python demande alors à cet objet d'assigner l'attribut donné ; si ce n'est "
|
||
"pas possible, une exception est levée (habituellement, mais pas "
|
||
"nécessairement, :exc:`AttributeError`)."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:159
|
||
msgid ""
|
||
"Note: If the object is a class instance and the attribute reference occurs "
|
||
"on both sides of the assignment operator, the RHS expression, ``a.x`` can "
|
||
"access either an instance attribute or (if no instance attribute exists) a "
|
||
"class attribute. The LHS target ``a.x`` is always set as an instance "
|
||
"attribute, creating it if necessary. Thus, the two occurrences of ``a.x`` "
|
||
"do not necessarily refer to the same attribute: if the RHS expression refers "
|
||
"to a class attribute, the LHS creates a new instance attribute as the target "
|
||
"of the assignment::"
|
||
msgstr ""
|
||
"Note : si l'objet est une instance de classe et que la référence à "
|
||
"l'attribut apparaît des deux côtés de l'opérateur d'assignation, "
|
||
"l'expression \"à droite\", ``a.x`` peut accéder soit à l'attribut d'instance "
|
||
"ou (si cet attribut d'instance n'existe pas) à l'attribut de classe. "
|
||
"L'expression cible \"à gauche\" ``a.x`` est toujours définie comme un "
|
||
"attribut d'instance, en le créant si nécessaire. Ainsi, les deux occurrences "
|
||
"de ``a.x`` ne font pas nécessairement référence au même attribut : si "
|
||
"l'expression \"à droite\" fait référence à un attribut de classe, "
|
||
"l'expression \"à gauche\" crée un nouvel attribut d'instance comme cible de "
|
||
"l'assignation ::"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:173
|
||
msgid ""
|
||
"This description does not necessarily apply to descriptor attributes, such "
|
||
"as properties created with :func:`property`."
|
||
msgstr ""
|
||
"Cette description ne s'applique pas nécessairement aux attributs des "
|
||
"descripteurs, telles que les propriétés créées avec :func:`property`."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:180
|
||
msgid ""
|
||
"If the target is a subscription: The primary expression in the reference is "
|
||
"evaluated. It should yield either a mutable sequence object (such as a "
|
||
"list) or a mapping object (such as a dictionary). Next, the subscript "
|
||
"expression is evaluated."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:189
|
||
msgid ""
|
||
"If the primary is a mutable sequence object (such as a list), the subscript "
|
||
"must yield a plain integer. If it is negative, the sequence's length is "
|
||
"added to it. The resulting value must be a nonnegative integer less than the "
|
||
"sequence's length, and the sequence is asked to assign the assigned object "
|
||
"to its item with that index. If the index is out of range, :exc:"
|
||
"`IndexError` is raised (assignment to a subscripted sequence cannot add new "
|
||
"items to a list)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:200
|
||
msgid ""
|
||
"If the primary is a mapping object (such as a dictionary), the subscript "
|
||
"must have a type compatible with the mapping's key type, and the mapping is "
|
||
"then asked to create a key/datum pair which maps the subscript to the "
|
||
"assigned object. This can either replace an existing key/value pair with "
|
||
"the same key value, or insert a new key/value pair (if no key with the same "
|
||
"value existed)."
|
||
msgstr ""
|
||
"Si la primaire est un objet tableau de correspondances (tel qu'un "
|
||
"dictionnaire), la sélection doit être d'un type compatible avec le type des "
|
||
"clés ; Python demande alors au tableau de correspondances de créer un couple "
|
||
"clé-valeur qui associe la sélection à l'objet assigné. Ceci peut remplacer "
|
||
"une correspondance déjà existante pour une clé donnée ou insérer un nouveau "
|
||
"couple clé-valeur."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:208
|
||
msgid ""
|
||
"If the target is a slicing: The primary expression in the reference is "
|
||
"evaluated. It should yield a mutable sequence object (such as a list). The "
|
||
"assigned object should be a sequence object of the same type. Next, the "
|
||
"lower and upper bound expressions are evaluated, insofar they are present; "
|
||
"defaults are zero and the sequence's length. The bounds should evaluate to "
|
||
"(small) integers. If either bound is negative, the sequence's length is "
|
||
"added to it. The resulting bounds are clipped to lie between zero and the "
|
||
"sequence's length, inclusive. Finally, the sequence object is asked to "
|
||
"replace the slice with the items of the assigned sequence. The length of "
|
||
"the slice may be different from the length of the assigned sequence, thus "
|
||
"changing the length of the target sequence, if the object allows it."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:222
|
||
msgid ""
|
||
"In the current implementation, the syntax for targets is taken to be the "
|
||
"same as for expressions, and invalid syntax is rejected during the code "
|
||
"generation phase, causing less detailed error messages."
|
||
msgstr ""
|
||
"Dans l'implémentation actuelle, la syntaxe pour les cibles est similaire à "
|
||
"celle des expressions. Toute syntaxe invalide est rejetée pendant la phase "
|
||
"de génération de code, ce qui produit des messages d'erreurs moins détaillés."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:226
|
||
msgid ""
|
||
"WARNING: Although the definition of assignment implies that overlaps between "
|
||
"the left-hand side and the right-hand side are 'safe' (for example ``a, b = "
|
||
"b, a`` swaps two variables), overlaps *within* the collection of assigned-to "
|
||
"variables are not safe! For instance, the following program prints ``[0, "
|
||
"2]``::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:240
|
||
msgid "Augmented assignment statements"
|
||
msgstr "Les assignations augmentées"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:258
|
||
msgid ""
|
||
"Augmented assignment is the combination, in a single statement, of a binary "
|
||
"operation and an assignment statement:"
|
||
msgstr ""
|
||
"Une assignation augmentée est la combinaison, dans une seule instruction, "
|
||
"d'une opération binaire et d'une assignation :"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:270
|
||
msgid ""
|
||
"An augmented assignment evaluates the target (which, unlike normal "
|
||
"assignment statements, cannot be an unpacking) and the expression list, "
|
||
"performs the binary operation specific to the type of assignment on the two "
|
||
"operands, and assigns the result to the original target. The target is only "
|
||
"evaluated once."
|
||
msgstr ""
|
||
"Une assignation augmentée évalue la cible (qui, au contraire des "
|
||
"assignations normales, ne peut pas être un dépaquetage) et la liste "
|
||
"d'expressions, effectue l'opération binaire (spécifique au type "
|
||
"d'assignation) sur les deux opérandes et assigne le résultat à la cible "
|
||
"originale. La cible n'est évaluée qu'une seule fois."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:275
|
||
msgid ""
|
||
"An augmented assignment expression like ``x += 1`` can be rewritten as ``x = "
|
||
"x + 1`` to achieve a similar, but not exactly equal effect. In the augmented "
|
||
"version, ``x`` is only evaluated once. Also, when possible, the actual "
|
||
"operation is performed *in-place*, meaning that rather than creating a new "
|
||
"object and assigning that to the target, the old object is modified instead."
|
||
msgstr ""
|
||
"Une assignation augmentée comme ``x += 1`` peut être ré-écrite en ``x = x + "
|
||
"1`` pour obtenir un effet similaire, mais pas exactement équivalent. Dans la "
|
||
"version augmentée. ``x`` n'est évalué qu'une seule fois. Aussi, lorsque "
|
||
"c'est possible, l'opération concrète est effectuée *sur place*, c'est-à-dire "
|
||
"que plutôt que de créer un nouvel objet et l'assigner à la cible, c'est le "
|
||
"vieil objet qui est modifié."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:281
|
||
msgid ""
|
||
"With the exception of assigning to tuples and multiple targets in a single "
|
||
"statement, the assignment done by augmented assignment statements is handled "
|
||
"the same way as normal assignments. Similarly, with the exception of the "
|
||
"possible *in-place* behavior, the binary operation performed by augmented "
|
||
"assignment is the same as the normal binary operations."
|
||
msgstr ""
|
||
"À l'exception de l'assignation de tuples et de cibles multiples dans une "
|
||
"seule instruction, l'assignation effectuée par une assignation augmentée est "
|
||
"traitée de la même manière qu'une assignation normale. De même, à "
|
||
"l'exception du comportement possible *sur place*, l'opération binaire "
|
||
"effectuée par assignation augmentée est la même que les opérations binaires "
|
||
"normales."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:287
|
||
msgid ""
|
||
"For targets which are attribute references, the same :ref:`caveat about "
|
||
"class and instance attributes <attr-target-note>` applies as for regular "
|
||
"assignments."
|
||
msgstr ""
|
||
"Pour les cibles qui sont des références à des attributs, la même :ref:`mise "
|
||
"en garde sur les attributs de classe et d'instances <attr-target-note>` "
|
||
"s'applique que pour les assignations normales."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:294
|
||
msgid "The :keyword:`assert` statement"
|
||
msgstr "L'instruction :keyword:`assert`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:300
|
||
msgid ""
|
||
"Assert statements are a convenient way to insert debugging assertions into a "
|
||
"program:"
|
||
msgstr ""
|
||
"Les instructions ``assert`` sont une manière pratique d'insérer des tests de "
|
||
"débogage au sein d'un programme :"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:306
|
||
msgid "The simple form, ``assert expression``, is equivalent to ::"
|
||
msgstr "La forme la plus simple, ``assert expression``, est équivalente à ::"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:311
|
||
msgid ""
|
||
"The extended form, ``assert expression1, expression2``, is equivalent to ::"
|
||
msgstr ""
|
||
"La forme étendue, ``assert expression1, expression2``, est équivalente à ::"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:320
|
||
msgid ""
|
||
"These equivalences assume that :const:`__debug__` and :exc:`AssertionError` "
|
||
"refer to the built-in variables with those names. In the current "
|
||
"implementation, the built-in variable :const:`__debug__` is ``True`` under "
|
||
"normal circumstances, ``False`` when optimization is requested (command line "
|
||
"option -O). The current code generator emits no code for an assert "
|
||
"statement when optimization is requested at compile time. Note that it is "
|
||
"unnecessary to include the source code for the expression that failed in the "
|
||
"error message; it will be displayed as part of the stack trace."
|
||
msgstr ""
|
||
"Ces équivalences supposent que :const:`__debug__` et :exc:`AssertionError` "
|
||
"font référence aux variables natives ainsi nommées. Dans l'implémentation "
|
||
"actuelle, la variable native :const:`__debug__` vaut ``True`` dans des "
|
||
"circonstances normales, ``False`` quand les optimisations sont demandées "
|
||
"(ligne de commande avec l'option *-O*). Le générateur de code actuel ne "
|
||
"produit aucun code pour une instruction ``assert`` quand vous demandez les "
|
||
"optimisations à la compilation. Notez qu'il est superflu d'inclure le code "
|
||
"source dans le message d'erreur pour l'expression qui a échoué : il est "
|
||
"affiché dans la pile d'appels."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:329
|
||
msgid ""
|
||
"Assignments to :const:`__debug__` are illegal. The value for the built-in "
|
||
"variable is determined when the interpreter starts."
|
||
msgstr ""
|
||
"Assigner vers :const:`__debug__` est illégal. La valeur de cette variable "
|
||
"native est déterminée au moment où l'interpréteur démarre."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:336
|
||
msgid "The :keyword:`pass` statement"
|
||
msgstr "L'instruction :keyword:`pass`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:345
|
||
msgid ""
|
||
":keyword:`pass` is a null operation --- when it is executed, nothing "
|
||
"happens. It is useful as a placeholder when a statement is required "
|
||
"syntactically, but no code needs to be executed, for example::"
|
||
msgstr ""
|
||
":keyword:`pass` est une opération vide --- quand elle est exécutée, rien ne "
|
||
"se passe. Elle est utile comme bouche-trou lorsqu'une instruction est "
|
||
"syntaxiquement requise mais qu'aucun code ne doit être exécuté. Par "
|
||
"exemple ::"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:357
|
||
msgid "The :keyword:`del` statement"
|
||
msgstr "L'instruction :keyword:`del`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:367
|
||
msgid ""
|
||
"Deletion is recursively defined very similar to the way assignment is "
|
||
"defined. Rather than spelling it out in full details, here are some hints."
|
||
msgstr ""
|
||
"La suppression est récursivement définie de la même manière que "
|
||
"l'assignation. Plutôt que de détailler cela de manière approfondie, voici "
|
||
"quelques indices."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:370
|
||
msgid ""
|
||
"Deletion of a target list recursively deletes each target, from left to "
|
||
"right."
|
||
msgstr ""
|
||
"La suppression d'une liste cible (*target_list* dans la grammaire ci-dessus) "
|
||
"supprime récursivement chaque cible, de la gauche vers la droite."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:376
|
||
msgid ""
|
||
"Deletion of a name removes the binding of that name from the local or "
|
||
"global namespace, depending on whether the name occurs in a :keyword:"
|
||
"`global` statement in the same code block. If the name is unbound, a :exc:"
|
||
"`NameError` exception will be raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:383
|
||
msgid ""
|
||
"It is illegal to delete a name from the local namespace if it occurs as a "
|
||
"free variable in a nested block."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:388
|
||
msgid ""
|
||
"Deletion of attribute references, subscriptions and slicings is passed to "
|
||
"the primary object involved; deletion of a slicing is in general equivalent "
|
||
"to assignment of an empty slice of the right type (but even this is "
|
||
"determined by the sliced object)."
|
||
msgstr ""
|
||
"La suppression d'une référence à un attribut, une sélection ou une tranche "
|
||
"est passée à l'objet primaire concerné : la suppression d'une tranche est en "
|
||
"général équivalente à l'assignation d'une tranche vide du type adéquat (mais "
|
||
"ceci est au final déterminé par l'objet que l'on tranche)."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:397
|
||
msgid "The :keyword:`print` statement"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:405
|
||
msgid ""
|
||
":keyword:`print` evaluates each expression in turn and writes the resulting "
|
||
"object to standard output (see below). If an object is not a string, it is "
|
||
"first converted to a string using the rules for string conversions. The "
|
||
"(resulting or original) string is then written. A space is written before "
|
||
"each object is (converted and) written, unless the output system believes it "
|
||
"is positioned at the beginning of a line. This is the case (1) when no "
|
||
"characters have yet been written to standard output, (2) when the last "
|
||
"character written to standard output is a whitespace character except ``' "
|
||
"'``, or (3) when the last write operation on standard output was not a :"
|
||
"keyword:`print` statement. (In some cases it may be functional to write an "
|
||
"empty string to standard output for this reason.)"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:419
|
||
msgid ""
|
||
"Objects which act like file objects but which are not the built-in file "
|
||
"objects often do not properly emulate this aspect of the file object's "
|
||
"behavior, so it is best not to rely on this."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:429
|
||
msgid ""
|
||
"A ``'\\n'`` character is written at the end, unless the :keyword:`print` "
|
||
"statement ends with a comma. This is the only action if the statement "
|
||
"contains just the keyword :keyword:`print`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:439
|
||
msgid ""
|
||
"Standard output is defined as the file object named ``stdout`` in the built-"
|
||
"in module :mod:`sys`. If no such object exists, or if it does not have a :"
|
||
"meth:`write` method, a :exc:`RuntimeError` exception is raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:445
|
||
msgid ""
|
||
":keyword:`print` also has an extended form, defined by the second portion of "
|
||
"the syntax described above. This form is sometimes referred to as \":keyword:"
|
||
"`print` chevron.\" In this form, the first expression after the ``>>`` must "
|
||
"evaluate to a \"file-like\" object, specifically an object that has a :meth:"
|
||
"`write` method as described above. With this extended form, the subsequent "
|
||
"expressions are printed to this file object. If the first expression "
|
||
"evaluates to ``None``, then ``sys.stdout`` is used as the file for output."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:457
|
||
msgid "The :keyword:`return` statement"
|
||
msgstr "L'instruction :keyword:`return`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:467
|
||
msgid ""
|
||
":keyword:`return` may only occur syntactically nested in a function "
|
||
"definition, not within a nested class definition."
|
||
msgstr ""
|
||
":keyword:`return` ne peut être placée qu'à l'intérieur d'une définition de "
|
||
"fonction, pas à l'intérieur d'une définition de classe."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:470
|
||
msgid ""
|
||
"If an expression list is present, it is evaluated, else ``None`` is "
|
||
"substituted."
|
||
msgstr ""
|
||
"Si une liste d'expressions (*expression_list* dans la grammaire ci-dessus) "
|
||
"est présente, elle est évaluée, sinon ``None`` est utilisée comme valeur par "
|
||
"défaut."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:472
|
||
msgid ""
|
||
":keyword:`return` leaves the current function call with the expression list "
|
||
"(or ``None``) as return value."
|
||
msgstr ""
|
||
":keyword:`return` quitte l'appel à la fonction courante avec la liste "
|
||
"d'expressions (ou ``None``) comme valeur de retour."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:477
|
||
msgid ""
|
||
"When :keyword:`return` passes control out of a :keyword:`try` statement with "
|
||
"a :keyword:`finally` clause, that :keyword:`finally` clause is executed "
|
||
"before really leaving the function."
|
||
msgstr ""
|
||
"Quand :keyword:`return` fait sortir d'une instruction :keyword:`try` avec "
|
||
"une clause :keyword:`finally`, cette clause :keyword:`finally` est exécutée "
|
||
"avant de réellement quitter la fonction."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:481
|
||
msgid ""
|
||
"In a generator function, the :keyword:`return` statement is not allowed to "
|
||
"include an :token:`expression_list`. In that context, a bare :keyword:"
|
||
"`return` indicates that the generator is done and will cause :exc:"
|
||
"`StopIteration` to be raised."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:490
|
||
msgid "The :keyword:`yield` statement"
|
||
msgstr "L'instruction :keyword:`yield`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:502
|
||
msgid ""
|
||
"The :keyword:`yield` statement is only used when defining a generator "
|
||
"function, and is only used in the body of the generator function. Using a :"
|
||
"keyword:`yield` statement in a function definition is sufficient to cause "
|
||
"that definition to create a generator function instead of a normal function."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:507
|
||
msgid ""
|
||
"When a generator function is called, it returns an iterator known as a "
|
||
"generator iterator, or more commonly, a generator. The body of the "
|
||
"generator function is executed by calling the generator's :meth:`~generator."
|
||
"next` method repeatedly until it raises an exception."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:512
|
||
msgid ""
|
||
"When a :keyword:`yield` statement is executed, the state of the generator is "
|
||
"frozen and the value of :token:`expression_list` is returned to :meth:"
|
||
"`~generator.next`'s caller. By \"frozen\" we mean that all local state is "
|
||
"retained, including the current bindings of local variables, the instruction "
|
||
"pointer, and the internal evaluation stack: enough information is saved so "
|
||
"that the next time :meth:`~generator.next` is invoked, the function can "
|
||
"proceed exactly as if the :keyword:`yield` statement were just another "
|
||
"external call."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:520
|
||
msgid ""
|
||
"As of Python version 2.5, the :keyword:`yield` statement is now allowed in "
|
||
"the :keyword:`try` clause of a :keyword:`try` ... :keyword:`finally` "
|
||
"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:`close` method will be called, allowing any "
|
||
"pending :keyword:`finally` clauses to execute."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:527
|
||
msgid ""
|
||
"For full details of :keyword:`yield` semantics, refer to the :ref:"
|
||
"`yieldexpr` section."
|
||
msgstr ""
|
||
"Pour tous les détails sur la sémantique de :keyword:`yield`, reportez-vous à "
|
||
"la section :ref:`yieldexpr`."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:532
|
||
msgid ""
|
||
"In Python 2.2, the :keyword:`yield` statement was only allowed when the "
|
||
"``generators`` feature has been enabled. This ``__future__`` import "
|
||
"statement was used to enable the feature::"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:542
|
||
msgid ":pep:`255` - Simple Generators"
|
||
msgstr ":pep:`255`: Générateurs simples"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:542
|
||
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`."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:545
|
||
msgid ":pep:`342` - Coroutines via Enhanced Generators"
|
||
msgstr ":pep:`342` -- Coroutines *via* des générateurs améliorés"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:545
|
||
msgid ""
|
||
"The proposal that, among other generator enhancements, proposed allowing :"
|
||
"keyword:`yield` to appear inside a :keyword:`try` ... :keyword:`finally` "
|
||
"block."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:552
|
||
msgid "The :keyword:`raise` statement"
|
||
msgstr "L'instruction :keyword:`raise`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:562
|
||
msgid ""
|
||
"If no expressions are present, :keyword:`raise` re-raises the last exception "
|
||
"that was active in the current scope. If no exception is active in the "
|
||
"current scope, a :exc:`TypeError` exception is raised indicating that this "
|
||
"is an error (if running under IDLE, a :exc:`Queue.Empty` exception is raised "
|
||
"instead)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:567
|
||
msgid ""
|
||
"Otherwise, :keyword:`raise` evaluates the expressions to get three objects, "
|
||
"using ``None`` as the value of omitted expressions. The first two objects "
|
||
"are used to determine the *type* and *value* of the exception."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:571
|
||
msgid ""
|
||
"If the first object is an instance, the type of the exception is the class "
|
||
"of the instance, the instance itself is the value, and the second object "
|
||
"must be ``None``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:575
|
||
msgid ""
|
||
"If the first object is a class, it becomes the type of the exception. The "
|
||
"second object is used to determine the exception value: If it is an instance "
|
||
"of the class, the instance becomes the exception value. If the second object "
|
||
"is a tuple, it is used as the argument list for the class constructor; if it "
|
||
"is ``None``, an empty argument list is used, and any other object is treated "
|
||
"as a single argument to the constructor. The instance so created by calling "
|
||
"the constructor is used as the exception value."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:585
|
||
msgid ""
|
||
"If a third object is present and not ``None``, it must be a traceback object "
|
||
"(see section :ref:`types`), and it is substituted instead of the current "
|
||
"location as the place where the exception occurred. If the third object is "
|
||
"present and not a traceback object or ``None``, a :exc:`TypeError` exception "
|
||
"is raised. The three-expression form of :keyword:`raise` is useful to re-"
|
||
"raise an exception transparently in an except clause, but :keyword:`raise` "
|
||
"with no expressions should be preferred if the exception to be re-raised was "
|
||
"the most recently active exception in the current scope."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:594
|
||
msgid ""
|
||
"Additional information on exceptions can be found in section :ref:"
|
||
"`exceptions`, and information about handling exceptions is in section :ref:"
|
||
"`try`."
|
||
msgstr ""
|
||
"Des informations complémentaires sur les exceptions sont disponibles dans la "
|
||
"section :ref:`exceptions` et sur la gestion des exceptions dans la section :"
|
||
"ref:`try`."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:601
|
||
msgid "The :keyword:`break` statement"
|
||
msgstr "L'instruction :keyword:`break`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:612
|
||
msgid ""
|
||
":keyword:`break` may only occur syntactically nested in a :keyword:`for` or :"
|
||
"keyword:`while` loop, but not nested in a function or class definition "
|
||
"within that loop."
|
||
msgstr ""
|
||
"Une instruction :keyword:`break` ne peut apparaître qu'à l'intérieur d'une "
|
||
"boucle :keyword:`for` ou :keyword:`while`, mais pas dans une définition de "
|
||
"fonction ou de classe à l'intérieur de cette boucle."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:618
|
||
msgid ""
|
||
"It terminates the nearest enclosing loop, skipping the optional :keyword:"
|
||
"`else` clause if the loop has one."
|
||
msgstr ""
|
||
"Elle termine la boucle la plus imbriquée, shuntant l'éventuelle clause :"
|
||
"keyword:`else` de la boucle."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:623
|
||
msgid ""
|
||
"If a :keyword:`for` loop is terminated by :keyword:`break`, the loop control "
|
||
"target keeps its current value."
|
||
msgstr ""
|
||
"Si une boucle :keyword:`for` est terminée par un :keyword:`break`, la cible "
|
||
"qui contrôle la boucle garde sa valeur."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:628
|
||
msgid ""
|
||
"When :keyword:`break` passes control out of a :keyword:`try` statement with "
|
||
"a :keyword:`finally` clause, that :keyword:`finally` clause is executed "
|
||
"before really leaving the loop."
|
||
msgstr ""
|
||
"Quand :keyword:`break` passe le contrôle en dehors d'une instruction :"
|
||
"keyword:`try` qui comporte une clause :keyword:`finally`, cette clause :"
|
||
"keyword:`finally` est exécutée avant de quitter la boucle."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:636
|
||
msgid "The :keyword:`continue` statement"
|
||
msgstr "L'instruction :keyword:`continue`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:648
|
||
msgid ""
|
||
":keyword:`continue` may only occur syntactically nested in a :keyword:`for` "
|
||
"or :keyword:`while` loop, but not nested in a function or class definition "
|
||
"or :keyword:`finally` clause within that loop. It continues with the next "
|
||
"cycle of the nearest enclosing loop."
|
||
msgstr ""
|
||
"L'instruction :keyword:`continue` ne peut apparaître qu'à l'intérieur d'une "
|
||
"boucle :keyword:`for` ou :keyword:`while`, mais pas dans une définition de "
|
||
"fonction ou de classe ni dans une clause :keyword:`finally`, à l'intérieur "
|
||
"de cette boucle. Elle fait continuer le flot d'exécution au prochain cycle "
|
||
"de la boucle la plus imbriquée."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:653
|
||
msgid ""
|
||
"When :keyword:`continue` passes control out of a :keyword:`try` statement "
|
||
"with a :keyword:`finally` clause, that :keyword:`finally` clause is executed "
|
||
"before really starting the next loop cycle."
|
||
msgstr ""
|
||
"Quand :keyword:`continue` passe le contrôle en dehors d'une instruction :"
|
||
"keyword:`try` qui comporte une clause :keyword:`finally`, cette clause :"
|
||
"keyword:`finally` est exécutée avant de commencer le cycle suivant de la "
|
||
"boucle."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:662
|
||
msgid "The :keyword:`import` statement"
|
||
msgstr "L'instruction :keyword:`import`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:682
|
||
msgid ""
|
||
"Import statements are executed in two steps: (1) find a module, and "
|
||
"initialize it if necessary; (2) define a name or names in the local "
|
||
"namespace (of the scope where the :keyword:`import` statement occurs). The "
|
||
"statement comes in two forms differing on whether it uses the :keyword:"
|
||
"`from` keyword. The first form (without :keyword:`from`) repeats these steps "
|
||
"for each identifier in the list. The form with :keyword:`from` performs step "
|
||
"(1) once, and then performs step (2) repeatedly."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:693
|
||
msgid ""
|
||
"To understand how step (1) occurs, one must first understand how Python "
|
||
"handles hierarchical naming of modules. To help organize modules and provide "
|
||
"a hierarchy in naming, Python has a concept of packages. A package can "
|
||
"contain other packages and modules while modules cannot contain other "
|
||
"modules or packages. From a file system perspective, packages are "
|
||
"directories and modules are files."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:703
|
||
msgid ""
|
||
"Once the name of the module is known (unless otherwise specified, the term "
|
||
"\"module\" will refer to both packages and modules), searching for the "
|
||
"module or package can begin. The first place checked is :data:`sys.modules`, "
|
||
"the cache of all modules that have been imported previously. If the module "
|
||
"is found there then it is used in step (2) of import."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:715
|
||
msgid ""
|
||
"If the module is not found in the cache, then :data:`sys.meta_path` is "
|
||
"searched (the specification for :data:`sys.meta_path` can be found in :pep:"
|
||
"`302`). The object is a list of :term:`finder` objects which are queried in "
|
||
"order as to whether they know how to load the module by calling their :meth:"
|
||
"`find_module` method with the name of the module. If the module happens to "
|
||
"be contained within a package (as denoted by the existence of a dot in the "
|
||
"name), then a second argument to :meth:`find_module` is given as the value "
|
||
"of the :attr:`__path__` attribute from the parent package (everything up to "
|
||
"the last dot in the name of the module being imported). If a finder can find "
|
||
"the module it returns a :term:`loader` (discussed later) or returns ``None``."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:731
|
||
msgid ""
|
||
"If none of the finders on :data:`sys.meta_path` are able to find the module "
|
||
"then some implicitly defined finders are queried. Implementations of Python "
|
||
"vary in what implicit meta path finders are defined. The one they all do "
|
||
"define, though, is one that handles :data:`sys.path_hooks`, :data:`sys."
|
||
"path_importer_cache`, and :data:`sys.path`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:737
|
||
msgid ""
|
||
"The implicit finder searches for the requested module in the \"paths\" "
|
||
"specified in one of two places (\"paths\" do not have to be file system "
|
||
"paths). If the module being imported is supposed to be contained within a "
|
||
"package then the second argument passed to :meth:`find_module`, :attr:"
|
||
"`__path__` on the parent package, is used as the source of paths. If the "
|
||
"module is not contained in a package then :data:`sys.path` is used as the "
|
||
"source of paths."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:744
|
||
msgid ""
|
||
"Once the source of paths is chosen it is iterated over to find a finder that "
|
||
"can handle that path. The dict at :data:`sys.path_importer_cache` caches "
|
||
"finders for paths and is checked for a finder. If the path does not have a "
|
||
"finder cached then :data:`sys.path_hooks` is searched by calling each object "
|
||
"in the list with a single argument of the path, returning a finder or "
|
||
"raises :exc:`ImportError`. If a finder is returned then it is cached in :"
|
||
"data:`sys.path_importer_cache` and then used for that path entry. If no "
|
||
"finder can be found but the path exists then a value of ``None`` is stored "
|
||
"in :data:`sys.path_importer_cache` to signify that an implicit, file-based "
|
||
"finder that handles modules stored as individual files should be used for "
|
||
"that path. If the path does not exist then a finder which always returns "
|
||
"``None`` is placed in the cache for the path."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:762
|
||
msgid ""
|
||
"If no finder can find the module then :exc:`ImportError` is raised. "
|
||
"Otherwise some finder returned a loader whose :meth:`load_module` method is "
|
||
"called with the name of the module to load (see :pep:`302` for the original "
|
||
"definition of loaders). A loader has several responsibilities to perform on "
|
||
"a module it loads. First, if the module already exists in :data:`sys."
|
||
"modules` (a possibility if the loader is called outside of the import "
|
||
"machinery) then it is to use that module for initialization and not a new "
|
||
"module. But if the module does not exist in :data:`sys.modules` then it is "
|
||
"to be added to that dict before initialization begins. If an error occurs "
|
||
"during loading of the module and it was added to :data:`sys.modules` it is "
|
||
"to be removed from the dict. If an error occurs but the module was already "
|
||
"in :data:`sys.modules` it is left in the dict."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:782
|
||
msgid ""
|
||
"The loader must set several attributes on the module. :data:`__name__` is to "
|
||
"be set to the name of the module. :data:`__file__` is to be the \"path\" to "
|
||
"the file unless the module is built-in (and thus listed in :data:`sys."
|
||
"builtin_module_names`) in which case the attribute is not set. If what is "
|
||
"being imported is a package then :data:`__path__` is to be set to a list of "
|
||
"paths to be searched when looking for modules and packages contained within "
|
||
"the package being imported. :data:`__package__` is optional but should be "
|
||
"set to the name of package that contains the module or package (the empty "
|
||
"string is used for module not contained in a package). :data:`__loader__` is "
|
||
"also optional but should be set to the loader object that is loading the "
|
||
"module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:797
|
||
msgid ""
|
||
"If an error occurs during loading then the loader raises :exc:`ImportError` "
|
||
"if some other exception is not already being propagated. Otherwise the "
|
||
"loader returns the module that was loaded and initialized."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:801
|
||
msgid ""
|
||
"When step (1) finishes without raising an exception, step (2) can begin."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:803
|
||
msgid ""
|
||
"The first form of :keyword:`import` statement binds the module name in the "
|
||
"local namespace to the module object, and then goes on to import the next "
|
||
"identifier, if any. If the module name is followed by :keyword:`as`, the "
|
||
"name following :keyword:`as` is used as the local name for the module."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:812
|
||
msgid ""
|
||
"The :keyword:`from` form does not bind the module name: it goes through the "
|
||
"list of identifiers, looks each one of them up in the module found in step "
|
||
"(1), and binds the name in the local namespace to the object thus found. As "
|
||
"with the first form of :keyword:`import`, an alternate local name can be "
|
||
"supplied by specifying \":keyword:`as` localname\". If a name is not "
|
||
"found, :exc:`ImportError` is raised. If the list of identifiers is replaced "
|
||
"by a star (``'*'``), all public names defined in the module are bound in the "
|
||
"local namespace of the :keyword:`import` statement.."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:823
|
||
msgid ""
|
||
"The *public names* defined by a module are determined by checking the "
|
||
"module's namespace for a variable named ``__all__``; if defined, it must be "
|
||
"a sequence of strings which are names defined or imported by that module. "
|
||
"The names given in ``__all__`` are all considered public and are required to "
|
||
"exist. If ``__all__`` is not defined, the set of public names includes all "
|
||
"names found in the module's namespace which do not begin with an underscore "
|
||
"character (``'_'``). ``__all__`` should contain the entire public API. It is "
|
||
"intended to avoid accidentally exporting items that are not part of the API "
|
||
"(such as library modules which were imported and used within the module)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:833
|
||
msgid ""
|
||
"The :keyword:`from` form with ``*`` may only occur in a module scope. If "
|
||
"the wild card form of import --- ``import *`` --- is used in a function and "
|
||
"the function contains or is a nested block with free variables, the compiler "
|
||
"will raise a :exc:`SyntaxError`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:841
|
||
msgid ""
|
||
"When specifying what module to import you do not have to specify the "
|
||
"absolute name of the module. When a module or package is contained within "
|
||
"another package it is possible to make a relative import within the same top "
|
||
"package without having to mention the package name. By using leading dots in "
|
||
"the specified module or package after :keyword:`from` you can specify how "
|
||
"high to traverse up the current package hierarchy without specifying exact "
|
||
"names. One leading dot means the current package where the module making the "
|
||
"import exists. Two dots means up one package level. Three dots is up two "
|
||
"levels, etc. So if you execute ``from . import mod`` from a module in the "
|
||
"``pkg`` package then you will end up importing ``pkg.mod``. If you execute "
|
||
"``from ..subpkg2 import mod`` from within ``pkg.subpkg1`` you will import "
|
||
"``pkg.subpkg2.mod``. The specification for relative imports is contained "
|
||
"within :pep:`328`."
|
||
msgstr ""
|
||
"Quand vous spécifiez les modules à importer, vous n'avez pas besoin de "
|
||
"spécifier les noms absolus des modules. Quand un module ou un paquet est "
|
||
"contenu dans un autre paquet, il est possible d'effectuer une importation "
|
||
"relative à l'intérieur du même paquet de plus haut niveau sans avoir à "
|
||
"mentionner le nom du paquet. En utilisant des points en entête du module ou "
|
||
"du paquet spécifié après :keyword:`from`, vous pouvez spécifier combien de "
|
||
"niveaux vous souhaitez remonter dans la hiérarchie du paquet courant sans "
|
||
"spécifier de nom exact. Un seul point en tête signifie le paquet courant où "
|
||
"se situe le module qui effectue l'importation. Deux points signifient de "
|
||
"remonter d'un niveau. Trois points, remonter de deux niveaux et ainsi de "
|
||
"suite. Ainsi, si vous exécutez ``from . import mod`` dans un module du "
|
||
"paquet ``pkg``, vous importez finalement ``pkg.mod``. Et si vous exécutez "
|
||
"``from ..souspkg2 import mod`` depuis ``pkg.souspkg1``, vous importez "
|
||
"finalement ``pkg.souspkg2.mod``. La spécification des importations relatives "
|
||
"se situe dans la :pep:`328`."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:854
|
||
msgid ""
|
||
":func:`importlib.import_module` is provided to support applications that "
|
||
"determine which modules need to be loaded dynamically."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:861
|
||
msgid "Future statements"
|
||
msgstr "L'instruction future"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:865
|
||
msgid ""
|
||
"A :dfn:`future statement` is a directive to the compiler that a particular "
|
||
"module should be compiled using syntax or semantics that will be available "
|
||
"in a specified future release of Python. The future statement is intended "
|
||
"to ease migration to future versions of Python that introduce incompatible "
|
||
"changes to the language. It allows use of the new features on a per-module "
|
||
"basis before the release in which the feature becomes standard."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:880
|
||
msgid ""
|
||
"A future statement must appear near the top of the module. The only lines "
|
||
"that can appear before a future statement are:"
|
||
msgstr ""
|
||
"Une instruction *future* doit apparaître en haut du module. Les seules "
|
||
"lignes autorisées avant une instruction *future* sont :"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:883
|
||
msgid "the module docstring (if any),"
|
||
msgstr "la chaîne de documentation du module (si elle existe),"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:884
|
||
msgid "comments,"
|
||
msgstr "des commentaires,"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:885
|
||
msgid "blank lines, and"
|
||
msgstr "des lignes vides et"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:886
|
||
msgid "other future statements."
|
||
msgstr "d'autres instructions *future*."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:888
|
||
msgid ""
|
||
"The features recognized by Python 2.6 are ``unicode_literals``, "
|
||
"``print_function``, ``absolute_import``, ``division``, ``generators``, "
|
||
"``nested_scopes`` and ``with_statement``. ``generators``, "
|
||
"``with_statement``, ``nested_scopes`` are redundant in Python version 2.6 "
|
||
"and above because they are always enabled."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:894
|
||
msgid ""
|
||
"A future statement is recognized and treated specially at compile time: "
|
||
"Changes to the semantics of core constructs are often implemented by "
|
||
"generating different code. It may even be the case that a new feature "
|
||
"introduces new incompatible syntax (such as a new reserved word), in which "
|
||
"case the compiler may need to parse the module differently. Such decisions "
|
||
"cannot be pushed off until runtime."
|
||
msgstr ""
|
||
"Une instruction *future* est reconnue et traitée spécialement au moment de "
|
||
"la compilation : les modifications à la sémantique des constructions de base "
|
||
"sont souvent implémentées en générant un code différent. Il peut même "
|
||
"arriver qu'une nouvelle fonctionnalité ait une syntaxe incompatible (tel "
|
||
"qu'un nouveau mot réservé) ; dans ce cas, le compilateur a besoin d'analyser "
|
||
"le module de manière différente. De telles décisions ne peuvent pas être "
|
||
"différées au moment de l'exécution."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:901
|
||
msgid ""
|
||
"For any given release, the compiler knows which feature names have been "
|
||
"defined, and raises a compile-time error if a future statement contains a "
|
||
"feature not known to it."
|
||
msgstr ""
|
||
"Pour une version donnée, le compilateur sait quelles fonctionnalités ont été "
|
||
"définies et lève une erreur à la compilation si une instruction *future* "
|
||
"contient une fonctionnalité qui lui est inconnue."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:905
|
||
msgid ""
|
||
"The direct runtime semantics are the same as for any import statement: there "
|
||
"is a standard module :mod:`__future__`, described later, and it will be "
|
||
"imported in the usual way at the time the future statement is executed."
|
||
msgstr ""
|
||
"La sémantique à l'exécution est la même que pour toute autre instruction "
|
||
"d'importation : il existe un module standard :mod:`__future__`, décrit plus "
|
||
"loin, qui est importé comme les autres au moment ou l'instruction *future* "
|
||
"est exécutée."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:909
|
||
msgid ""
|
||
"The interesting runtime semantics depend on the specific feature enabled by "
|
||
"the future statement."
|
||
msgstr ""
|
||
"La sémantique particulière à l'exécution dépend des fonctionnalités "
|
||
"apportées par l'instruction *future*."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:912
|
||
msgid "Note that there is nothing special about the statement::"
|
||
msgstr "Notez que l'instruction suivante est tout à fait normale ::"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:916
|
||
msgid ""
|
||
"That is not a future statement; it's an ordinary import statement with no "
|
||
"special semantics or syntax restrictions."
|
||
msgstr ""
|
||
"Ce n'est pas une instruction *future* ; c'est une instruction d'importation "
|
||
"ordinaire qui n'a aucune sémantique particulière ou restriction de syntaxe."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:919
|
||
msgid ""
|
||
"Code compiled by an :keyword:`exec` statement or calls to the built-in "
|
||
"functions :func:`compile` and :func:`execfile` that occur in a module :mod:"
|
||
"`M` containing a future statement will, by default, use the new syntax or "
|
||
"semantics associated with the future statement. This can, starting with "
|
||
"Python 2.2 be controlled by optional arguments to :func:`compile` --- see "
|
||
"the documentation of that function for details."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:926
|
||
msgid ""
|
||
"A future statement typed at an interactive interpreter prompt will take "
|
||
"effect for the rest of the interpreter session. If an interpreter is "
|
||
"started with the :option:`-i` option, is passed a script name to execute, "
|
||
"and the script includes a future statement, it will be in effect in the "
|
||
"interactive session started after the script is executed."
|
||
msgstr ""
|
||
"Une instruction *future* entrée à l'invite de l'interpréteur interactif est "
|
||
"effective pour le reste de la session de l'interpréteur. Si l'interpréteur "
|
||
"est démarré avec l'option :option:`-i`, qu'un nom de script est passé pour "
|
||
"être exécuté et que ce script contient une instruction *future*, elle est "
|
||
"effective pour la session interactive qui démarre après l'exécution du "
|
||
"script."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:934
|
||
msgid ":pep:`236` - Back to the __future__"
|
||
msgstr ":pep:`236` -- retour vers le __future__"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:935
|
||
msgid "The original proposal for the __future__ mechanism."
|
||
msgstr "La proposition originale pour le mécanisme de __future__."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:941
|
||
msgid "The :keyword:`global` statement"
|
||
msgstr "L'instruction :keyword:`global`"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:950
|
||
msgid ""
|
||
"The :keyword:`global` statement is a declaration which holds for the entire "
|
||
"current code block. It means that the listed identifiers are to be "
|
||
"interpreted as globals. It would be impossible to assign to a global "
|
||
"variable without :keyword:`global`, although free variables may refer to "
|
||
"globals without being declared global."
|
||
msgstr ""
|
||
"L'instruction :keyword:`global` est une déclaration qui couvre l'ensemble du "
|
||
"bloc de code courant. Elle signifie que les noms (*identifier* dans la "
|
||
"grammaire ci-dessus) listés doivent être interprétés comme globaux. Il est "
|
||
"impossible d'assigner une variable globale sans :keyword:`global`, mais "
|
||
"rappelez-vous que les variables libres peuvent faire référence à des "
|
||
"variables globales sans avoir été déclarées en tant que telles."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:956
|
||
msgid ""
|
||
"Names listed in a :keyword:`global` statement must not be used in the same "
|
||
"code block textually preceding that :keyword:`global` statement."
|
||
msgstr ""
|
||
"Les noms listés dans l'instruction :keyword:`global` ne doivent pas être "
|
||
"utilisés, dans le même bloc de code, avant l'instruction :keyword:`global`."
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:959
|
||
msgid ""
|
||
"Names listed in a :keyword:`global` statement must not be defined as formal "
|
||
"parameters or in a :keyword:`for` loop control target, :keyword:`class` "
|
||
"definition, function definition, or :keyword:`import` statement."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:965
|
||
msgid ""
|
||
"The current implementation does not enforce the latter two restrictions, but "
|
||
"programs should not abuse this freedom, as future implementations may "
|
||
"enforce them or silently change the meaning of the program."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:975
|
||
msgid ""
|
||
"**Programmer's note:** the :keyword:`global` is a directive to the parser. "
|
||
"It applies only to code parsed at the same time as the :keyword:`global` "
|
||
"statement. In particular, a :keyword:`global` statement contained in an :"
|
||
"keyword:`exec` statement does not affect the code block *containing* the :"
|
||
"keyword:`exec` statement, and code contained in an :keyword:`exec` statement "
|
||
"is unaffected by :keyword:`global` statements in the code containing the :"
|
||
"keyword:`exec` statement. The same applies to the :func:`eval`, :func:"
|
||
"`execfile` and :func:`compile` functions."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:988
|
||
msgid "The :keyword:`exec` statement"
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:995
|
||
msgid ""
|
||
"This statement supports dynamic execution of Python code. The first "
|
||
"expression should evaluate to either a Unicode string, a *Latin-1* encoded "
|
||
"string, an open file object, a code object, or a tuple. If it is a string, "
|
||
"the string is parsed as a suite of Python statements which is then executed "
|
||
"(unless a syntax error occurs). [#]_ If it is an open file, the file is "
|
||
"parsed until EOF and executed. If it is a code object, it is simply "
|
||
"executed. For the interpretation of a tuple, see below. In all cases, the "
|
||
"code that's executed is expected to be valid as file input (see section :ref:"
|
||
"`file-input`). Be aware that the :keyword:`return` and :keyword:`yield` "
|
||
"statements may not be used outside of function definitions even within the "
|
||
"context of code passed to the :keyword:`exec` statement."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:1007
|
||
msgid ""
|
||
"In all cases, if the optional parts are omitted, the code is executed in the "
|
||
"current scope. If only the first expression after ``in`` is specified, it "
|
||
"should be a dictionary, which will be used for both the global and the local "
|
||
"variables. If two expressions are given, they are used for the global and "
|
||
"local variables, respectively. If provided, *locals* can be any mapping "
|
||
"object. Remember that at module level, globals and locals are the same "
|
||
"dictionary. If two separate objects are given as *globals* and *locals*, the "
|
||
"code will be executed as if it were embedded in a class definition."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:1016
|
||
msgid ""
|
||
"The first expression may also be a tuple of length 2 or 3. In this case, "
|
||
"the optional parts must be omitted. The form ``exec(expr, globals)`` is "
|
||
"equivalent to ``exec expr in globals``, while the form ``exec(expr, globals, "
|
||
"locals)`` is equivalent to ``exec expr in globals, locals``. The tuple form "
|
||
"of ``exec`` provides compatibility with Python 3, where ``exec`` is a "
|
||
"function rather than a statement."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:1023
|
||
msgid "Formerly, *locals* was required to be a dictionary."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:1030
|
||
msgid ""
|
||
"As a side effect, an implementation may insert additional keys into the "
|
||
"dictionaries given besides those corresponding to variable names set by the "
|
||
"executed code. For example, the current implementation may add a reference "
|
||
"to the dictionary of the built-in module :mod:`__builtin__` under the key "
|
||
"``__builtins__`` (!)."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:1041
|
||
msgid ""
|
||
"**Programmer's hints:** dynamic evaluation of expressions is supported by "
|
||
"the built-in function :func:`eval`. The built-in functions :func:`globals` "
|
||
"and :func:`locals` return the current global and local dictionary, "
|
||
"respectively, which may be useful to pass around for use by :keyword:`exec`."
|
||
msgstr ""
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:1048
|
||
msgid "Footnotes"
|
||
msgstr "Notes"
|
||
|
||
#: ../Doc/reference/simple_stmts.rst:1049
|
||
msgid ""
|
||
"Note that the parser only accepts the Unix-style end of line convention. If "
|
||
"you are reading the code from a file, make sure to use :term:`universal "
|
||
"newlines` mode to convert Windows or Mac-style newlines."
|
||
msgstr ""
|