python-docs-fr/tutorial/introduction.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-01-15 22:33+0100\n"
"PO-Revision-Date: 2023-02-04 14:11+0100\n"
"Last-Translator: Fipaddict <fipaddict@protonmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 3.2.1\n"

#: tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "Introduction informelle à Python"

#: tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"Dans les exemples qui suivent, les entrées et sorties se distinguent par la "
"présence ou l'absence d'invite (:term:`>>>` et :term:`...`) : pour "
"reproduire les exemples, vous devez taper tout ce qui est après l'invite, au "
"moment où celle-ci apparaît ; les lignes qui n'affichent pas d'invite sont "
"les sorties de l'interpréteur. Notez qu'une invite secondaire affichée seule "
"sur une ligne dans un exemple indique que vous devez entrer une ligne vide ; "
"ceci est utilisé pour terminer une commande multi-lignes."

#: tutorial/introduction.rst:16
msgid ""
"You can toggle the display of prompts and output by clicking on ``>>>`` in "
"the upper-right corner of an example box.  If you hide the prompts and "
"output for an example, then you can easily copy and paste the input lines "
"into your interpreter."
msgstr ""
"Vous pouvez basculer l'affichage des invites et des sorties en cliquant sur "
"``>>>`` dans le coin haut-droit d'une boite d'exemple. En masquant les "
"invites et les sorties d'un exemple, vous pouvez facilement copier et coller "
"les lignes d'entrée dans votre interpréteur."

#: tutorial/introduction.rst:23
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments.  Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line.  A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal.  A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
"Beaucoup d'exemples de ce manuel, même ceux saisis à l'invite de "
"l'interpréteur, incluent des commentaires. Les commentaires en Python "
"commencent avec un caractère croisillon, ``#``, et s'étendent jusqu'à la fin "
"de la ligne. Un commentaire peut apparaître au début d'une ligne ou à la "
"suite d'un espace ou de code, mais pas à l'intérieur d'une chaîne de "
"caractères littérale. Un caractère croisillon à l'intérieur d'une chaîne de "
"caractères est juste un caractère croisillon. Comme les commentaires ne "
"servent qu'à expliquer le code et ne sont pas interprétés par Python, ils "
"peuvent être ignorés lorsque vous tapez les exemples."

#: tutorial/introduction.rst:31
msgid "Some examples::"
msgstr "Quelques exemples ::"

#: tutorial/introduction.rst:42
msgid "Using Python as a Calculator"
msgstr "Utilisation de Python comme une calculatrice"

#: tutorial/introduction.rst:44
msgid ""
"Let's try some simple Python commands.  Start the interpreter and wait for "
"the primary prompt, ``>>>``.  (It shouldn't take long.)"
msgstr ""
"Essayons quelques commandes Python simples. Démarrez l'interpréteur et "
"attendez l'invite primaire, ``>>>``. Ça ne devrait pas être long."

#: tutorial/introduction.rst:51
msgid "Numbers"
msgstr "Les nombres"

#: tutorial/introduction.rst:53
msgid ""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value.  Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
"L'interpréteur agit comme une simple calculatrice : vous pouvez lui entrer "
"une expression et il vous affiche la valeur. La syntaxe des expressions est "
"simple : les opérateurs ``+``, ``-``, ``*`` et ``/`` fonctionnent comme dans "
"la plupart des langages (par exemple, Pascal ou C) ; les parenthèses peuvent "
"être utilisées pour faire des regroupements. Par exemple ::"

#: tutorial/introduction.rst:68
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
"`float`.  We will see more about numeric types later in the tutorial."
msgstr ""
"Les nombres entiers (comme ``2``, ``4``, ``20``) sont de type :class:`int`, "
"alors que les décimaux (comme ``5.0``, ``1.6``) sont de type :class:`float`. "
"Vous trouvez plus de détails sur les types numériques plus loin dans ce "
"tutoriel."

#: tutorial/introduction.rst:72
msgid ""
"Division (``/``) always returns a float.  To do :term:`floor division` and "
"get an integer result you can use the ``//`` operator; to calculate the "
"remainder you can use ``%``::"
msgstr ""
"Les divisions (``/``) donnent toujours des :class:`!float`. Utilisez "
"l'opérateur ``//`` pour effectuer une :term:`division entière` et donc "
"obtenir un résultat entier. Pour obtenir le reste d'une division entière, "
"utilisez l'opérateur ``%`` ::"

#: tutorial/introduction.rst:86
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
"En Python, il est possible de calculer des puissances avec l'opérateur "
"``**`` [#]_ ::"

