2016-10-30 09:46:26 +00:00
|
|
|
|
# SOME DESCRIPTIVE TITLE.
|
|
|
|
|
# Copyright (C) 2001-2016, Python Software Foundation
|
|
|
|
|
# This file is distributed under the same license as the Python package.
|
|
|
|
|
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
|
|
|
|
#
|
|
|
|
|
msgid ""
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Project-Id-Version: Python 3.6\n"
|
|
|
|
|
"Report-Msgid-Bugs-To: \n"
|
2017-08-01 11:29:09 +00:00
|
|
|
|
"POT-Creation-Date: 2017-08-01 13:21+0200\n"
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"PO-Revision-Date: 2018-02-01 23:24+0100\n"
|
2017-05-16 21:31:05 +00:00
|
|
|
|
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
|
|
|
|
"Language-Team: \n"
|
|
|
|
|
"Language: fr\n"
|
2017-05-27 17:46:38 +00:00
|
|
|
|
"MIME-Version: 1.0\n"
|
|
|
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
|
|
|
"Content-Transfer-Encoding: 8bit\n"
|
2017-08-10 12:07:18 +00:00
|
|
|
|
"X-Generator: Poedit 2.0.2\n"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:5
|
|
|
|
|
msgid "More Control Flow Tools"
|
|
|
|
|
msgstr "D'autres outils de contrôle de flux"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:7
|
|
|
|
|
msgid ""
|
|
|
|
|
"Besides the :keyword:`while` statement just introduced, Python knows the "
|
|
|
|
|
"usual control flow statements known from other languages, with some twists."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"En plus de l'instruction :keyword:`while` qui vient d'être présentée, Python "
|
|
|
|
|
"dispose des instructions de contrôle de flux classiques que l'on trouve dans "
|
|
|
|
|
"d'autres langages, mais toujours avec ses propres tournures."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:14
|
|
|
|
|
msgid ":keyword:`if` Statements"
|
|
|
|
|
msgstr "L'instruction :keyword:`if`"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:16
|
|
|
|
|
msgid ""
|
|
|
|
|
"Perhaps the most well-known statement type is the :keyword:`if` statement. "
|
|
|
|
|
"For example::"
|
|
|
|
|
msgstr ""
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"L'instruction :keyword:`if` est sans doute la plus connue. Par exemple ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:33
|
|
|
|
|
msgid ""
|
|
|
|
|
"There can be zero or more :keyword:`elif` parts, and the :keyword:`else` "
|
|
|
|
|
"part is optional. The keyword ':keyword:`elif`' is short for 'else if', and "
|
|
|
|
|
"is useful to avoid excessive indentation. An :keyword:`if` ... :keyword:"
|
|
|
|
|
"`elif` ... :keyword:`elif` ... sequence is a substitute for the ``switch`` "
|
|
|
|
|
"or ``case`` statements found in other languages."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"Il peut y avoir un nombre quelconque de parties :keyword:`elif` et la "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"partie :keyword:`else` est facultative. Le mot clé ':keyword:`elif`' est un "
|
|
|
|
|
"raccourci pour 'else if', mais permet de gagner un niveau d'indentation. Une "
|
|
|
|
|
"séquence :keyword:`if` ... :keyword:`elif` ... :keyword:`elif` ... est par "
|
|
|
|
|
"ailleurs équivalente aux instructions ``switch`` ou ``case`` disponibles "
|
|
|
|
|
"dans d'autres langages."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:43
|
|
|
|
|
msgid ":keyword:`for` Statements"
|
|
|
|
|
msgstr "L'instruction :keyword:`for`"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:48
|
|
|
|
|
msgid ""
|
|
|
|
|
"The :keyword:`for` statement in Python differs a bit from what you may be "
|
|
|
|
|
"used to in C or Pascal. Rather than always iterating over an arithmetic "
|
|
|
|
|
"progression of numbers (like in Pascal), or giving the user the ability to "
|
|
|
|
|
"define both the iteration step and halting condition (as C), Python's :"
|
|
|
|
|
"keyword:`for` statement iterates over the items of any sequence (a list or a "
|
|
|
|
|
"string), in the order that they appear in the sequence. For example (no pun "
|
|
|
|
|
"intended):"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'instruction :keyword:`for` que propose Python est un peu différente de "
|
|
|
|
|
"celle que l'on peut trouver en C ou en Pascal. Au lieu de toujours itérer "
|
|
|
|
|
"sur une suite arithmétique de nombres (comme en Pascal), ou de donner à "
|
|
|
|
|
"l'utilisateur la possibilité de définir le pas d'itération et la condition "
|
|
|
|
|
"de fin (comme en C), l'instruction :keyword:`for` en Python itère sur les "
|
|
|
|
|
"éléments d'une séquence (qui peut être une liste, une chaîne de "
|
|
|
|
|
"caractères...), dans l'ordre dans lequel ils apparaissent dans la séquence. "
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"Par exemple ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:69
|
|
|
|
|
msgid ""
|
|
|
|
|
"If you need to modify the sequence you are iterating over while inside the "
|
|
|
|
|
"loop (for example to duplicate selected items), it is recommended that you "
|
|
|
|
|
"first make a copy. Iterating over a sequence does not implicitly make a "
|
|
|
|
|
"copy. The slice notation makes this especially convenient::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Si vous devez modifier la séquence sur laquelle s'effectue l'itération à "
|
|
|
|
|
"l'intérieur de la boucle (par exemple pour dupliquer ou supprimer un "
|
|
|
|
|
"élément), il est plus que recommandé de commencer par en faire une copie, "
|
|
|
|
|
"celle-ci n'étant pas implicite. La notation \"par tranches\" rend cette "
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"opération particulièrement simple ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:81
|
|
|
|
|
msgid ""
|
|
|
|
|
"With ``for w in words:``, the example would attempt to create an infinite "
|
|
|
|
|
"list, inserting ``defenestrate`` over and over again."
|
|
|
|
|
msgstr ""
|
2016-11-19 15:44:37 +00:00
|
|
|
|
"Avec ``for w in words:``, l'exemple tenterait de créer une liste infinie, en "
|
|
|
|
|
"insérant ``defenestrate`` indéfiniment."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:88
|
|
|
|
|
msgid "The :func:`range` Function"
|
|
|
|
|
msgstr "La fonction :func:`range`"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:90
|
|
|
|
|
msgid ""
|
|
|
|
|
"If you do need to iterate over a sequence of numbers, the built-in function :"
|
|
|
|
|
"func:`range` comes in handy. It generates arithmetic progressions::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Si vous devez itérer sur une suite de nombres, la fonction intégrée :func:"
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"`range` est faite pour cela. Elle génère des suites arithmétiques ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:102
|
|
|
|
|
msgid ""
|
|
|
|
|
"The given end point is never part of the generated sequence; ``range(10)`` "
|
|
|
|
|
"generates 10 values, the legal indices for items of a sequence of length "
|
|
|
|
|
"10. It is possible to let the range start at another number, or to specify "
|
|
|
|
|
"a different increment (even negative; sometimes this is called the 'step')::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Le dernier élément fourni en paramètre ne fait jamais partie de la liste "
|
|
|
|
|
"générée ; ``range(10)`` génère une liste de 10 valeurs, dont les valeurs "
|
|
|
|
|
"vont de 0 à 9. Il est possible de spécifier une valeur de début et/ou une "
|
|
|
|
|
"valeur d'incrément différente(s) (y compris négative pour cette dernière, "
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"que l'on appelle également parfois le 'pas') ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:116
|
|
|
|
|
msgid ""
|
|
|
|
|
"To iterate over the indices of a sequence, you can combine :func:`range` "
|
|
|
|
|
"and :func:`len` as follows::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Pour itérer sur les indices d'une séquence, on peut combiner les fonctions :"
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"func:`range` et :func:`len` ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:129
|
|
|
|
|
msgid ""
|
|
|
|
|
"In most such cases, however, it is convenient to use the :func:`enumerate` "
|
|
|
|
|
"function, see :ref:`tut-loopidioms`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Cependant, dans la plupart des cas, il est plus pratique d'utiliser la "
|
|
|
|
|
"fonction :func:`enumerate`. Voyez pour cela :ref:`tut-loopidioms`."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:132
|
|
|
|
|
msgid "A strange thing happens if you just print a range::"
|
2018-02-02 22:23:20 +00:00
|
|
|
|
msgstr "Une chose étrange se produit lorsqu'on affiche un range ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:137
|
|
|
|
|
msgid ""
|
|
|
|
|
"In many ways the object returned by :func:`range` behaves as if it is a "
|
|
|
|
|
"list, but in fact it isn't. It is an object which returns the successive "
|
|
|
|
|
"items of the desired sequence when you iterate over it, but it doesn't "
|
|
|
|
|
"really make the list, thus saving space."
|
|
|
|
|
msgstr ""
|
2018-02-02 08:11:24 +00:00
|
|
|
|
"L'objet renvoyé par :func:`range` se comporte presque comme une liste, mais "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"ce n'en est pas une. Cet objet génère les éléments de la séquence au fur et "
|
|
|
|
|
"à mesure de l'itération, sans réellement produire la liste en tant que "
|
|
|
|
|
"telle, économisant ainsi de l'espace."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:142
|
|
|
|
|
msgid ""
|
|
|
|
|
"We say such an object is *iterable*, that is, suitable as a target for "
|
|
|
|
|
"functions and constructs that expect something from which they can obtain "
|
|
|
|
|
"successive items until the supply is exhausted. We have seen that the :"
|
|
|
|
|
"keyword:`for` statement is such an *iterator*. The function :func:`list` is "
|
|
|
|
|
"another; it creates lists from iterables::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"On appelle de tels objets des *iterables*, c'est à dire des objets qui "
|
|
|
|
|
"conviennent à des *iterateurs*, des fonctions ou constructions qui "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"s'attendent à quelque chose duquel ils peuvent tirer des éléments, "
|
|
|
|
|
"successivement, jusqu'à épuisement. On a vu que l'instruction :keyword:`for` "
|
2018-02-02 08:11:24 +00:00
|
|
|
|
"est un itérateur. La fonction :func:`list` en est un autre, qui crée des "
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"listes à partir d'itérables ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:152
|
|
|
|
|
msgid ""
|
|
|
|
|
"Later we will see more functions that return iterables and take iterables as "
|
|
|
|
|
"argument."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"Plus loin nous voyons d'autres fonctions qui donnent des itérables ou en "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"prennent en paramètre."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:158
|
|
|
|
|
msgid ""
|
|
|
|
|
":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` "
|
|
|
|
|
"Clauses on Loops"
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"Les instructions :keyword:`break`, :keyword:`continue` et les clauses :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"keyword:`else` au sein des boucles"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:160
|
|
|
|
|
msgid ""
|
2017-08-01 11:29:09 +00:00
|
|
|
|
"The :keyword:`break` statement, like in C, breaks out of the innermost "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"enclosing :keyword:`for` or :keyword:`while` loop."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'instruction :keyword:`break`, comme en C, interrompt la boucle :keyword:"
|
2017-08-10 12:07:18 +00:00
|
|
|
|
"`for` ou :keyword:`while` la plus profonde."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:163
|
|
|
|
|
msgid ""
|
|
|
|
|
"Loop statements may have an ``else`` clause; it is executed when the loop "
|
|
|
|
|
"terminates through exhaustion of the list (with :keyword:`for`) or when the "
|
|
|
|
|
"condition becomes false (with :keyword:`while`), but not when the loop is "
|
|
|
|
|
"terminated by a :keyword:`break` statement. This is exemplified by the "
|
|
|
|
|
"following loop, which searches for prime numbers::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Les boucles peuvent également disposer d'une instruction ``else`` ; celle-ci "
|
|
|
|
|
"est exécutée lorsqu'une boucle se termine alors que tous ses éléments ont "
|
|
|
|
|
"été traités (dans le cas d'un :keyword:`for`) ou que la condition devient "
|
|
|
|
|
"fausse (dans le cas d'un :keyword:`while`), mais pas lorsque la boucle est "
|
|
|
|
|
"interrompue par une instruction :keyword:`break`. L'exemple suivant, qui "
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"effectue une recherche de nombres premiers, en est une démonstration ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:187
|
|
|
|
|
msgid ""
|
|
|
|
|
"(Yes, this is the correct code. Look closely: the ``else`` clause belongs "
|
|
|
|
|
"to the :keyword:`for` loop, **not** the :keyword:`if` statement.)"
|
|
|
|
|
msgstr ""
|
2018-02-02 22:23:20 +00:00
|
|
|
|
"(Oui, ce code est correct. Regardez attentivement : l'instruction ``else`` "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"est rattachée à la boucle :keyword:`for`, et **non** à l'instruction :"
|
|
|
|
|
"keyword:`if`.)"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:190
|
|
|
|
|
msgid ""
|
|
|
|
|
"When used with a loop, the ``else`` clause has more in common with the "
|
|
|
|
|
"``else`` clause of a :keyword:`try` statement than it does that of :keyword:"
|
|
|
|
|
"`if` statements: a :keyword:`try` statement's ``else`` clause runs when no "
|
|
|
|
|
"exception occurs, and a loop's ``else`` clause runs when no ``break`` "
|
|
|
|
|
"occurs. For more on the :keyword:`try` statement and exceptions, see :ref:"
|
|
|
|
|
"`tut-handling`."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Lorsqu'elle utilisée dans une boucle, la clause ``else`` est donc plus "
|
|
|
|
|
"proche de celle associée à une instruction :keyword:`try` que de celle "
|
|
|
|
|
"associée à une instruction :keyword:`if` : la clause ``else`` d'une "
|
|
|
|
|
"instruction :keyword:`try` s'exécute lorsqu'aucune exception n'est "
|
|
|
|
|
"déclenchée, et celle d'une boucle lorsque aucun ``break`` n'intervient. Plus "
|
|
|
|
|
"plus d'informations sur l'instruction :keyword:`try` et le traitement des "
|
|
|
|
|
"exceptions, consultez :ref:`tut-handling`."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:197
|
|
|
|
|
msgid ""
|
|
|
|
|
"The :keyword:`continue` statement, also borrowed from C, continues with the "
|
|
|
|
|
"next iteration of the loop::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'instruction :keyword:`continue`, également empruntée au C, fait passer la "
|
|
|
|
|
"boucle à son itération suivante : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:217
|
|
|
|
|
msgid ":keyword:`pass` Statements"
|
|
|
|
|
msgstr "L'instruction :keyword:`pass`"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:219
|
|
|
|
|
msgid ""
|
|
|
|
|
"The :keyword:`pass` statement does nothing. It can be used when a statement "
|
|
|
|
|
"is required syntactically but the program requires no action. For example::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'instruction :keyword:`pass` ne fait rien. Elle peut être utilisée "
|
|
|
|
|
"lorsqu'une instruction est nécessaire pour fournir une syntaxe correcte, "
|
|
|
|
|
"mais qu'aucune action ne doit être effectuée. Par exemple : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:226
|
|
|
|
|
msgid "This is commonly used for creating minimal classes::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"On utilise couramment cette instruction pour créer des classes minimales : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:232
|
|
|
|
|
msgid ""
|
|
|
|
|
"Another place :keyword:`pass` can be used is as a place-holder for a "
|
|
|
|
|
"function or conditional body when you are working on new code, allowing you "
|
|
|
|
|
"to keep thinking at a more abstract level. The :keyword:`pass` is silently "
|
|
|
|
|
"ignored::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Un autre cas d'utilisation du :keyword:`pass` est de réserver un espace en "
|
|
|
|
|
"phase de développement pour une fonction ou un traitement conditionnel, vous "
|
|
|
|
|
"permettant ainsi de construire votre code à un niveau plus abstrait. "
|
|
|
|
|
"L'instruction :keyword:`pass` est alors ignorée silencieusement : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:243
|
|
|
|
|
msgid "Defining Functions"
|
|
|
|
|
msgstr "Définir des fonctions"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:245
|
|
|
|
|
msgid ""
|
|
|
|
|
"We can create a function that writes the Fibonacci series to an arbitrary "
|
|
|
|
|
"boundary::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"On peut créer une fonction qui écrit la suite de Fibonacci jusqu'à une "
|
|
|
|
|
"limite imposée : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:265
|
|
|
|
|
msgid ""
|
|
|
|
|
"The keyword :keyword:`def` introduces a function *definition*. It must be "
|
|
|
|
|
"followed by the function name and the parenthesized list of formal "
|
|
|
|
|
"parameters. The statements that form the body of the function start at the "
|
|
|
|
|
"next line, and must be indented."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Le mot-clé :keyword:`def` introduit une *définition* de fonction. Il doit "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"être suivi du nom de la fonction et d'une liste, entre parenthèses, de ses "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"paramètres. L'instruction qui constitue le corps de la fonction débute à la "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"ligne suivante et doit être indentée."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:270
|
|
|
|
|
msgid ""
|
|
|
|
|
"The first statement of the function body can optionally be a string literal; "
|
|
|
|
|
"this string literal is the function's documentation string, or :dfn:"
|
|
|
|
|
"`docstring`. (More about docstrings can be found in the section :ref:`tut-"
|
|
|
|
|
"docstrings`.) There are tools which use docstrings to automatically produce "
|
|
|
|
|
"online or printed documentation, or to let the user interactively browse "
|
|
|
|
|
"through code; it's good practice to include docstrings in code that you "
|
|
|
|
|
"write, so make a habit of it."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"La première instruction d'une fonction peut, de façon facultative, être une "
|
|
|
|
|
"chaîne de caractères littérale ; cette chaîne de caractères sera alors la "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"chaîne de documentation de la fonction, appelée :dfn:`docstring` (consultez "
|
|
|
|
|
"la section :ref:`tut-docstrings` pour en savoir plus). Il existe des outils "
|
|
|
|
|
"qui utilisent ces chaînes de documentation pour générer automatiquement une "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"documentation en ligne ou imprimée, ou pour permettre à l'utilisateur de "
|
|
|
|
|
"naviguer de façon interactive dans le code ; prenez-en l'habitude, c'est une "
|
2018-03-20 23:16:43 +00:00
|
|
|
|
"bonne pratique que de documenter le code que vous écrivez !."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:277
|
|
|
|
|
msgid ""
|
|
|
|
|
"The *execution* of a function introduces a new symbol table used for the "
|
|
|
|
|
"local variables of the function. More precisely, all variable assignments "
|
|
|
|
|
"in a function store the value in the local symbol table; whereas variable "
|
|
|
|
|
"references first look in the local symbol table, then in the local symbol "
|
|
|
|
|
"tables of enclosing functions, then in the global symbol table, and finally "
|
|
|
|
|
"in the table of built-in names. Thus, global variables cannot be directly "
|
|
|
|
|
"assigned a value within a function (unless named in a :keyword:`global` "
|
|
|
|
|
"statement), although they may be referenced."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"*L'exécution* d'une fonction introduit une nouvelle table de symboles "
|
|
|
|
|
"utilisée par les variables locales de la fonction. Plus précisément, toutes "
|
|
|
|
|
"les affectations de variables effectuées au sein d'une fonction stockent la "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"valeur dans la table de symboles locale ; en revanche, les références de "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"variables sont recherchées dans la table de symboles locale, puis dans la "
|
|
|
|
|
"table de symboles locale des fonctions englobantes, puis dans la table de "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"symboles globale et finalement dans la table de noms des primitives. Par "
|
|
|
|
|
"conséquent, bien qu'elles puissent être référencées, il est impossible "
|
|
|
|
|
"d'affecter une valeur à une variable globale (sauf en utilisant une "
|
|
|
|
|
"instruction :keyword:`global`)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:286
|
|
|
|
|
msgid ""
|
|
|
|
|
"The actual parameters (arguments) to a function call are introduced in the "
|
|
|
|
|
"local symbol table of the called function when it is called; thus, arguments "
|
|
|
|
|
"are passed using *call by value* (where the *value* is always an object "
|
|
|
|
|
"*reference*, not the value of the object). [#]_ When a function calls "
|
|
|
|
|
"another function, a new local symbol table is created for that call."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Les paramètres effectifs (arguments) d'une fonction sont introduits dans la "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"table de symboles locale de la fonction appelée au moment où elle est "
|
|
|
|
|
"appelée ; par conséquent, les passages de paramètres se font *par valeur*, "
|
|
|
|
|
"la *valeur* étant toujours une *référence* à un objet et non la valeur de "
|
|
|
|
|
"l'objet lui-même. [#]_ Lorsqu'une fonction appelle une autre fonction, une "
|
|
|
|
|
"nouvelle table de symboles locale est créée pour cet appel."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:292
|
|
|
|
|
msgid ""
|
|
|
|
|
"A function definition introduces the function name in the current symbol "
|
|
|
|
|
"table. The value of the function name has a type that is recognized by the "
|
|
|
|
|
"interpreter as a user-defined function. This value can be assigned to "
|
|
|
|
|
"another name which can then also be used as a function. This serves as a "
|
|
|
|
|
"general renaming mechanism::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Une définition de fonction introduit le nom de la fonction dans la table de "
|
|
|
|
|
"symboles courante. La valeur du nom de la fonction est un type qui est "
|
|
|
|
|
"reconnu par l'interpréteur comme une fonction utilisateur. Cette valeur peut "
|
|
|
|
|
"être affectée à un autre nom qui pourra alors être utilisé également comme "
|
|
|
|
|
"une fonction. Ceci fournit un mécanisme de renommage général : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:304
|
|
|
|
|
msgid ""
|
|
|
|
|
"Coming from other languages, you might object that ``fib`` is not a function "
|
|
|
|
|
"but a procedure since it doesn't return a value. In fact, even functions "
|
|
|
|
|
"without a :keyword:`return` statement do return a value, albeit a rather "
|
|
|
|
|
"boring one. This value is called ``None`` (it's a built-in name). Writing "
|
|
|
|
|
"the value ``None`` is normally suppressed by the interpreter if it would be "
|
|
|
|
|
"the only value written. You can see it if you really want to using :func:"
|
|
|
|
|
"`print`::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Si vous venez d'autres langages, vous pouvez penser que ``fib`` n'est pas "
|
|
|
|
|
"une fonction mais une procédure, puisqu'elle ne renvoie pas de résultat. En "
|
|
|
|
|
"fait, même les fonctions sans instruction :keyword:`return` renvoient une "
|
|
|
|
|
"valeur, quoique ennuyeuse. Cette valeur est appelée ``None`` (c'est le nom "
|
|
|
|
|
"d'une primitive). Écrire la valeur ``None`` est normalement supprimé par "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"l'interpréteur lorsqu'il s'agit de la seule valeur qui doit être écrite. "
|
|
|
|
|
"Vous pouvez le constater, si vous y tenez vraiment, en utilisant :func:"
|
2018-03-20 22:55:56 +00:00
|
|
|
|
"`print` ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:315
|
|
|
|
|
msgid ""
|
|
|
|
|
"It is simple to write a function that returns a list of the numbers of the "
|
|
|
|
|
"Fibonacci series, instead of printing it::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Il est facile d'écrire une fonction qui renvoie une liste de la série de "
|
2018-02-02 22:27:03 +00:00
|
|
|
|
"Fibonacci au lieu de l'afficher : ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:331
|
|
|
|
|
msgid "This example, as usual, demonstrates some new Python features:"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Cet exemple, comme d'habitude, illustre de nouvelles fonctionnalités de "
|
|
|
|
|
"Python :"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:333
|
|
|
|
|
msgid ""
|
|
|
|
|
"The :keyword:`return` statement returns with a value from a function. :"
|
|
|
|
|
"keyword:`return` without an expression argument returns ``None``. Falling "
|
|
|
|
|
"off the end of a function also returns ``None``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'instruction :keyword:`return` provoque la sortie de la fonction en "
|
|
|
|
|
"renvoyant une valeur. :keyword:`return` sans expression en paramètre renvoie "
|
|
|
|
|
"``None``. Arriver à la fin d'une fonction renvoie également ``None``."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:337
|
|
|
|
|
msgid ""
|
|
|
|
|
"The statement ``result.append(a)`` calls a *method* of the list object "
|
|
|
|
|
"``result``. A method is a function that 'belongs' to an object and is named "
|
|
|
|
|
"``obj.methodname``, where ``obj`` is some object (this may be an "
|
|
|
|
|
"expression), and ``methodname`` is the name of a method that is defined by "
|
|
|
|
|
"the object's type. Different types define different methods. Methods of "
|
|
|
|
|
"different types may have the same name without causing ambiguity. (It is "
|
|
|
|
|
"possible to define your own object types and methods, using *classes*, see :"
|
|
|
|
|
"ref:`tut-classes`) The method :meth:`append` shown in the example is defined "
|
|
|
|
|
"for list objects; it adds a new element at the end of the list. In this "
|
|
|
|
|
"example it is equivalent to ``result = result + [a]``, but more efficient."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'instruction ``result.append(a)`` appelle une *méthode* de l'objet "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"``result`` qui est une liste. Une méthode est une fonction qui \"appartient"
|
|
|
|
|
"\" à un objet et qui est nommée ``obj.methodname``, où ``obj`` est un objet "
|
|
|
|
|
"(il peut également s'agir d'une expression) et ``methodname`` est le nom "
|
|
|
|
|
"d'une méthode que le type de l'objet définit. Différents types définissent "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"différentes méthodes. Des méthodes de différents types peuvent porter le "
|
|
|
|
|
"même nom sans qu'il n'y ait d'ambigüité (vous pouvez définir vos propres "
|
|
|
|
|
"types d'objets et leurs méthodes en utilisant des *classes*, voir :ref:`tut-"
|
|
|
|
|
"classes`). La méthode :meth:`append` donnée dans cet exemple est définie "
|
|
|
|
|
"pour les listes ; elles ajoute un nouvel élément à la fin de la liste. Dans "
|
|
|
|
|
"cet exemple, elle est l'équivalent de ``result = result + [a]``, mais elle "
|
|
|
|
|
"est plus efficace."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:352
|
|
|
|
|
msgid "More on Defining Functions"
|
|
|
|
|
msgstr "D'avantage sur la définition des fonctions"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:354
|
|
|
|
|
msgid ""
|
|
|
|
|
"It is also possible to define functions with a variable number of arguments. "
|
|
|
|
|
"There are three forms, which can be combined."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Il est également possible de définir des fonctions avec un nombre variable "
|
|
|
|
|
"d'arguments. Trois syntaxes peuvent être utilisées, éventuellement combinées."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:361
|
|
|
|
|
msgid "Default Argument Values"
|
|
|
|
|
msgstr "Valeur par défaut des arguments"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:363
|
|
|
|
|
msgid ""
|
|
|
|
|
"The most useful form is to specify a default value for one or more "
|
|
|
|
|
"arguments. This creates a function that can be called with fewer arguments "
|
|
|
|
|
"than it is defined to allow. For example::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"La forme la plus utile consiste à indiquer une valeur par défaut pour "
|
|
|
|
|
"certains arguments. Ceci crée une fonction qui pourra être appelée avec "
|
|
|
|
|
"moins d'arguments que ceux présents dans sa définition. Par exemple : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:379
|
|
|
|
|
msgid "This function can be called in several ways:"
|
|
|
|
|
msgstr "Cette fonction peut être appelée de plusieurs façons :"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:381
|
|
|
|
|
msgid ""
|
|
|
|
|
"giving only the mandatory argument: ``ask_ok('Do you really want to quit?')``"
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"en ne fournissant que les arguments obligatoires : ``ask_ok('Do you really "
|
|
|
|
|
"want to quit?')``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:383
|
|
|
|
|
msgid ""
|
|
|
|
|
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
|
|
|
|
|
"2)``"
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"en fournissant une partie des arguments facultatifs : ``ask_ok('OK to "
|
|
|
|
|
"overwrite the file?', 2)``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:385
|
|
|
|
|
msgid ""
|
|
|
|
|
"or even giving all arguments: ``ask_ok('OK to overwrite the file?', 2, 'Come "
|
|
|
|
|
"on, only yes or no!')``"
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"en fournissant tous les arguments : ``ask_ok('OK to overwrite the file?', 2, "
|
|
|
|
|
"'Come on, only yes or no!')``"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:388
|
|
|
|
|
msgid ""
|
|
|
|
|
"This example also introduces the :keyword:`in` keyword. This tests whether "
|
|
|
|
|
"or not a sequence contains a certain value."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Cet exemple présente également le mot-clé :keyword:`in`. Celui-ci permet de "
|
|
|
|
|
"tester si une séquence contient une certaine valeur."
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:391
|
|
|
|
|
msgid ""
|
|
|
|
|
"The default values are evaluated at the point of function definition in the "
|
|
|
|
|
"*defining* scope, so that ::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Les valeurs par défaut sont évaluées lors de la définition de la fonction "
|
|
|
|
|
"dans la portée de *définition*, de telle sorte que : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:402
|
|
|
|
|
msgid "will print ``5``."
|
2018-02-02 22:27:03 +00:00
|
|
|
|
msgstr "Affiche ``5``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:404
|
|
|
|
|
msgid ""
|
|
|
|
|
"**Important warning:** The default value is evaluated only once. This makes "
|
|
|
|
|
"a difference when the default is a mutable object such as a list, "
|
|
|
|
|
"dictionary, or instances of most classes. For example, the following "
|
|
|
|
|
"function accumulates the arguments passed to it on subsequent calls::"
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"**Avertissement important :** la valeur par défaut n'est évaluée qu'une "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"seule fois. Ceci fait une différence lorsque cette valeur par défaut est un "
|
2017-10-27 15:42:48 +00:00
|
|
|
|
"objet muable tel qu'une liste, un dictionnaire ou des instances de la "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"plupart des classes. Par exemple, la fonction suivante accumule les "
|
|
|
|
|
"arguments qui lui sont passés au fil des appels successifs : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:417
|
|
|
|
|
msgid "This will print ::"
|
2018-02-02 22:27:03 +00:00
|
|
|
|
msgstr "Ceci affiche : ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:423
|
|
|
|
|
msgid ""
|
|
|
|
|
"If you don't want the default to be shared between subsequent calls, you can "
|
|
|
|
|
"write the function like this instead::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Si vous ne voulez pas que cette valeur par défaut soit partagée entre des "
|
|
|
|
|
"appels successifs, vous pouvez écrire la fonction de cette façon : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:436
|
|
|
|
|
msgid "Keyword Arguments"
|
|
|
|
|
msgstr "Les arguments nommés"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:438
|
|
|
|
|
msgid ""
|
|
|
|
|
"Functions can also be called using :term:`keyword arguments <keyword "
|
|
|
|
|
"argument>` of the form ``kwarg=value``. For instance, the following "
|
|
|
|
|
"function::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Les fonctions peuvent également être appelées en utilisant des :term:"
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"`arguments nommés <keyword argument>` sous la forme ``kwarg=value``. Par "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"exemple, la fonction suivante : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:447
|
|
|
|
|
msgid ""
|
|
|
|
|
"accepts one required argument (``voltage``) and three optional arguments "
|
|
|
|
|
"(``state``, ``action``, and ``type``). This function can be called in any "
|
|
|
|
|
"of the following ways::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"accepte un argument obligatoire (``voltage``) et trois arguments facultatifs "
|
|
|
|
|
"(``state``, ``action`` et ``type``). Cette fonction peut être appelée de "
|
|
|
|
|
"n'importe laquelle des façons suivantes : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:458
|
|
|
|
|
msgid "but all the following calls would be invalid::"
|
|
|
|
|
msgstr "mais tous les appels qui suivent sont incorrects : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:465
|
|
|
|
|
msgid ""
|
|
|
|
|
"In a function call, keyword arguments must follow positional arguments. All "
|
|
|
|
|
"the keyword arguments passed must match one of the arguments accepted by the "
|
|
|
|
|
"function (e.g. ``actor`` is not a valid argument for the ``parrot`` "
|
|
|
|
|
"function), and their order is not important. This also includes non-"
|
|
|
|
|
"optional arguments (e.g. ``parrot(voltage=1000)`` is valid too). No argument "
|
|
|
|
|
"may receive a value more than once. Here's an example that fails due to this "
|
|
|
|
|
"restriction::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Dans un appel de fonction, les arguments nommés doivent suivre les arguments "
|
|
|
|
|
"positionnés. Tous les arguments nommés doivent correspondre à l'un des "
|
|
|
|
|
"arguments acceptés par la fonction (par exemple, ``actor`` n'est pas un "
|
|
|
|
|
"argument accepté par la fonction ``parrot``), mais leur ordre n'est pas "
|
|
|
|
|
"important. Ceci inclut également les arguments facultatifs "
|
|
|
|
|
"(``parrot(voltage=1000)`` est également correct). Aucun argument ne peut "
|
|
|
|
|
"recevoir une valeur plus d'une fois, comme l'illustre cet exemple incorrect "
|
|
|
|
|
"du fait de cette restriction : ::"
|
|
|
|
|
|
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:481
|
|
|
|
|
msgid ""
|
|
|
|
|
"When a final formal parameter of the form ``**name`` is present, it receives "
|
|
|
|
|
"a dictionary (see :ref:`typesmapping`) containing all keyword arguments "
|
|
|
|
|
"except for those corresponding to a formal parameter. This may be combined "
|
|
|
|
|
"with a formal parameter of the form ``*name`` (described in the next "
|
|
|
|
|
"subsection) which receives a tuple containing the positional arguments "
|
|
|
|
|
"beyond the formal parameter list. (``*name`` must occur before ``**name``.) "
|
|
|
|
|
"For example, if we define a function like this::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Quand un dernier paramètre formel est présent sous la forme ``**name``, il "
|
|
|
|
|
"reçoit un dictionnaire (voir :ref:`typesmapping`) contenant tous les "
|
|
|
|
|
"arguments nommés à l'exception de ceux correspondant à un paramètre formel. "
|
|
|
|
|
"Ceci peut être combiné à un paramètre formel sous la forme ``*name`` (décrit "
|
|
|
|
|
"dans la section suivante) qui lui reçoit un tuple contenant les arguments "
|
|
|
|
|
"positionnés au-delà de la liste des paramètres formels (``*name`` doit être "
|
|
|
|
|
"présent avant ``**name``). Par exemple, si vous définissez une fonction "
|
2018-03-20 22:55:56 +00:00
|
|
|
|
"comme ceci ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:498
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "It could be called like this::"
|
|
|
|
|
msgstr "Elle pourrait être appelée comme ceci : ::"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:506
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "and of course it would print:"
|
2018-02-01 22:35:59 +00:00
|
|
|
|
msgstr "et, bien sûr, elle affiche :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:519
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
2017-04-02 20:14:06 +00:00
|
|
|
|
"Note that the order in which the keyword arguments are printed is guaranteed "
|
|
|
|
|
"to match the order in which they were provided in the function call."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"Notez que Python garantit que l'ordre d'affichage des arguments est le même "
|
|
|
|
|
"que l'ordre dans lesquels ils sont fournis lors de l'appel à la fonction."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:526
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Arbitrary Argument Lists"
|
|
|
|
|
msgstr "Listes d'arguments arbitraires"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:531
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Finally, the least frequently used option is to specify that a function can "
|
|
|
|
|
"be called with an arbitrary number of arguments. These arguments will be "
|
|
|
|
|
"wrapped up in a tuple (see :ref:`tut-tuples`). Before the variable number "
|
|
|
|
|
"of arguments, zero or more normal arguments may occur. ::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Pour terminer, l'option la moins fréquente consiste à indiquer qu'une "
|
|
|
|
|
"fonction peut être appelée avec un nombre arbitraire d'arguments. Ces "
|
|
|
|
|
"arguments sont intégrés dans un tuple (voir :ref:`tut-tuples`). Avant le "
|
|
|
|
|
"nombre variable d'arguments, zéro arguments normaux ou plus peuvent "
|
|
|
|
|
"apparaître : ::"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:540
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Normally, these ``variadic`` arguments will be last in the list of formal "
|
|
|
|
|
"parameters, because they scoop up all remaining input arguments that are "
|
|
|
|
|
"passed to the function. Any formal parameters which occur after the "
|
|
|
|
|
"``*args`` parameter are 'keyword-only' arguments, meaning that they can only "
|
|
|
|
|
"be used as keywords rather than positional arguments. ::"
|
|
|
|
|
msgstr ""
|
2017-09-24 10:31:50 +00:00
|
|
|
|
"Normalement, ces arguments ``variadiques`` sont les derniers paramètres, "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"parce qu'ils agrègent toutes les valeurs suivantes. Tout paramètre placé "
|
2017-09-24 10:31:50 +00:00
|
|
|
|
"après le paramètre ``*arg`` ne pourra être utilisé que par son nom."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:557
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Unpacking Argument Lists"
|
|
|
|
|
msgstr "Séparation des listes d'arguments"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:559
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The reverse situation occurs when the arguments are already in a list or "
|
|
|
|
|
"tuple but need to be unpacked for a function call requiring separate "
|
|
|
|
|
"positional arguments. For instance, the built-in :func:`range` function "
|
|
|
|
|
"expects separate *start* and *stop* arguments. If they are not available "
|
|
|
|
|
"separately, write the function call with the ``*``\\ -operator to unpack "
|
|
|
|
|
"the arguments out of a list or tuple::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"La situation inverse intervient lorsque les arguments sont déjà dans une "
|
|
|
|
|
"liste ou un tuple mais doivent être séparés pour un appel de fonction "
|
|
|
|
|
"nécessitant des arguments positionnés séparés. Par exemple, la primitive :"
|
|
|
|
|
"func:`range` attend des arguments *start* et *stop* distincts. S'ils ne sont "
|
|
|
|
|
"pas disponibles séparément, écrivez l'appel de fonction en utilisant "
|
|
|
|
|
"l'opérateur ``*`` pour séparer les arguments présents dans une liste ou un "
|
|
|
|
|
"tuple : ::"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:575
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"In the same fashion, dictionaries can deliver keyword arguments with the "
|
|
|
|
|
"``**``\\ -operator::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"De la même façon, les dictionnaires peuvent fournir des arguments nommés en "
|
2018-03-20 22:55:56 +00:00
|
|
|
|
"utilisant l'opérateur ``**`` ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:591
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Lambda Expressions"
|
|
|
|
|
msgstr "Fonctions anonymes"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:593
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Small anonymous functions can be created with the :keyword:`lambda` keyword. "
|
|
|
|
|
"This function returns the sum of its two arguments: ``lambda a, b: a+b``. "
|
|
|
|
|
"Lambda functions can be used wherever function objects are required. They "
|
|
|
|
|
"are syntactically restricted to a single expression. Semantically, they are "
|
|
|
|
|
"just syntactic sugar for a normal function definition. Like nested function "
|
|
|
|
|
"definitions, lambda functions can reference variables from the containing "
|
|
|
|
|
"scope::"
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"Avec le mot-clé :keyword:`lambda`, vous pouvez créer de petites fonctions "
|
|
|
|
|
"anonymes. En voici une qui renvoie la somme de ses deux arguments : ``lambda "
|
|
|
|
|
"a, b: a+b``. Les fonctions lambda peuvent être utilisées partout où un objet "
|
|
|
|
|
"fonction est attendu. Elles sont syntaxiquement restreintes à une seule "
|
|
|
|
|
"expression. Sémantiquement, elles ne sont que du sucre syntaxique pour une "
|
|
|
|
|
"définition de fonction normale. Comme les fonctions imbriquées, les "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"fonctions lambda peuvent référencer des variables de la portée "
|
|
|
|
|
"englobante : ::"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:610
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The above example uses a lambda expression to return a function. Another "
|
|
|
|
|
"use is to pass a small function as an argument::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'exemple précédent utilise une fonction anonyme pour renvoyer une fonction. "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"Une autre utilisation classique est de donner une fonction minimaliste "
|
2018-03-20 22:55:56 +00:00
|
|
|
|
"directement en temps que paramètre ::"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:622
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Documentation Strings"
|
|
|
|
|
msgstr "Chaînes de documentation"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:629
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Here are some conventions about the content and formatting of documentation "
|
|
|
|
|
"strings."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Voici quelques conventions concernant le contenu et le format des chaînes de "
|
|
|
|
|
"documentation."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:632
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The first line should always be a short, concise summary of the object's "
|
|
|
|
|
"purpose. For brevity, it should not explicitly state the object's name or "
|
|
|
|
|
"type, since these are available by other means (except if the name happens "
|
|
|
|
|
"to be a verb describing a function's operation). This line should begin "
|
|
|
|
|
"with a capital letter and end with a period."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"La première ligne devrait toujours être courte et résumer de manière concise "
|
|
|
|
|
"l'utilité de l'objet. Afin d'être bref, nul besoin de rappeler le nom de "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"l'objet ou son type, qui sont accessibles par d'autres moyens (sauf si le "
|
|
|
|
|
"nom est un verbe qui décrit une opération). Cette ligne devrait commencer "
|
|
|
|
|
"avec une majuscule et se terminer par un point."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:638
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"If there are more lines in the documentation string, the second line should "
|
|
|
|
|
"be blank, visually separating the summary from the rest of the description. "
|
|
|
|
|
"The following lines should be one or more paragraphs describing the object's "
|
|
|
|
|
"calling conventions, its side effects, etc."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"S'il y a d'autres lignes dans la chaîne de documentation, la deuxième ligne "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"devrait être vide, pour la séparer visuellement du reste de la description. "
|
|
|
|
|
"Les autres lignes peuvent alors constituer un ou plusieurs paragraphes "
|
|
|
|
|
"décrivant le mode d'utilisation de l'objet, ses effets de bord, etc."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:643
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"The Python parser does not strip indentation from multi-line string literals "
|
|
|
|
|
"in Python, so tools that process documentation have to strip indentation if "
|
|
|
|
|
"desired. This is done using the following convention. The first non-blank "
|
|
|
|
|
"line *after* the first line of the string determines the amount of "
|
|
|
|
|
"indentation for the entire documentation string. (We can't use the first "
|
|
|
|
|
"line since it is generally adjacent to the string's opening quotes so its "
|
|
|
|
|
"indentation is not apparent in the string literal.) Whitespace \"equivalent"
|
|
|
|
|
"\" to this indentation is then stripped from the start of all lines of the "
|
|
|
|
|
"string. Lines that are indented less should not occur, but if they occur "
|
|
|
|
|
"all their leading whitespace should be stripped. Equivalence of whitespace "
|
|
|
|
|
"should be tested after expansion of tabs (to 8 spaces, normally)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"L'analyseur de code Python ne supprime pas l'indentation des chaînes de "
|
|
|
|
|
"caractères littérales multi-lignes, donc les outils qui utilisent la "
|
|
|
|
|
"documentation doivent si besoin faire cette opération eux-mêmes. La "
|
|
|
|
|
"convention suivante s'applique : la première ligne non vide *après* la "
|
|
|
|
|
"première détermine la profondeur d'indentation de l'ensemble de la chaîne de "
|
|
|
|
|
"documentation (on ne peut pas utiliser la première ligne qui est "
|
|
|
|
|
"généralement accolée aux guillemets d'ouverture de la chaîne de caractères "
|
|
|
|
|
"et dont l'indentation n'est donc pas visible). Les espaces \"correspondant\" "
|
|
|
|
|
"à cette profondeur d'indentation sont alors supprimés du début de chacune "
|
|
|
|
|
"des lignes de la chaîne. Aucune ligne ne devrait présenter un niveau "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"d'indentation inférieur mais si cela arrive, toutes les espaces situés en "
|
|
|
|
|
"début de ligne doivent être supprimées. L'équivalent des espaces doit être "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"testé après expansion des tabulations (normalement remplacés par 4 espaces)."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:655
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Here is an example of a multi-line docstring::"
|
|
|
|
|
msgstr "Voici un exemple de chaîne de documentation multi-lignes : ::"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:673
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Function Annotations"
|
|
|
|
|
msgstr "Annotations de fonctions"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:680
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
":ref:`Function annotations <function>` are completely optional metadata "
|
|
|
|
|
"information about the types used by user-defined functions (see :pep:`484` "
|
|
|
|
|
"for more information)."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
":ref:`Function annotations <function>` sont des métadonnées optionnelles "
|
|
|
|
|
"décrivant les types utilisés par une fonction définie par l'utilisateur "
|
|
|
|
|
"(voir la :pep:`484` pour plus d'informations)."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:684
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Annotations are stored in the :attr:`__annotations__` attribute of the "
|
|
|
|
|
"function as a dictionary and have no effect on any other part of the "
|
|
|
|
|
"function. Parameter annotations are defined by a colon after the parameter "
|
|
|
|
|
"name, followed by an expression evaluating to the value of the annotation. "
|
|
|
|
|
"Return annotations are defined by a literal ``->``, followed by an "
|
|
|
|
|
"expression, between the parameter list and the colon denoting the end of "
|
|
|
|
|
"the :keyword:`def` statement. The following example has a positional "
|
|
|
|
|
"argument, a keyword argument, and the return value annotated::"
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Les annotations sont stockées dans l'attribut :attr:`__annotations__` de la "
|
|
|
|
|
"fonction, sous forme d'un dictionnaire, et n'ont aucun autre effet. Les "
|
|
|
|
|
"annotations sur les paramètres sont définis par deux points (:) après le nom "
|
|
|
|
|
"du paramètre suivi d'une expression donnant la valeur de l'annotation. Les "
|
|
|
|
|
"annotations de retour sont définies par ``->`` suivi d'une expression, entre "
|
|
|
|
|
"la liste des paramètres et les deux points de fin de l'instruction :keyword:"
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"`def`. L'exemple suivant a un paramètre positionnel, un paramètre nommé et "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"une valeur de retour annotée : ::"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:706
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Intermezzo: Coding Style"
|
2018-02-01 22:35:59 +00:00
|
|
|
|
msgstr "Aparté : le style de codage"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:711
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Now that you are about to write longer, more complex pieces of Python, it is "
|
|
|
|
|
"a good time to talk about *coding style*. Most languages can be written (or "
|
|
|
|
|
"more concise, *formatted*) in different styles; some are more readable than "
|
|
|
|
|
"others. Making it easy for others to read your code is always a good idea, "
|
|
|
|
|
"and adopting a nice coding style helps tremendously for that."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Maintenant que vous êtes prêt à écrire des programmes plus longs et plus "
|
|
|
|
|
"complexes, il est temps de parler du *style de codage*. La plupart des "
|
2017-08-17 17:44:34 +00:00
|
|
|
|
"langages peuvent être écrits (ou plutôt *formatés*) selon différents "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"styles ; certains sont plus lisibles que d'autres. Rendre la lecture de "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"votre code plus facile aux autres est toujours une bonne idée et adopter un "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"bon style de codage peut énormément vous y aider."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:717
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"For Python, :pep:`8` has emerged as the style guide that most projects "
|
|
|
|
|
"adhere to; it promotes a very readable and eye-pleasing coding style. Every "
|
|
|
|
|
"Python developer should read it at some point; here are the most important "
|
|
|
|
|
"points extracted for you:"
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"En Python, la plupart des projets adhèrent au style défini dans la :pep:"
|
|
|
|
|
"`8` ; elle met en avant un style de codage très lisible et agréable à l’œil. "
|
|
|
|
|
"Chaque développeur Python se doit donc de la lire et de s'en inspirer autant "
|
|
|
|
|
"que possible ; voici ses principaux points notables :"
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:722
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Use 4-space indentation, and no tabs."
|
2018-02-01 22:35:59 +00:00
|
|
|
|
msgstr "Utilisez des indentations de 4 espaces et pas de tabulation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:724
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"4 spaces are a good compromise between small indentation (allows greater "
|
|
|
|
|
"nesting depth) and large indentation (easier to read). Tabs introduce "
|
|
|
|
|
"confusion, and are best left out."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"4 espaces constituent un bon compromis entre une indentation courte (qui "
|
|
|
|
|
"permet une profondeur d'imbrication plus importante) et une longue (qui rend "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"le code plus facile à lire). Les tabulations introduisent de la confusion et "
|
|
|
|
|
"doivent être proscrites autant que possible."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:728
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Wrap lines so that they don't exceed 79 characters."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"Faites en sorte que les lignes ne dépassent pas 79 caractères, au besoin en "
|
|
|
|
|
"insérant des retours à la ligne."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:730
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"This helps users with small displays and makes it possible to have several "
|
|
|
|
|
"code files side-by-side on larger displays."
|
|
|
|
|
msgstr ""
|
2018-02-02 08:11:24 +00:00
|
|
|
|
"Vous facilitez ainsi la lecture pour les utilisateurs qui n'ont qu'un petit "
|
|
|
|
|
"écran et, pour les autres, cela leur permet de visualiser plusieurs fichiers "
|
|
|
|
|
"côte à côte."
|
2018-03-20 22:55:56 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:733
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Use blank lines to separate functions and classes, and larger blocks of code "
|
|
|
|
|
"inside functions."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Utilisez des lignes vides pour séparer les fonctions et les classes, ou pour "
|
|
|
|
|
"scinder de gros blocs de code à l'intérieur de fonctions."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:736
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "When possible, put comments on a line of their own."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Lorsque c'est possible, placez les commentaires sur leur propres lignes."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:738
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Use docstrings."
|
2018-03-20 23:16:43 +00:00
|
|
|
|
msgstr "Utilisez les chaînes de documentation."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:740
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Use spaces around operators and after commas, but not directly inside "
|
|
|
|
|
"bracketing constructs: ``a = f(1, 2) + g(3, 4)``."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Utilisez des espaces autour des opérateurs et après les virgules, mais pas "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"juste à l'intérieur des parenthèses : ``a = f(1, 2) + g(3, 4)``."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:743
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Name your classes and functions consistently; the convention is to use "
|
|
|
|
|
"``CamelCase`` for classes and ``lower_case_with_underscores`` for functions "
|
|
|
|
|
"and methods. Always use ``self`` as the name for the first method argument "
|
|
|
|
|
"(see :ref:`tut-firstclasses` for more on classes and methods)."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"Nommez toujours vos classes et fonctions de la même manière ; la convention "
|
|
|
|
|
"est d'utiliser une notation ``CamelCase`` pour les classes, et "
|
|
|
|
|
"``minuscules_avec_trait_bas`` pour les fonctions et méthodes. Utilisez "
|
|
|
|
|
"toujours ``self`` comme nom du premier argument des méthodes (voyez :ref:"
|
|
|
|
|
"`tut-firstclasses` pour en savoir plus sur les classes et les méthodes)."
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:748
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Don't use fancy encodings if your code is meant to be used in international "
|
|
|
|
|
"environments. Python's default, UTF-8, or even plain ASCII work best in any "
|
|
|
|
|
"case."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"N'utilisez pas d'encodage exotique dès lors que votre code est censé être "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"utilisé dans des environnements internationaux. Par défaut, Python travaille "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"en UTF-8. Pour couvrir tous les cas, préférez le simple ASCII."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:752
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Likewise, don't use non-ASCII characters in identifiers if there is only the "
|
|
|
|
|
"slightest chance people speaking a different language will read or maintain "
|
|
|
|
|
"the code."
|
|
|
|
|
msgstr ""
|
|
|
|
|
"De la même manière, n'utilisez que des caractères ASCII pour vos noms de "
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"variables s'il est envisageable qu'une personne parlant une autre langue "
|
|
|
|
|
"lise ou doive modifier votre code."
|
2016-10-30 09:46:26 +00:00
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:758
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid "Footnotes"
|
|
|
|
|
msgstr "Notes"
|
|
|
|
|
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#: ../Doc/tutorial/controlflow.rst:759
|
2016-10-30 09:46:26 +00:00
|
|
|
|
msgid ""
|
|
|
|
|
"Actually, *call by object reference* would be a better description, since if "
|
|
|
|
|
"a mutable object is passed, the caller will see any changes the callee makes "
|
|
|
|
|
"to it (items inserted into a list)."
|
|
|
|
|
msgstr ""
|
2018-02-01 22:35:59 +00:00
|
|
|
|
"En fait, *appels par référence d'objets* serait sans doute une description "
|
|
|
|
|
"plus juste dans la mesure où, si un objet muable est passé en argument, "
|
2016-10-30 09:46:26 +00:00
|
|
|
|
"l'appelant verra toutes les modifications qui lui auront été apportées par "
|
|
|
|
|
"l'appelé (insertion d'éléments dans une liste...)."
|
2017-04-02 20:14:06 +00:00
|
|
|
|
|
|
|
|
|
#~ msgid ""
|
|
|
|
|
#~ "Note that the list of keyword argument names is created by sorting the "
|
|
|
|
|
#~ "result of the keywords dictionary's ``keys()`` method before printing its "
|
|
|
|
|
#~ "contents; if this is not done, the order in which the arguments are "
|
|
|
|
|
#~ "printed is undefined."
|
|
|
|
|
#~ msgstr ""
|
2018-02-02 22:27:03 +00:00
|
|
|
|
#~ "Notez que la liste des arguments nommés est créée en classant les clés du "
|
|
|
|
|
#~ "dictionnaire extraites par la méthode ``keys()`` avant de les afficher. "
|
|
|
|
|
#~ "Si celà n'est pas fait, l'ordre dans lequel les arguments sont affichés "
|
2017-04-02 20:14:06 +00:00
|
|
|
|
#~ "n'est pas défini."
|