# 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"
"POT-Creation-Date: 2016-10-30 10:40+0100\n"
"PO-Revision-Date: 2016-11-19 16:39+0100\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../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 ""
"L'instruction :keyword:`if` est sans doute la plus connue. Par exemple : ::"

#: ../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 ""
"Il peut y avoir un nombre quelconque de parties :keyword:`elif`, et la "
"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. "
"Par exemple (sans jeu de mots) :"

#: ../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 "
"opération particulièrement simple : ::"

#: ../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 ""
"Avec ``for w in words:``, l'exemple tenterait de créer une liste infinie, en "
"insérant ``defenestrate`` indéfiniment."

#: ../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:"
"`range` est faite pour cela. Elle génère des suites arithmétiques : :"

#: ../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, "
"que l'on appelle également parfois le 'pas') ::"

#: ../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 :"
"func:`range` et :func:`len` ::"

#: ../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::"
msgstr "Une chose étrange se produit lorsqu'on affiche un range : :"

#: ../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 ""
"Les objets données par :func:`range` se comportent presque comme des listes, "
"mais n'en sont pas. Ce sont des objets qui génèrent les éléments de la "
"séquence au fur et à mesure de leur itération, économisant ainsi de l'espace."

#: ../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 "
"s'attendent à quelque-chose duquel ils peuvent tirer des éléments, "
"successives successivement, jusqu'à épuisement. On a vu que l'instruction :"
"keyword:`for` est un iterateur. La fonction :func:`list` en est un autre, "
"qui créé des listes à partir d'iterables : ::"

#: ../Doc/tutorial/controlflow.rst:152
msgid ""
"Later we will see more functions that return iterables and take iterables as "
"argument."
msgstr ""
"Plus loin nous verrons d'autre fonctions qui donnent des iterables ou en "
"prennent en paramètre."

#: ../Doc/tutorial/controlflow.rst:158
msgid ""
":keyword:`break` and :keyword:`continue` Statements, and :keyword:`else` "
"Clauses on Loops"
msgstr ""
"Les instructions :keyword:`break` et :keyword:`continue`, et les clauses :"
"keyword:`else` au sein des boucles"

#: ../Doc/tutorial/controlflow.rst:160
msgid ""
"The :keyword:`break` statement, like in C, breaks out of the smallest "
"enclosing :keyword:`for` or :keyword:`while` loop."
msgstr ""
"L'instruction :keyword:`break`, comme en C, interrompt la boucle :keyword:"
"`for` ou :keyword:`while` la plus imbriquée."

#: ../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 "
"effectue une recherche de nombres premiers, en est une démonstration : ::"

#: ../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 ""
"(Oui, ce code est correct. Regardez attentivement : l'instruction ``else`` "
"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 "
"être suivi du nom de la fonction et d'une liste entre parenthèses de ses "
"paramètres. L'instruction qui constitue le corps de la fonction débute à la "
"ligne suivante, et doit être indentée."

#: ../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 "
"chaîne de documentation de la fonction, ou :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 "
"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 "
"bonne habitude que de documenter le code que vous écrivez !"

#: ../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 "
"valeur dans la table de symboles locale ; tandis que les références de "
"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 "
"symboles globale et finallement dans la table de noms des primitives. Par "
"conséquent, il est impossible d'affecter une valeur à une variable globale "
"(sauf en utilisant une instruction :keyword:`global`), bien qu'elles "
"puissent être référencées."

#: ../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 "
"table de symboles locale de la fonction appelée lorsqu'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."

#: ../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 "
"l'interpréteur lorsqu'il s'agit de la seule value écrite. Vous pouvez le "
"voir si vous y tenez vraiment en utilisant :func:`print` ::"

#: ../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 "
"Fibonacci au lieu de l'imprimer : ::"

#: ../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 "
"``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 définie par le type de l'objet. Différents types définissent "
"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 ""
"en ne fournissant que les arguments obligatoires : ``ask_ok('Voulez-vous "
"vraiment quitter ?')``"