#: tutorial/introduction.rst:93
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
"Le signe égal (``=``) est utilisé pour affecter une valeur à une variable. "
"Dans ce cas, aucun résultat n'est affiché avant l'invite suivante ::"

#: tutorial/introduction.rst:101
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"Si une variable n'est pas « définie » (si aucune valeur ne lui a été "
"affectée), son utilisation produit une erreur ::"

#: tutorial/introduction.rst:109
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
"Les nombres à virgule flottante sont tout à fait admis (NdT : Python utilise "
"le point *.* comme séparateur entre la partie entière et la partie décimale "
"des nombres, c'est la convention anglo-saxonne) ; les opérateurs avec des "
"opérandes de types différents convertissent l'opérande de type entier en "
"type virgule flottante ::"

#: tutorial/introduction.rst:115
msgid ""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``.  This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
"En mode interactif, la dernière expression affichée est affectée à la "
"variable ``_``. Ainsi, lorsque vous utilisez Python comme calculatrice, cela "
"vous permet de continuer des calculs facilement, par exemple ::"

#: tutorial/introduction.rst:128
msgid ""
"This variable should be treated as read-only by the user.  Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
"Cette variable doit être considérée comme une variable en lecture seule par "
"l'utilisateur. Ne lui affectez pas de valeur explicitement — vous créeriez "
"ainsi une variable locale indépendante, avec le même nom, qui masquerait la "
"variable native et son fonctionnement magique."

#: tutorial/introduction.rst:132
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
"Fraction`. Python also has built-in support for :ref:`complex numbers "
"<typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr ""
"En plus des :class:`int` et des :class:`float`, il existe les :class:"
"`~decimal.Decimal` et les :class:`~fractions.Fraction`. Python gère aussi "
"les :ref:`nombres complexes <typesnumeric>`, en utilisant le suffixe ``j`` "
"ou ``J`` pour indiquer la partie imaginaire (tel que ``3+5j``)."

#: tutorial/introduction.rst:142
msgid "Strings"
msgstr "Chaînes de caractères"

#: tutorial/introduction.rst:144
msgid ""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways.  They can be enclosed in single quotes (``'...'``) or "
"double quotes (``\"...\"``) with the same result [#]_.  ``\\`` can be used "
"to escape quotes::"
msgstr ""
"En plus des nombres, Python sait aussi manipuler des chaînes de caractères, "
"qui peuvent être exprimées de différentes manières. Elles peuvent être "
"écrites entre guillemets simples (``'...'``) ou entre guillemets (``\"..."
"\"``) sans distinction [#]_. ``\\`` peut être utilisé pour protéger un "
"guillemet ::"

#: tutorial/introduction.rst:162
msgid ""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes.  While this might sometimes "
"look different from the input (the enclosing quotes could change), the two "
"strings are equivalent.  The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes.  The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
"En mode interactif, l'interpréteur affiche les chaînes de caractères entre "
"guillemets. Les guillemets et autres caractères spéciaux sont protégés avec "
"des barres obliques inverses (*backslash* en anglais). Bien que cela puisse "
"être affiché différemment de ce qui a été entré (les guillemets peuvent "
"changer), les deux formats sont équivalents. La chaîne est affichée entre "
"guillemets si elle contient un guillemet simple et aucun guillemet, sinon "
"elle est affichée entre guillemets simples. La fonction :func:`print` "
"affiche les chaînes de manière plus lisible, en retirant les guillemets et "
"en affichant les caractères spéciaux qui étaient protégés par une barre "
"oblique inverse ::"

#: tutorial/introduction.rst:182
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"Si vous ne voulez pas que les caractères précédés d'un ``\\`` soient "
"interprétés comme étant spéciaux, utilisez les *chaînes brutes* (*raw "
"strings* en anglais) en préfixant la chaîne d'un ``r`` ::"

#: tutorial/introduction.rst:192
msgid ""
"There is one subtle aspect to raw strings: a raw string may not end in an "
"odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-programming-"
"raw-string-backslash>` for more information and workarounds."
msgstr ""
"Il existe une petite subtilité concernant les chaînes brutes : une chaîne "
"brute ne peut pas se terminer par un nombre impair de caractères ``\\`` ; "
"voir :ref:`l'entrée FAQ <faq-programming-raw-string-backslash>` pour plus "
"d'informations et des solutions de contournement."

