forked from AFPy/python-docs-fr
Julien Palard
0d4bffbcf9
Long debate between those words. We could use "modifiable" too but the binary relation between "immuable" and "modifiable" is less clear. "muable" was in the 6th edition of the dictionnary of the Académie française.
667 lines
30 KiB
Plaintext
667 lines
30 KiB
Plaintext
# 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: 2017-08-10 00:49+0200\n"
|
|
"PO-Revision-Date: 2017-10-27 17:27+0200\n"
|
|
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
|
"Language-Team: \n"
|
|
"Language: fr\n"
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
"X-Generator: Poedit 2.0.2\n"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:5
|
|
msgid "An Informal Introduction to Python"
|
|
msgstr "Introduction informelle à Python"
|
|
|
|
#: ../Doc/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."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:14
|
|
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 dièse, ``#``, 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 dièse à l'intérieur d'une chaîne de caractères est "
|
|
"juste un caractère dièse. 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."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:22
|
|
msgid "Some examples::"
|
|
msgstr "Quelques exemples : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:33
|
|
msgid "Using Python as a Calculator"
|
|
msgstr "Utiliser Python comme une calculatrice"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:35
|
|
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."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:42
|
|
msgid "Numbers"
|
|
msgstr "Les nombres"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:44
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:59
|
|
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 nombre 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`. "
|
|
"Plus de détails sont données sur les types numériques plus loin dans ce "
|
|
"tutoriel."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:63
|
|
msgid ""
|
|
"Division (``/``) always returns a float. To do :term:`floor division` and "
|
|
"get an integer result (discarding any fractional 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 des divisions entières, et donc obtenir un "
|
|
"résultat entier. Pour obtenir le reste de cette division entière, utilisez "
|
|
"l'opérateur ``%`` ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:77
|
|
msgid ""
|
|
"With Python, it is possible to use the ``**`` operator to calculate powers "
|
|
"[#]_::"
|
|
msgstr ""
|
|
"Avec Python il est possible de calculer des puissances avec l'opérateur "
|
|
"``**`` [#]_ ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:84
|
|
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. "
|
|
"Après cela, aucun résultat n'est affiché avant l'invite suivante : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:92
|
|
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é), l'utiliser engendrera une erreur : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:100
|
|
msgid ""
|
|
"There is full support for floating point; operators with mixed type operands "
|
|
"convert the integer operand to floating point::"
|
|
msgstr ""
|
|
"Il y a un support complet des nombres à virgule flottante ; les opérateurs "
|
|
"avec des types d'opérandes mélangés convertissent l'opérande entier en "
|
|
"virgule flottante : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:106
|
|
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 ``_``. Ce qui signifie que lorsque vous utilisez Python comme "
|
|
"calculatrice, il est parfois plus simple de continuer des calculs, par "
|
|
"exemple : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:119
|
|
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."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:123
|
|
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:`nombre complexes <typesnumeric>`, en utilisant le suffixe ``j`` ou "
|
|
"``J`` pour indiquer la partie imaginaire (tel que: ``3+5j``)."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:133
|
|
msgid "Strings"
|
|
msgstr "Les chaînes de caractères"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:135
|
|
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 ""
|
|
"Au delà des nombres, Python peut aussi manipuler des chaînes de caractères, "
|
|
"qui peuvent être exprimés 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 : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:153
|
|
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 et en protégant les guillemets et autres caractères spéciaux avec "
|
|
"des antislash. Bien que cela puisse paraître différent de ce qui a été donné "
|
|
"(les guillemets peuvent changer) La chaîne est affichée entre guillemets si "
|
|
"elle contient un guillemet simple mais aucun guillemet, sinon elle est "
|
|
"affichée entreguillemets 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ées par un antislash : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:173
|
|
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 ""
|
|
"Pour éviter que les caractères précédées d'un ``\\`` ne soient interprétés "
|
|
"comme étant spéciaux, utilisez les *chaînes brutes* (*raw strings*) en "
|
|
"préfixant la chaîne d'un ``r`` ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:183
|
|
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. On peut "
|
|
"utiliser les triples guillemets, simples ou doubles: ``'''...'''`` ou ``"
|
|
"\"\"\"...\"\"\"``. Les retours à la ligne sont automatiquement inclus, mais "
|
|
"on peut l'en empêcher en ajoutant ``\\`` à la fin de la ligne. L'exemple "
|
|
"suivant : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:194
|
|
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) :"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:202
|
|
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 ``*``::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:209
|
|
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. ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:215
|
|
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 les "
|
|
"variables ni les expressions : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:225
|
|
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 ``+``::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:230
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:237
|
|
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 (accéder aux caractères par "
|
|
"leur position), le premiercaractère d'une chaîne est à 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 ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:247
|
|
msgid ""
|
|
"Indices may also be negative numbers, to start counting from the right::"
|
|
msgstr ""
|
|
"Les indices peuvent également être négatifs, pour effectuer un décompte en "
|
|
"partant de la droite. Par exemple : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:256
|
|
msgid "Note that since -0 is the same as 0, negative indices start from -1."
|
|
msgstr "Notez que puisque -0 égal 0, les indices négatifs commencent par -1."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:258
|
|
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* une liste. Accéder à une chaîne par un indice permet d'obtenir un "
|
|
"caractère, alors que la *trancher* permet d'obtenir une sous-chaîne : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:266
|
|
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`` ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:274
|
|
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 indices par tranches ont des valeurs par défaut utiles ; le premier "
|
|
"indice lorsqu'il est omis équivaut à zéro, le second à la taille de la "
|
|
"chaîne de caractères : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:284
|
|
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 ""
|
|
"Une façon de mémoriser la façon dont les tranches fonctionnent est de penser "
|
|
"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 : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:295
|
|
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."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:300
|
|
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 longue "
|
|
"de ``word[1:3]`` est 2."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:304
|
|
msgid "Attempting to use an index that is too large will result in an error::"
|
|
msgstr "Utiliser un indice trop grand générera une erreur : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:311
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:319
|
|
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 "
|
|
"quelles sont :term:`immuable`. Affecter une nouvelle valeur à un indice dans "
|
|
"une chaîne produit une erreur : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:329
|
|
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 "
|
|
"autre : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:336
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:347
|
|
msgid ":ref:`textseq`"
|
|
msgstr ":ref:`textseq`"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:346
|
|
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*, et "
|
|
"supportent donc lesopérations classiques prises en charge par ces types."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:351
|
|
msgid ":ref:`string-methods`"
|
|
msgstr ":ref:`string-methods`"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:350
|
|
msgid ""
|
|
"Strings support a large number of methods for basic transformations and "
|
|
"searching."
|
|
msgstr ""
|
|
"Les chaînes de caractères supportent un large éventail de méthodes de "
|
|
"transformations basiques et de recherche."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:354
|
|
msgid ":ref:`f-strings`"
|
|
msgstr ":ref:`f-strings`"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:354
|
|
msgid "String literals that have embedded expressions."
|
|
msgstr "Des chaînes littérales qui contiennent des expressions."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:357
|
|
msgid ":ref:`formatstrings`"
|
|
msgstr ":ref:`formatstrings`"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:357
|
|
msgid "Information about string formatting with :meth:`str.format`."
|
|
msgstr ""
|
|
"Informations sur le formatage des chaînes avec la méthode :meth:`str.format`."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:360
|
|
msgid ":ref:`old-string-formatting`"
|
|
msgstr ":ref:`old-string-formatting`"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:360
|
|
msgid ""
|
|
"The old formatting operations invoked when strings are the left operand of "
|
|
"the ``%`` operator are described in more detail here."
|
|
msgstr ""
|
|
"Les anciennes méthodes de mise en forme appelées lorsque les chaînes de "
|
|
"caractères sont à gauche d'un opérateur ``%`` sont décrites en détail ici."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:367
|
|
msgid "Lists"
|
|
msgstr "Les listes"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:369
|
|
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. La plus souple est la *liste*, qui peut être "
|
|
"écrite comme une suite de valeurs (éléments) séparés par des virgules placée "
|
|
"entre crochets. Les éléments d'une liste ne sont pas obligatoirement tous du "
|
|
"même type, bien qu'à l'usage ce soit souvent le cas. ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:378
|
|
msgid ""
|
|
"Like strings (and all other built-in :term:`sequence` type), lists can be "
|
|
"indexed and sliced::"
|
|
msgstr ""
|
|
"Comme les chaînes de caractères (et toute autre types de :term:`sequence`), "
|
|
"les listes peuvent être indicées et découpées : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:388
|
|
msgid ""
|
|
"All slice operations return a new list containing the requested elements. "
|
|
"This means that the following slice returns a new (shallow) copy of the "
|
|
"list::"
|
|
msgstr ""
|
|
"Toutes les opérations par tranches renvoient une nouvelle liste contenant "
|
|
"les éléments demandés. Ce qui signifie que l'opération suivante renvoie une "
|
|
"copie superficielle de la liste : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:394
|
|
msgid "Lists also support operations like concatenation::"
|
|
msgstr "Les listes gèrent aussi les opérations comme les concaténations : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:399
|
|
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:`immuable`\\s, les listes "
|
|
"sont :term:`muables`\\s : il est possible de changer leur contenu : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:409
|
|
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 seront abordées plus "
|
|
"tard) ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:417
|
|
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 : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:436
|
|
msgid "The built-in function :func:`len` also applies to lists::"
|
|
msgstr "La primitive :func:`len` s'applique aussi aux listes : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:442
|
|
msgid ""
|
|
"It is possible to nest lists (create lists containing other lists), for "
|
|
"example::"
|
|
msgstr ""
|
|
"Il est possible d'imbriquer des listes (de créer des listes contenant "
|
|
"d'autres listes), par exemple : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:458
|
|
msgid "First Steps Towards Programming"
|
|
msgstr "Premiers pas vers la programmation"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:460
|
|
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 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 une sous-séquence "
|
|
"initiale de la suite de Fibonacci comme ceci : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:478
|
|
msgid "This example introduces several new features."
|
|
msgstr "Cet exemple introduit plusieurs nouvelles fonctionnalités."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:480
|
|
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."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:486
|
|
msgid ""
|
|
"The :keyword:`while` loop executes as long as the condition (here: ``b < "
|
|
"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 : ``b < "
|
|
"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)."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:495
|
|
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."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:504
|
|
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 valeur des paramètres qui lui sont "
|
|
"fournis. Ce n'est pas la même chose que d'écrire l'expression que vousvoulez "
|
|
"afficher (comme nous l'avons fait dans l'exemple de la calculatrice), dû à "
|
|
"la manière de ``print`` de gérer les paramètres multiples, les nombres "
|
|
"décimaux, et les chaînes. Les chaînes sont affichées sans apostrophes et "
|
|
"unespace est inséré entre les éléments de telle sorte que vous pouvez "
|
|
"facilement formater les choses, comme ceci : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:515
|
|
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 "
|
|
"terminer la ligne par une autre chaîne : ::"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:527
|
|
msgid "Footnotes"
|
|
msgstr "Notes"
|
|
|
|
#: ../Doc/tutorial/introduction.rst:528
|
|
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`` sera interprété ``-(3 "
|
|
"** 2)`` et vaudra donc ``-9``. Pour éviter cela et obtenir ``9``, utilisez "
|
|
"des parenthèses : ``(-3) ** 2``."
|
|
|
|
#: ../Doc/tutorial/introduction.rst:532
|
|
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 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."
|
|
|
|
#, fuzzy
|
|
#~ msgid "f-strings"
|
|
#~ msgstr "Les chaînes de caractères"
|
|
|
|
#, fuzzy
|
|
#~ msgid "formatstrings"
|
|
#~ msgstr ":ref:`formatstrings`"
|