#: ../Doc/tutorial/controlflow.rst:383
msgid ""
"giving one of the optional arguments: ``ask_ok('OK to overwrite the file?', "
"2)``"
msgstr ""
"en fournissant une partie des arguments facultatifs : ``ask_ok('OK pour "
"écraser le fichier ?', 2)``"

#: ../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 ""
"en fournissant tous les arguments : ``ask_ok('OK pour écraser le fichier ?', "
"2, 'Allez, seulement oui ou non !')``"

#: ../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``."
msgstr "imprimera ``5``."

#: ../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 ""
"**Avertissement important :** La valeur par défaut n'est évaluée qu'une "
"seule fois. Ceci fait une différence lorsque cette valeur par défaut est un "
"objet mutable tel qu'une liste, un dictionnaire ou des instances de la "
"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 ::"
msgstr "Ceci imprimera : ::"

#: ../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:"
"`arguments nommés <keyword argument>` sous la form ``kwarg=value``. Par "
"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 "
"comme ceci :"

#: ../Doc/tutorial/controlflow.rst:499
msgid "It could be called like this::"
msgstr "Elle pourrait être appelée comme ceci : ::"

#: ../Doc/tutorial/controlflow.rst:507
msgid "and of course it would print:"
msgstr "et bien sûr, il afficherait :"

#: ../Doc/tutorial/controlflow.rst:520
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 ""
"Notez que la liste des arguments nommés est créée en triant les clés du "
"dictionnaire extraites par la méthode ``keys()`` avant de les imprimer. Si "
"celà n'est pas fait, l'ordre dans lequel les arguments sont imprimée n'est "
"pas défini."

#: ../Doc/tutorial/controlflow.rst:527
msgid "Arbitrary Argument Lists"
msgstr "Listes d'arguments arbitraires"

#: ../Doc/tutorial/controlflow.rst:532
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 : ::"

#: ../Doc/tutorial/controlflow.rst:541
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 ""
"Normalement, c'est arguments ``variadiques`` sont les derniers paramètres, "
"parce qu'ils agrègent toutes les valeurs suivantes. Tout paramètre placé "
"après le paramètre ``*arg`` ne pourront être utilisées que par leur nom."

#: ../Doc/tutorial/controlflow.rst:558
msgid "Unpacking Argument Lists"
msgstr "Séparation des listes d'arguments"

#: ../Doc/tutorial/controlflow.rst:560
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 : ::"

#: ../Doc/tutorial/controlflow.rst:576
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 "
"utilisant l'opérateur ``**`` ::"

#: ../Doc/tutorial/controlflow.rst:592
msgid "Lambda Expressions"
msgstr "Fonctions anonymes"

#: ../Doc/tutorial/controlflow.rst:594
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 ""
"Avec le mot-clé :keyword:`lambda`, on peut créer de petites fonctions "
"anonymes. Voilàune fonction 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 qu'un sucre syntaxique pour "
"une définition de fonction normale. Comme les fonctions imbriquées, les "
"fonctions lambda peuvent référencer des variables de la portée "
"englobante : ::"

#: ../Doc/tutorial/controlflow.rst:611
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. "
"Un aute usage typique est de donner une fonction minimaliste directement en "
"temps que paramètre::"

#: ../Doc/tutorial/controlflow.rst:623
msgid "Documentation Strings"
msgstr "Chaînes de documentation"

#: ../Doc/tutorial/controlflow.rst:630
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."

#: ../Doc/tutorial/controlflow.rst:633
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 ""
"La première ligne devrait toujours être courte, un résumé concis de "
"l'utilité de l'objet. Pour être bref, nul besoin de rappeler le nom de "
"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."

#: ../Doc/tutorial/controlflow.rst:639
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 ""
"Si il a d'autres lignes dans la chaîne de documentation, la seconde ligne "
"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."

#: ../Doc/tutorial/controlflow.rst:644
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 "
"d'indentation inférieur mais si cela arrive, tous les espaces situés en "
"début de ligne doivent être supprimés. L'équivalent des espaces doit être "
"testé après expansion des tabulations (normalement remplacés par 4 espaces)."

#: ../Doc/tutorial/controlflow.rst:656
msgid "Here is an example of a multi-line docstring::"
msgstr "Voici un exemple de chaîne de documentation multi-lignes : ::"