#: tutorial/introduction.rst:197
msgid ""
"String literals can span multiple lines.  One way is using triple-quotes: "
"``\"\"\"...\"\"\"`` or ``'''...'''``.  End of lines are automatically "
"included in the string, but it's possible to prevent this by adding a ``\\`` "
"at the end of the line.  The following example::"
msgstr ""
"Les chaînes de caractères peuvent s'étendre sur plusieurs lignes. Utilisez "
"alors des triples guillemets, simples ou doubles : ``'''...'''`` ou "
"``\"\"\"...\"\"\"``. Les retours à la ligne sont automatiquement inclus, "
"mais on peut l'empêcher en ajoutant ``\\`` à la fin de la ligne. L'exemple "
"suivant ::"

#: tutorial/introduction.rst:208
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
"produit l'affichage suivant (notez que le premier retour à la ligne n'est "
"pas inclus) :"

#: tutorial/introduction.rst:216
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
"Les chaînes peuvent être concaténées (collées ensemble) avec l'opérateur "
"``+`` et répétées avec l'opérateur ``*`` ::"

#: tutorial/introduction.rst:223
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
"Plusieurs chaînes de caractères, écrites littéralement (c'est-à-dire entre "
"guillemets), côte à côte, sont automatiquement concaténées. ::"

#: tutorial/introduction.rst:229
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr ""
"Cette fonctionnalité est surtout intéressante pour couper des chaînes trop "
"longues ::"

#: tutorial/introduction.rst:236
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"Cela ne fonctionne cependant qu'avec les chaînes littérales, pas avec les "
"variables ni les expressions ::"

#: tutorial/introduction.rst:250
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
"Pour concaténer des variables, ou des variables avec des chaînes littérales, "
"utilisez l'opérateur ``+`` ::"

#: tutorial/introduction.rst:255
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
"Les chaînes de caractères peuvent être indexées (ou indicées, c'est-à-dire "
"que l'on peut accéder aux caractères par leur position), le premier "
"caractère d'une chaîne étant à la position 0. Il n'existe pas de type "
"distinct pour les caractères, un caractère est simplement une chaîne de "
"longueur 1 ::"

#: tutorial/introduction.rst:265
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"Les indices peuvent également être négatifs, on compte alors en partant de "
"la droite. Par exemple ::"

#: tutorial/introduction.rst:274
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr ""
"Notez que, comme ``-0`` égale ``0``, les indices négatifs commencent par "
"``-1``."

#: tutorial/introduction.rst:276
msgid ""
"In addition to indexing, *slicing* is also supported.  While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
"En plus d'accéder à un élément par son indice, il est aussi possible de "
"« trancher » (*slice* en anglais) une chaîne. Accéder à une chaîne par un "
"indice permet d'obtenir un caractère, *trancher* permet d'obtenir une sous-"
"chaîne ::"

#: tutorial/introduction.rst:284
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"Les valeurs par défaut des indices de tranches ont une utilité ; le premier "
"indice vaut zéro par défaut (c.-à-d. lorsqu'il est omis), le deuxième "
"correspond par défaut à la taille de la chaîne de caractères ::"

#: tutorial/introduction.rst:294
msgid ""
"Note how the start is always included, and the end always excluded.  This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
"Notez que le début est toujours inclus et la fin toujours exclue. Cela "
"assure que ``s[:i] + s[i:]`` est toujours égal à ``s`` ::"

#: tutorial/introduction.rst:302
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
"Pour mémoriser la façon dont les tranches fonctionnent, vous pouvez imaginer "
"que les indices pointent *entre* les caractères, le côté gauche du premier "
"caractère ayant la position 0. Le côté droit du dernier caractère d'une "
"chaîne de *n* caractères a alors pour indice *n*. Par exemple ::"

#: tutorial/introduction.rst:313
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
"La première ligne de nombres donne la position des indices 0…6 dans la "
"chaîne ; la deuxième ligne donne l'indice négatif correspondant. La tranche "
"de *i* à *j* est constituée de tous les caractères situés entre les bords "
"libellés *i* et *j*, respectivement."

#: tutorial/introduction.rst:318
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds.  For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
"Pour des indices non négatifs, la longueur d'une tranche est la différence "
"entre ces indices, si les deux sont entre les bornes. Par exemple, la "
"longueur de ``word[1:3]`` est 2."

#: tutorial/introduction.rst:322
msgid "Attempting to use an index that is too large will result in an error::"
msgstr "Utiliser un indice trop grand produit une erreur ::"

#: tutorial/introduction.rst:329
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"Cependant, les indices hors bornes sont gérés silencieusement lorsqu'ils "
"sont utilisés dans des tranches ::"

#: tutorial/introduction.rst:337
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"Les chaînes de caractères, en Python, ne peuvent pas être modifiées. On dit "
"qu'elles sont :term:`immuables <immutable>`. Affecter une nouvelle valeur à "
"un indice dans une chaîne produit une erreur ::"

#: tutorial/introduction.rst:349
msgid "If you need a different string, you should create a new one::"
msgstr ""
"Si vous avez besoin d'une chaîne différente, vous devez en créer une "
"nouvelle ::"

#: tutorial/introduction.rst:356
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "La fonction native :func:`len` renvoie la longueur d'une chaîne ::"

#: tutorial/introduction.rst:367
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: tutorial/introduction.rst:366
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"Les chaînes de caractères sont des exemples de *types séquences* ; elles "
"acceptent donc les opérations classiques prises en charge par ces types."

#: tutorial/introduction.rst:371
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: tutorial/introduction.rst:370
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
"Les chaînes de caractères gèrent un large éventail de méthodes de "
"transformations basiques et de recherche."

#: tutorial/introduction.rst:374
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"

#: tutorial/introduction.rst:374
msgid "String literals that have embedded expressions."
msgstr "Des chaînes littérales qui contiennent des expressions."

#: tutorial/introduction.rst:377
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"

#: tutorial/introduction.rst:377
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
"Informations sur le formatage des chaînes avec la méthode :meth:`str.format`."

#: tutorial/introduction.rst:380
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"

#: tutorial/introduction.rst:380
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
"Description détaillée des anciennes méthodes de mise en forme, appelées "
"lorsque les chaînes de caractères sont à gauche de l'opérateur ``%``."

#: tutorial/introduction.rst:387
msgid "Lists"
msgstr "Listes"

#: tutorial/introduction.rst:389
msgid ""
"Python knows a number of *compound* data types, used to group together other "
"values.  The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets.  Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
"Python connaît différents types de données *combinés*, utilisés pour "
"regrouper plusieurs valeurs. Le plus souple est la *liste*, qui peut être "
"écrit comme une suite, placée entre crochets, de valeurs (éléments) séparées "
"par des virgules. Les éléments d'une liste ne sont pas obligatoirement tous "
"du même type, bien qu'à l'usage ce soit souvent le cas. ::"

#: tutorial/introduction.rst:398
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
"Comme les chaînes de caractères (et toute autre type de :term:`sequence`), "
"les listes peuvent être indicées et découpées ::"

#: tutorial/introduction.rst:408
msgid ""
"All slice operations return a new list containing the requested elements.  "
"This means that the following slice returns a :ref:`shallow copy "
"<shallow_vs_deep_copy>` of the list::"
msgstr ""
"Toutes les opérations par tranches renvoient une nouvelle liste contenant "
"les éléments demandés. Cela signifie que l'opération suivante renvoie une :"
"ref:`copie (superficielle) <shallow_vs_deep_copy>` de la liste ::"

#: tutorial/introduction.rst:415
msgid "Lists also support operations like concatenation::"
msgstr "Les listes gèrent aussi les opérations comme les concaténations ::"

#: tutorial/introduction.rst:420
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
"Mais à la différence des chaînes qui sont :term:`immuables <immutable>`, les "
"listes sont :term:`muables <mutable>` : il est possible de modifier leur "
"contenu ::"

#: tutorial/introduction.rst:430
msgid ""
"You can also add new items at the end of the list, by using the :meth:`~list."
"append` *method* (we will see more about methods later)::"
msgstr ""
"Il est aussi possible d'ajouter de nouveaux éléments à la fin d'une liste "
"avec la méthode :meth:`~list.append` (les méthodes sont abordées plus "
"tard) ::"

#: tutorial/introduction.rst:438
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"Des affectations de tranches sont également possibles, ce qui peut même "
"modifier la taille de la liste ou la vider complètement ::"

#: tutorial/introduction.rst:457
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "La primitive :func:`len` s'applique aussi aux listes ::"

#: tutorial/introduction.rst:463
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
"Il est possible d'imbriquer des listes (c.-à-d. créer des listes contenant "
"d'autres listes). Par exemple ::"

#: tutorial/introduction.rst:479
msgid "First Steps Towards Programming"
msgstr "Premiers pas vers la programmation"