#: ../Doc/tutorial/controlflow.rst:674
msgid "Function Annotations"
msgstr "Annotations de fonctions"

#: ../Doc/tutorial/controlflow.rst:681
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 ""
":ref:`Function annotations <function>` sont des métadonnée optionnelles "
"décrivant les types utilisées par une fonction définie par l'utilisateur "
"(Voir la :pep:`484` pour plus d'informations)."

#: ../Doc/tutorial/controlflow.rst:685
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:"
"`def`. L'exemple suivant a un paramètre positionnel, un paramètre nommé, et "
"une valeur de retour annotée : ::"

#: ../Doc/tutorial/controlflow.rst:707
msgid "Intermezzo: Coding Style"
msgstr "Un style de codage : Intermezzo"

#: ../Doc/tutorial/controlflow.rst:712
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 "
"langages peuvent être écrits (ou plutôt *formattés*) selon différents "
"styles ; certains sont plus lisibles que d'autres. Rendre la lecture de "
"votre code plus facile aux autres est toujours une bonne idée, et adopter un "
"bon style de codage peut énormément vous y aider."

#: ../Doc/tutorial/controlflow.rst:718
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 ""
"En Python, la :pep:`8` a émergé comme étant un guide auquel la plupart des "
"projets adhèrent ; elle met en avant un style de codage très lisible et "
"agréable à l'oeil. Chaque développeur Python devrait donc la lire et s'en "
"inspirer autant que possible ; voici ses principaux points notables :"

#: ../Doc/tutorial/controlflow.rst:723
msgid "Use 4-space indentation, and no tabs."
msgstr "Utilisez des indentations de 4 espaces, et pas de tabulation."

#: ../Doc/tutorial/controlflow.rst:725
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 "
"le code plus facile à lire). Les tabulations introduisent de la confusion, "
"et doivent être proscrites autant que possible."

#: ../Doc/tutorial/controlflow.rst:729
msgid "Wrap lines so that they don't exceed 79 characters."
msgstr ""
"Faites des retours à la ligne, de telle sorte qu'elles n'excèdent pas 79 "
"caractères."

#: ../Doc/tutorial/controlflow.rst:731
msgid ""
"This helps users with small displays and makes it possible to have several "
"code files side-by-side on larger displays."
msgstr ""
"Ceci aide les utilisateurs ne disposant que de petits écrans, et permet sur "
"de plus grands de disposer plusieurs fichiers côte à côte sans difficulté."

#: ../Doc/tutorial/controlflow.rst:734
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."

#: ../Doc/tutorial/controlflow.rst:737
msgid "When possible, put comments on a line of their own."
msgstr ""
"Lorsque c'est possible, placez les commentaires sur leur propres lignes."

#: ../Doc/tutorial/controlflow.rst:739
msgid "Use docstrings."
msgstr "Utilisez les chaînes de documentation"

#: ../Doc/tutorial/controlflow.rst:741
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 "
"directement à l'intérieur des parenthèses : ``a = f(1, 2) + g(3, 4)``."

#: ../Doc/tutorial/controlflow.rst:744
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)."

#: ../Doc/tutorial/controlflow.rst:749
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 ""
"N'utilisez pas d'encodages exotiques dès lors que votre code est sensé être "
"utilisé dans des environnements internationaux. Par défaut, Python travaille "
"en UTF-8, ou sinon du simple ASCII fonctionne dans la plupart des cas."

#: ../Doc/tutorial/controlflow.rst:753
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 "
"variables si vous soupçonnez qu'un personne parlant une autre langue lira ou "
"devra modifier votre code."

#: ../Doc/tutorial/controlflow.rst:759
msgid "Footnotes"
msgstr "Notes"

#: ../Doc/tutorial/controlflow.rst:760
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 ""
"En fait, *appels par référence d'objets* serait sans doute une desciption "
"plus juste, dans la mesure où si un objet mutable est passé en argument, "
"l'appelant verra toutes les modifications qui lui auront été apportées par "
"l'appelé (insertion d'éléments dans une liste...)."