#: tutorial/introduction.rst:481
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together.  For instance, we can write an initial sub-sequence of the "
"`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_number>`_ as "
"follows::"
msgstr ""
"Bien entendu, on peut utiliser Python pour des tâches plus compliquées que "
"d'additionner deux et deux. Par exemple, on peut écrire le début de la "
"`suite de Fibonacci <https://fr.wikipedia.org/wiki/Suite_de_Fibonacci>`_ "
"comme ceci ::"

#: tutorial/introduction.rst:501
msgid "This example introduces several new features."
msgstr "Cet exemple introduit plusieurs nouvelles fonctionnalités."

#: tutorial/introduction.rst:503
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1.  On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place.  The right-"
"hand side expressions are evaluated  from the left to the right."
msgstr ""
"La première ligne contient une *affectation multiple* : les variables ``a`` "
"et ``b`` se voient affecter simultanément leurs nouvelles valeurs 0 et 1. "
"Cette méthode est encore utilisée à la dernière ligne, pour démontrer que "
"les expressions sur la partie droite de l'affectation sont toutes évaluées "
"avant que les affectations ne soient effectuées. Ces expressions en partie "
"droite sont toujours évaluées de la gauche vers la droite."

#: tutorial/introduction.rst:509
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true.  In Python, like in C, any non-zero integer value is "
"true; zero is false.  The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false.  The test used in the example is a simple comparison.  The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
"La boucle :keyword:`while` s'exécute tant que la condition (ici : ``a < "
"10``) reste vraie. En Python, comme en C, tout entier différent de zéro est "
"vrai et zéro est faux. La condition peut aussi être une chaîne de "
"caractères, une liste, ou en fait toute séquence ; une séquence avec une "
"valeur non nulle est vraie, une séquence vide est fausse. Le test utilisé "
"dans l'exemple est une simple comparaison. Les opérateurs de comparaison "
"standards sont écrits comme en C : ``<`` (inférieur), ``>`` (supérieur), "
"``==`` (égal), ``<=`` (inférieur ou égal), ``>=`` (supérieur ou égal) et ``!"
"=`` (non égal)."

#: tutorial/introduction.rst:518
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements.  At the interactive prompt, you have to type a tab or "
"space(s) for each indented line.  In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility.  When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line).  Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"Le *corps* de la boucle est *indenté* : l'indentation est la méthode "
"utilisée par Python pour regrouper des instructions. En mode interactif, "
"vous devez saisir une tabulation ou des espaces pour chaque ligne indentée. "
"En pratique, vous aurez intérêt à utiliser un éditeur de texte pour les "
"saisies plus compliquées ; tous les éditeurs de texte dignes de ce nom "
"disposent d'une fonction d'auto-indentation. Lorsqu'une expression composée "
"est saisie en mode interactif, elle doit être suivie d'une ligne vide pour "
"indiquer qu'elle est terminée (car l'analyseur ne peut pas deviner que vous "
"venez de saisir la dernière ligne). Notez bien que toutes les lignes à "
"l'intérieur d'un bloc doivent être indentées au même niveau."

#: tutorial/introduction.rst:527
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating point quantities, and strings.  Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
"La fonction :func:`print` écrit les valeurs des paramètres qui lui sont "
"fournis. Ce n'est pas la même chose que d'écrire l'expression que vous "
"voulez afficher (comme nous l'avons fait dans l'exemple de la calculatrice), "
"en raison de la manière qu'a ``print`` de gérer les paramètres multiples, "
"les nombres décimaux et les chaînes. Les chaînes sont affichées sans "
"apostrophe et une espace est insérée entre les éléments de telle sorte que "
"vous pouvez facilement formater les choses, comme ceci ::"

#: tutorial/introduction.rst:538
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
"Le paramètre nommé *end* peut servir pour enlever le retour à la ligne ou "
"pour terminer la ligne par une autre chaîne ::"

#: tutorial/introduction.rst:550
msgid "Footnotes"
msgstr "Notes"

#: tutorial/introduction.rst:551
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``.  To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
"Puisque ``**`` est prioritaire sur ``-``, ``-3 ** 2`` est interprété ``-(3 "
"** 2)`` et vaut donc ``-9``. Pour éviter cela et obtenir ``9``, utilisez des "
"parenthèses : ``(-3) ** 2``."

#: tutorial/introduction.rst:555
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"Contrairement à d'autres langages, les caractères spéciaux comme ``\\n`` ont "
"la même signification entre guillemets (``\"...\"``) ou entre guillemets "
"simples (``'...'``). La seule différence est que, dans une chaîne entre "
"guillemets, il n'est pas nécessaire de protéger les guillemets simples et "
"vice-versa."