python-docs-fr/library/stdtypes.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/library/stdtypes.rst:8
msgid "Built-in Types"
msgstr "Types natifs"

#: ../Doc/library/stdtypes.rst:10
msgid ""
"The following sections describe the standard types that are built into the "
"interpreter."
msgstr ""
"Les sections suivantes décrivent les types standards intégrés à "
"l'interpréteur."

#: ../Doc/library/stdtypes.rst:15
msgid ""
"Historically (until release 2.2), Python's built-in types have differed from "
"user-defined types because it was not possible to use the built-in types as "
"the basis for object-oriented inheritance. This limitation no longer exists."
msgstr ""

#: ../Doc/library/stdtypes.rst:22
msgid ""
"The principal built-in types are numerics, sequences, mappings, files, "
"classes, instances and exceptions."
msgstr ""

#: ../Doc/library/stdtypes.rst:27
msgid ""
"Some operations are supported by several object types; in particular, "
"practically all objects can be compared, tested for truth value, and "
"converted to a string (with the :ref:`repr() <func-repr>` function or the "
"slightly different :func:`str` function).  The latter function is implicitly "
"used when an object is written by the :func:`print` function."
msgstr ""

#: ../Doc/library/stdtypes.rst:37
msgid "Truth Value Testing"
msgstr "Valeurs booléennes"

#: ../Doc/library/stdtypes.rst:46
msgid ""
"Any object can be tested for truth value, for use in an :keyword:`if` or :"
"keyword:`while` condition or as operand of the Boolean operations below. The "
"following values are considered false:"
msgstr ""
"Tout objet peut être testé typiquement dans une condition :keyword:`if` ou :"
"keyword:`while` ou comme opérande des opérations booléennes ci-dessous. Les "
"valeurs suivantes sont considérées comme fausses :"

#: ../Doc/library/stdtypes.rst:52
msgid "``None``"
msgstr "``None``"

#: ../Doc/library/stdtypes.rst:56
msgid "``False``"
msgstr "``False``"

#: ../Doc/library/stdtypes.rst:58
msgid "zero of any numeric type, for example, ``0``, ``0L``, ``0.0``, ``0j``."
msgstr ""

#: ../Doc/library/stdtypes.rst:60
msgid "any empty sequence, for example, ``''``, ``()``, ``[]``."
msgstr "toute séquence vide, par exemple, ``''``, ``()``, ``[]``."

#: ../Doc/library/stdtypes.rst:62
msgid "any empty mapping, for example, ``{}``."
msgstr "toute dictionnaire vide, par exemple, ``{}``."

#: ../Doc/library/stdtypes.rst:64
msgid ""
"instances of user-defined classes, if the class defines a :meth:"
"`__nonzero__` or :meth:`__len__` method, when that method returns the "
"integer zero or :class:`bool` value ``False``. [1]_"
msgstr ""

#: ../Doc/library/stdtypes.rst:70
msgid ""
"All other values are considered true --- so objects of many types are always "
"true."
msgstr ""
"Toutes les autres valeurs sont considérées comme vraies --- donc des objets "
"de beaucoup de types sont toujours vrais."

#: ../Doc/library/stdtypes.rst:79
msgid ""
"Operations and built-in functions that have a Boolean result always return "
"``0`` or ``False`` for false and ``1`` or ``True`` for true, unless "
"otherwise stated. (Important exception: the Boolean operations ``or`` and "
"``and`` always return one of their operands.)"
msgstr ""
"Les opérations et fonctions natives dont le résultat est booléen donnent "
"toujours ``0`` ou ``False`` pour faux et ``1`` ou ``True`` pour vrai, sauf "
"indication contraire. (Exception importante : les opérations booléennes "
"``or`` et ``and`` renvoient toujours l'une de leurs opérandes.)"

#: ../Doc/library/stdtypes.rst:88
msgid "Boolean Operations --- :keyword:`and`, :keyword:`or`, :keyword:`not`"
msgstr ""
"Opérations booléennes --- :keyword:`and`, :keyword:`or`, :keyword:`not`"

#: ../Doc/library/stdtypes.rst:92
msgid "These are the Boolean operations, ordered by ascending priority:"
msgstr "Ce sont les opérations booléennes, classées par priorité ascendante :"

#: ../Doc/library/stdtypes.rst:95 ../Doc/library/stdtypes.rst:153
#: ../Doc/library/stdtypes.rst:299 ../Doc/library/stdtypes.rst:397
#: ../Doc/library/stdtypes.rst:442 ../Doc/library/stdtypes.rst:731
#: ../Doc/library/stdtypes.rst:1653
msgid "Operation"
msgstr "Opération"

#: ../Doc/library/stdtypes.rst:95 ../Doc/library/stdtypes.rst:299
#: ../Doc/library/stdtypes.rst:397 ../Doc/library/stdtypes.rst:442
#: ../Doc/library/stdtypes.rst:731 ../Doc/library/stdtypes.rst:1653
msgid "Result"
msgstr "Résultat"

#: ../Doc/library/stdtypes.rst:95 ../Doc/library/stdtypes.rst:153
#: ../Doc/library/stdtypes.rst:299 ../Doc/library/stdtypes.rst:442
#: ../Doc/library/stdtypes.rst:731 ../Doc/library/stdtypes.rst:1502
#: ../Doc/library/stdtypes.rst:1653
msgid "Notes"
msgstr "Notes"

#: ../Doc/library/stdtypes.rst:97
msgid "``x or y``"
msgstr "``x or y``"

#: ../Doc/library/stdtypes.rst:97
msgid "if *x* is false, then *y*, else *x*"
msgstr "si *x* est faux, alors *y*, sinon *x*"

#: ../Doc/library/stdtypes.rst:97 ../Doc/library/stdtypes.rst:165
#: ../Doc/library/stdtypes.rst:307 ../Doc/library/stdtypes.rst:733
#: ../Doc/library/stdtypes.rst:736 ../Doc/library/stdtypes.rst:1508
#: ../Doc/library/stdtypes.rst:1664
msgid "\\(1)"
msgstr "\\(1)"

#: ../Doc/library/stdtypes.rst:100
msgid "``x and y``"
msgstr "``x and y``"

#: ../Doc/library/stdtypes.rst:100
msgid "if *x* is false, then *x*, else *y*"
msgstr "si *x* est faux, alors *x*, sinon *y*"

#: ../Doc/library/stdtypes.rst:100 ../Doc/library/stdtypes.rst:321
#: ../Doc/library/stdtypes.rst:323 ../Doc/library/stdtypes.rst:742
#: ../Doc/library/stdtypes.rst:1512 ../Doc/library/stdtypes.rst:1514
#: ../Doc/library/stdtypes.rst:1670
msgid "\\(2)"
msgstr "\\(2)"

#: ../Doc/library/stdtypes.rst:103
msgid "``not x``"
msgstr "``not x``"

#: ../Doc/library/stdtypes.rst:103
msgid "if *x* is false, then ``True``, else ``False``"
msgstr "si *x* est faux, alors ``True``, sinon ``False``"

#: ../Doc/library/stdtypes.rst:103 ../Doc/library/stdtypes.rst:318
#: ../Doc/library/stdtypes.rst:745 ../Doc/library/stdtypes.rst:1516
#: ../Doc/library/stdtypes.rst:1518 ../Doc/library/stdtypes.rst:1520
#: ../Doc/library/stdtypes.rst:1522 ../Doc/library/stdtypes.rst:1673
msgid "\\(3)"
msgstr "\\(3)"

#: ../Doc/library/stdtypes.rst:112 ../Doc/library/stdtypes.rst:172
#: ../Doc/library/stdtypes.rst:345 ../Doc/library/stdtypes.rst:460
#: ../Doc/library/stdtypes.rst:785 ../Doc/library/stdtypes.rst:1545
#: ../Doc/library/stdtypes.rst:1700
msgid "Notes:"
msgstr "Notes :"

#: ../Doc/library/stdtypes.rst:115
msgid ""
"This is a short-circuit operator, so it only evaluates the second argument "
"if the first one is :const:`False`."
msgstr ""
"Ceci est un opérateur court-circuit, il évalue seulement le deuxième "
"argument si le premier est :const:`False`."

#: ../Doc/library/stdtypes.rst:119
msgid ""
"This is a short-circuit operator, so it only evaluates the second argument "
"if the first one is :const:`True`."
msgstr ""
"Ceci est un opérateur court-circuit, il évalue seulement le deuxième "
"argument si le premier est :const:`True`."

#: ../Doc/library/stdtypes.rst:123
msgid ""
"``not`` has a lower priority than non-Boolean operators, so ``not a == b`` "
"is interpreted as ``not (a == b)``, and ``a == not b`` is a syntax error."
msgstr ""
"``not`` a une priorité inférieure à celle des opérateurs non-booléens, donc "
"``not a == b`` est interprété comme ``not (a == b)`` et ``a == not b`` est "
"une erreur de syntaxe."

#: ../Doc/library/stdtypes.rst:130
msgid "Comparisons"
msgstr "Comparaisons"

#: ../Doc/library/stdtypes.rst:144
msgid ""
"Comparison operations are supported by all objects.  They all have the same "
"priority (which is higher than that of the Boolean operations). Comparisons "
"can be chained arbitrarily; for example, ``x < y <= z`` is equivalent to ``x "
"< y and y <= z``, except that *y* is evaluated only once (but in both cases "
"*z* is not evaluated at all when ``x < y`` is found to be false)."
msgstr ""

#: ../Doc/library/stdtypes.rst:150
msgid "This table summarizes the comparison operations:"
msgstr "Ce tableau résume les opérations de comparaison :"

#: ../Doc/library/stdtypes.rst:153 ../Doc/library/stdtypes.rst:1479
#: ../Doc/library/stdtypes.rst:1502
msgid "Meaning"
msgstr "Signification"

#: ../Doc/library/stdtypes.rst:155
msgid "``<``"
msgstr "``<``"

#: ../Doc/library/stdtypes.rst:155
msgid "strictly less than"
msgstr "strictement inférieur"

#: ../Doc/library/stdtypes.rst:157
msgid "``<=``"
msgstr "``<=``"

#: ../Doc/library/stdtypes.rst:157
msgid "less than or equal"
msgstr "inférieur ou égal"

#: ../Doc/library/stdtypes.rst:159
msgid "``>``"
msgstr "``>``"

#: ../Doc/library/stdtypes.rst:159
msgid "strictly greater than"
msgstr "strictement supérieur"

#: ../Doc/library/stdtypes.rst:161
msgid "``>=``"
msgstr "``>=``"

#: ../Doc/library/stdtypes.rst:161
msgid "greater than or equal"
msgstr "supérieur ou égal"

#: ../Doc/library/stdtypes.rst:163
msgid "``==``"
msgstr "``==``"

#: ../Doc/library/stdtypes.rst:163
msgid "equal"
msgstr "égal"

#: ../Doc/library/stdtypes.rst:165
msgid "``!=``"
msgstr "``!=``"

#: ../Doc/library/stdtypes.rst:165
msgid "not equal"
msgstr "différent"

#: ../Doc/library/stdtypes.rst:167
msgid "``is``"
msgstr "``is``"

#: ../Doc/library/stdtypes.rst:167
msgid "object identity"
msgstr "identité d'objet"

#: ../Doc/library/stdtypes.rst:169
msgid "``is not``"
msgstr "``is not``"

#: ../Doc/library/stdtypes.rst:169
msgid "negated object identity"
msgstr "contraire de l'identité d'objet"

#: ../Doc/library/stdtypes.rst:175
msgid ""
"``!=`` can also be written ``<>``, but this is an obsolete usage kept for "
"backwards compatibility only. New code should always use ``!=``."
msgstr ""

#: ../Doc/library/stdtypes.rst:183
msgid ""
"Objects of different types, except different numeric types and different "
"string types, never compare equal; such objects are ordered consistently but "
"arbitrarily (so that sorting a heterogeneous array yields a consistent "
"result). Furthermore, some types (for example, file objects) support only a "
"degenerate notion of comparison where any two objects of that type are "
"unequal.  Again, such objects are ordered arbitrarily but consistently. The "
"``<``, ``<=``, ``>`` and ``>=`` operators will raise a :exc:`TypeError` "
"exception when any operand is a complex number."
msgstr ""

#: ../Doc/library/stdtypes.rst:201
msgid ""
"Non-identical instances of a class normally compare as non-equal unless the "
"class defines the :meth:`__eq__` method or the :meth:`__cmp__` method."
msgstr ""

#: ../Doc/library/stdtypes.rst:204
msgid ""
"Instances of a class cannot be ordered with respect to other instances of "
"the same class, or other types of object, unless the class defines either "
"enough of the rich comparison methods (:meth:`__lt__`, :meth:`__le__`, :meth:"
"`__gt__`, and :meth:`__ge__`) or the :meth:`__cmp__` method."
msgstr ""

#: ../Doc/library/stdtypes.rst:211
msgid ""
"Objects of different types except numbers are ordered by their type names; "
"objects of the same types that don't support proper comparison are ordered "
"by their address."
msgstr ""

#: ../Doc/library/stdtypes.rst:219
msgid ""
"Two more operations with the same syntactic priority, ``in`` and ``not in``, "
"are supported only by sequence types (below)."
msgstr ""

#: ../Doc/library/stdtypes.rst:226
msgid ""
"Numeric Types --- :class:`int`, :class:`float`, :class:`long`, :class:"
"`complex`"
msgstr ""

#: ../Doc/library/stdtypes.rst:237
msgid ""
"There are four distinct numeric types: :dfn:`plain integers`, :dfn:`long "
"integers`, :dfn:`floating point numbers`, and :dfn:`complex numbers`. In "
"addition, Booleans are a subtype of plain integers. Plain integers (also "
"just called :dfn:`integers`) are implemented using :c:type:`long` in C, "
"which gives them at least 32 bits of precision (``sys.maxint`` is always set "
"to the maximum plain integer value for the current platform, the minimum "
"value is ``-sys.maxint - 1``).  Long integers have unlimited precision.  "
"Floating point numbers are usually implemented using :c:type:`double` in C; "
"information about the precision and internal representation of floating "
"point numbers for the machine on which your program is running is available "
"in :data:`sys.float_info`.  Complex numbers have a real and imaginary part, "
"which are each a floating point number.  To extract these parts from a "
"complex number *z*, use ``z.real`` and ``z.imag``. (The standard library "
"includes additional numeric types, :mod:`fractions` that hold rationals, "
"and :mod:`decimal` that hold floating-point numbers with user-definable "
"precision.)"
msgstr ""

#: ../Doc/library/stdtypes.rst:262
msgid ""
"Numbers are created by numeric literals or as the result of built-in "
"functions and operators.  Unadorned integer literals (including binary, hex, "
"and octal numbers) yield plain integers unless the value they denote is too "
"large to be represented as a plain integer, in which case they yield a long "
"integer. Integer literals with an ``'L'`` or ``'l'`` suffix yield long "
"integers (``'L'`` is preferred because ``1l`` looks too much like eleven!).  "
"Numeric literals containing a decimal point or an exponent sign yield "
"floating point numbers. Appending ``'j'`` or ``'J'`` to a numeric literal "
"yields a complex number with a zero real part. A complex numeric literal is "
"the sum of a real and an imaginary part."
msgstr ""

#: ../Doc/library/stdtypes.rst:287
msgid ""
"Python fully supports mixed arithmetic: when a binary arithmetic operator "
"has operands of different numeric types, the operand with the \"narrower\" "
"type is widened to that of the other, where plain integer is narrower than "
"long integer is narrower than floating point is narrower than complex. "
"Comparisons between numbers of mixed type use the same rule. [2]_ The "
"constructors :func:`int`, :func:`long`, :func:`float`, and :func:`complex` "
"can be used to produce numbers of a specific type."
msgstr ""

#: ../Doc/library/stdtypes.rst:295
msgid ""
"All built-in numeric types support the following operations. See :ref:"
"`power` and later sections for the operators' priorities."
msgstr ""

#: ../Doc/library/stdtypes.rst:301
msgid "``x + y``"
msgstr "``x + y``"

#: ../Doc/library/stdtypes.rst:301
msgid "sum of *x* and *y*"
msgstr "somme de *x* et *y*"

#: ../Doc/library/stdtypes.rst:303
msgid "``x - y``"
msgstr "``x - y``"

#: ../Doc/library/stdtypes.rst:303
msgid "difference of *x* and *y*"
msgstr "différence de *x* et *y*"

#: ../Doc/library/stdtypes.rst:305
msgid "``x * y``"
msgstr "``x * y``"

#: ../Doc/library/stdtypes.rst:305
msgid "product of *x* and *y*"
msgstr "produit de *x* et *y*"

#: ../Doc/library/stdtypes.rst:307
msgid "``x / y``"
msgstr "``x / y``"

#: ../Doc/library/stdtypes.rst:307
msgid "quotient of *x* and *y*"
msgstr "quotient de *x* et *y*"

#: ../Doc/library/stdtypes.rst:309
msgid "``x // y``"
msgstr "``x // y``"

#: ../Doc/library/stdtypes.rst:309
msgid "(floored) quotient of *x* and *y*"
msgstr ""

#: ../Doc/library/stdtypes.rst:309
msgid "(4)(5)"
msgstr ""

#: ../Doc/library/stdtypes.rst:312
msgid "``x % y``"
msgstr "``x % y``"

#: ../Doc/library/stdtypes.rst:312
msgid "remainder of ``x / y``"
msgstr "reste de ``x / y``"

#: ../Doc/library/stdtypes.rst:312 ../Doc/library/stdtypes.rst:1524
#: ../Doc/library/stdtypes.rst:1528 ../Doc/library/stdtypes.rst:1682
#: ../Doc/library/stdtypes.rst:1691
msgid "\\(4)"
msgstr "\\(4)"

#: ../Doc/library/stdtypes.rst:314
msgid "``-x``"
msgstr "``-x``"

#: ../Doc/library/stdtypes.rst:314
msgid "*x* negated"
msgstr "négatif de *x*"

#: ../Doc/library/stdtypes.rst:316
msgid "``+x``"
msgstr "``+x``"

#: ../Doc/library/stdtypes.rst:316
msgid "*x* unchanged"
msgstr "*x* inchangé"

#: ../Doc/library/stdtypes.rst:318
msgid "``abs(x)``"
msgstr "``abs(x)``"

#: ../Doc/library/stdtypes.rst:318
msgid "absolute value or magnitude of *x*"
msgstr "valeur absolue de *x*"

#: ../Doc/library/stdtypes.rst:321
msgid "``int(x)``"
msgstr "``int(x)``"

#: ../Doc/library/stdtypes.rst:321
msgid "*x* converted to integer"
msgstr "*x* converti en nombre entier"

#: ../Doc/library/stdtypes.rst:323
msgid "``long(x)``"
msgstr ""

#: ../Doc/library/stdtypes.rst:323
msgid "*x* converted to long integer"
msgstr ""

#: ../Doc/library/stdtypes.rst:325
msgid "``float(x)``"
msgstr "``float(x)``"

#: ../Doc/library/stdtypes.rst:325
msgid "*x* converted to floating point"
msgstr "*x* converti en nombre à virgule flottante"

#: ../Doc/library/stdtypes.rst:325 ../Doc/library/stdtypes.rst:739
#: ../Doc/library/stdtypes.rst:1538 ../Doc/library/stdtypes.rst:1688
msgid "\\(6)"
msgstr "\\(6)"

#: ../Doc/library/stdtypes.rst:327
msgid "``complex(re,im)``"
msgstr ""

#: ../Doc/library/stdtypes.rst:327
msgid ""
"a complex number with real part *re*, imaginary part *im*. *im* defaults to "
"zero."
msgstr ""
"un nombre complexe avec *re* pour partie réelle et *im* pour partie "
"imaginaire. *im* vaut zéro par défaut."

#: ../Doc/library/stdtypes.rst:331
msgid "``c.conjugate()``"
msgstr "``c.conjugate()``"

#: ../Doc/library/stdtypes.rst:331
msgid "conjugate of the complex number *c*. (Identity on real numbers)"
msgstr ""

#: ../Doc/library/stdtypes.rst:334
msgid "``divmod(x, y)``"
msgstr "``divmod(x, y)``"

#: ../Doc/library/stdtypes.rst:334
msgid "the pair ``(x // y, x % y)``"
msgstr "la paire ``(x // y, x % y)``"

#: ../Doc/library/stdtypes.rst:334 ../Doc/library/stdtypes.rst:747
msgid "(3)(4)"
msgstr "(3)(4)"

#: ../Doc/library/stdtypes.rst:336
msgid "``pow(x, y)``"
msgstr "``pow(x, y)``"

#: ../Doc/library/stdtypes.rst:336 ../Doc/library/stdtypes.rst:338
msgid "*x* to the power *y*"
msgstr "*x* à la puissance *y*"

#: ../Doc/library/stdtypes.rst:336
msgid "(3)(7)"
msgstr ""

#: ../Doc/library/stdtypes.rst:338
msgid "``x ** y``"
msgstr "``x ** y``"

#: ../Doc/library/stdtypes.rst:338 ../Doc/library/stdtypes.rst:1510
#: ../Doc/library/stdtypes.rst:1693
msgid "\\(7)"
msgstr "\\(7)"

#: ../Doc/library/stdtypes.rst:352
msgid ""
"For (plain or long) integer division, the result is an integer. The result "
"is always rounded towards minus infinity: 1/2 is 0, (-1)/2 is -1, 1/(-2) is "
"-1, and (-1)/(-2) is 0.  Note that the result is a long integer if either "
"operand is a long integer, regardless of the numeric value."
msgstr ""

#: ../Doc/library/stdtypes.rst:365
msgid ""
"Conversion from floats using :func:`int` or :func:`long` truncates toward "
"zero like the related function, :func:`math.trunc`.  Use the function :func:"
"`math.floor` to round downward and :func:`math.ceil` to round upward."
msgstr ""

#: ../Doc/library/stdtypes.rst:371
msgid "See :ref:`built-in-funcs` for a full description."
msgstr ""

#: ../Doc/library/stdtypes.rst:374
msgid ""
"The floor division operator, the modulo operator, and the :func:`divmod` "
"function are no longer defined for complex numbers.  Instead, convert to a "
"floating point number using the :func:`abs` function if appropriate."
msgstr ""

#: ../Doc/library/stdtypes.rst:380
msgid ""
"Also referred to as integer division.  The resultant value is a whole "
"integer, though the result's type is not necessarily int."
msgstr ""

#: ../Doc/library/stdtypes.rst:384
msgid ""
"float also accepts the strings \"nan\" and \"inf\" with an optional prefix "
"\"+\" or \"-\" for Not a Number (NaN) and positive or negative infinity."
msgstr ""
"*float* accepte aussi les chaînes *nan* et *inf* avec un préfixe optionnel ``"
"+`` ou ``-`` pour *Not a Number* (*NaN*) et les infinis positif ou négatif."

#: ../Doc/library/stdtypes.rst:390
msgid ""
"Python defines ``pow(0, 0)`` and ``0 ** 0`` to be ``1``, as is common for "
"programming languages."
msgstr ""
"Python définit ``pow(0, 0)`` et ``0 ** 0`` valant ``1``, puisque c'est "
"courant pour les langages de programmation, et logique."

#: ../Doc/library/stdtypes.rst:393
msgid ""
"All :class:`numbers.Real` types (:class:`int`, :class:`long`, and :class:"
"`float`) also include the following operations:"
msgstr ""

#: ../Doc/library/stdtypes.rst:399
msgid ":func:`math.trunc(\\ x) <math.trunc>`"
msgstr ":func:`math.trunc(\\ x) <math.trunc>`"

#: ../Doc/library/stdtypes.rst:399
msgid "*x* truncated to :class:`~numbers.Integral`"
msgstr "*x* tronqué à l':class:`~numbers.Integral`"

#: ../Doc/library/stdtypes.rst:402
msgid ":func:`round(x[, n]) <round>`"
msgstr ":func:`round(x[, n]) <round>`"

#: ../Doc/library/stdtypes.rst:402
msgid ""
"*x* rounded to *n* digits, rounding ties away from zero. If *n* is omitted, "
"it defaults to 0."
msgstr ""

#: ../Doc/library/stdtypes.rst:406
msgid ":func:`math.floor(\\ x) <math.floor>`"
msgstr ":func:`math.floor(\\ x) <math.floor>`"

#: ../Doc/library/stdtypes.rst:406
msgid "the greatest integer as a float <= *x*"
msgstr ""

#: ../Doc/library/stdtypes.rst:409
msgid ":func:`math.ceil(x) <math.ceil>`"
msgstr ":func:`math.ceil(x) <math.ceil>`"

#: ../Doc/library/stdtypes.rst:409
msgid "the least integer as a float >= *x*"
msgstr ""

#: ../Doc/library/stdtypes.rst:419
msgid "Bitwise Operations on Integer Types"
msgstr "Opérations sur les bits des nombres entiers"

#: ../Doc/library/stdtypes.rst:431
msgid ""
"Bitwise operations only make sense for integers.  Negative numbers are "
"treated as their 2's complement value (this assumes a sufficiently large "
"number of bits that no overflow occurs during the operation)."
msgstr ""
"Les opérations sur les bits n'ont de sens que pour les entiers. Les nombres "
"négatifs sont traités comme leur complément à 2 (ce qui suppose un assez "
"grand nombre de bits afin qu'aucun débordement ne se produise pendant "
"l'opération)."

#: ../Doc/library/stdtypes.rst:435
msgid ""
"The priorities of the binary bitwise operations are all lower than the "
"numeric operations and higher than the comparisons; the unary operation "
"``~`` has the same priority as the other unary numeric operations (``+`` and "
"``-``)."
msgstr ""
"Les priorités de toutes les opération à deux opérandes sur des bits sont "
"inférieures aux opérations numériques et plus élevées que les comparaisons ; "
"l'opération unaire ``~`` a la même priorité que les autres opérations "
"numériques unaires (``+`` et ``-``)."

#: ../Doc/library/stdtypes.rst:439
msgid "This table lists the bitwise operations sorted in ascending priority:"
msgstr ""
"Ce tableau répertorie les opérations binaires triées par priorité "
"ascendante :"

#: ../Doc/library/stdtypes.rst:444
msgid "``x | y``"
msgstr "``x | y``"

#: ../Doc/library/stdtypes.rst:444
msgid "bitwise :dfn:`or` of *x* and *y*"
msgstr ":dfn:`ou <or>` binaire de *x* et *y*"

#: ../Doc/library/stdtypes.rst:447
msgid "``x ^ y``"
msgstr "``x ^ y``"

#: ../Doc/library/stdtypes.rst:447
msgid "bitwise :dfn:`exclusive or` of *x* and *y*"
msgstr ":dfn:`ou <or>` exclusive binaire de *x* et *y*"

#: ../Doc/library/stdtypes.rst:450
msgid "``x & y``"
msgstr "``x & y``"

#: ../Doc/library/stdtypes.rst:450
msgid "bitwise :dfn:`and` of *x* and *y*"
msgstr ":dfn:`et binaire <and>` de *x* et *y*"

#: ../Doc/library/stdtypes.rst:453
msgid "``x << n``"
msgstr "``x << n``"

#: ../Doc/library/stdtypes.rst:453
msgid "*x* shifted left by *n* bits"
msgstr "*x* décalé vers la gauche de *n* bits"

#: ../Doc/library/stdtypes.rst:453
msgid "(1)(2)"
msgstr "(1)(2)"

#: ../Doc/library/stdtypes.rst:455
msgid "``x >> n``"
msgstr "``x >> n``"

#: ../Doc/library/stdtypes.rst:455
msgid "*x* shifted right by *n* bits"
msgstr "*x* décalé vers la droite de *n* bits"

#: ../Doc/library/stdtypes.rst:455
msgid "(1)(3)"
msgstr "(1)(3)"

#: ../Doc/library/stdtypes.rst:457
msgid "``~x``"
msgstr "``~x``"

#: ../Doc/library/stdtypes.rst:457
msgid "the bits of *x* inverted"
msgstr "les bits de *x*, inversés"

#: ../Doc/library/stdtypes.rst:463
msgid ""
"Negative shift counts are illegal and cause a :exc:`ValueError` to be raised."
msgstr ""
"Des valeurs de décalage négatives sont illégales et provoquent une "
"exception :exc:`ValueError`."

#: ../Doc/library/stdtypes.rst:466
msgid ""
"A left shift by *n* bits is equivalent to multiplication by ``pow(2, n)``.  "
"A long integer is returned if the result exceeds the range of plain integers."
msgstr ""

#: ../Doc/library/stdtypes.rst:470
msgid "A right shift by *n* bits is equivalent to division by ``pow(2, n)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:474
msgid "Additional Methods on Integer Types"
msgstr "Méthodes supplémentaires sur les entiers"

#: ../Doc/library/stdtypes.rst:476
msgid ""
"The integer types implement the :class:`numbers.Integral` :term:`abstract "
"base class`. In addition, they provide one more method:"
msgstr ""

#: ../Doc/library/stdtypes.rst:482
msgid ""
"Return the number of bits necessary to represent an integer in binary, "
"excluding the sign and leading zeros::"
msgstr ""
"Renvoie le nombre de bits nécessaires pour représenter un nombre entier en "
"binaire, à l'exclusion du signe et des zéros non significatifs : ::"

#: ../Doc/library/stdtypes.rst:491
msgid ""
"More precisely, if ``x`` is nonzero, then ``x.bit_length()`` is the unique "
"positive integer ``k`` such that ``2**(k-1) <= abs(x) < 2**k``. "
"Equivalently, when ``abs(x)`` is small enough to have a correctly rounded "
"logarithm, then ``k = 1 + int(log(abs(x), 2))``. If ``x`` is zero, then ``x."
"bit_length()`` returns ``0``."
msgstr ""
"Plus précisément, si ``x`` est différent de zéro, ``x.bit_length()`` est le "
"nombre entier positif unique, ``k`` tel que ``2**(k-1) <= abs(x) < 2**k``. "
"Équivalemment, quand ``abs(x)`` est assez petit pour avoir un logarithme "
"correctement arrondi, ``k = 1 + int(log(abs(x), 2))``. Si ``x`` est nul, "
"alors ``x.bit_length()`` donne ``0``."

#: ../Doc/library/stdtypes.rst:497
msgid "Equivalent to::"
msgstr "Équivalent à : ::"

#: ../Doc/library/stdtypes.rst:508
msgid "Additional Methods on Float"
msgstr "Méthodes supplémentaires sur les nombres à virgule flottante"

#: ../Doc/library/stdtypes.rst:510
msgid ""
"The float type implements the :class:`numbers.Real` :term:`abstract base "
"class`. float also has the following additional methods."
msgstr ""
"Le type *float* implémente la :term:`classe de base abstraite <abstract base "
"class>` :class:`numbers.Real` et a également les méthodes suivantes."

#: ../Doc/library/stdtypes.rst:515
msgid ""
"Return a pair of integers whose ratio is exactly equal to the original float "
"and with a positive denominator.  Raises :exc:`OverflowError` on infinities "
"and a :exc:`ValueError` on NaNs."
msgstr ""
"Renvoie une paire de nombres entiers dont le rapport est exactement égal au "
"nombre d'origine et avec un dénominateur positif. Lève :exc:`OverflowError` "
"avec un infini et :exc:`ValueError` avec un NaN."

#: ../Doc/library/stdtypes.rst:524
msgid ""
"Return ``True`` if the float instance is finite with integral value, and "
"``False`` otherwise::"
msgstr ""
"Donne ``True`` si l'instance de *float* est finie avec une valeur entière, "
"et ``False`` autrement : ::"

#: ../Doc/library/stdtypes.rst:534
msgid ""
"Two methods support conversion to and from hexadecimal strings.  Since "
"Python's floats are stored internally as binary numbers, converting a float "
"to or from a *decimal* string usually involves a small rounding error.  In "
"contrast, hexadecimal strings allow exact representation and specification "
"of floating-point numbers.  This can be useful when debugging, and in "
"numerical work."
msgstr ""
"Deux méthodes prennent en charge la conversion vers et à partir de chaînes "
"hexadécimales. Étant donné que les *float* de Python sont stockés en interne "
"sous forme de nombres binaires, la conversion d'un *float* depuis ou vers "
"une chaine décimale implique généralement une petite erreur d'arrondi. En "
"revanche, les chaînes hexadécimales permettent de représenter exactement les "
"nombres à virgule flottante. Cela peut être utile lors du débogage, et dans "
"un travail numérique."

#: ../Doc/library/stdtypes.rst:545
msgid ""
"Return a representation of a floating-point number as a hexadecimal string.  "
"For finite floating-point numbers, this representation will always include a "
"leading ``0x`` and a trailing ``p`` and exponent."
msgstr ""
"Donne une représentation d'un nombre à virgule flottante sous forme de "
"chaîne hexadécimale. Pour les nombres à virgule flottante finis, cette "
"représentation comprendra toujours un préfixe ``0x``, un suffixe ``p``, et "
"un exposant."

#: ../Doc/library/stdtypes.rst:555
msgid ""
"Class method to return the float represented by a hexadecimal string *s*.  "
"The string *s* may have leading and trailing whitespace."
msgstr ""
"Méthode de classe pour obtenir le *float* représenté par une chaîne de "
"caractères hexadécimale *s*. La chaîne *s* peut contenir des espaces avant "
"et après le chiffre."

#: ../Doc/library/stdtypes.rst:562
msgid ""
"Note that :meth:`float.hex` is an instance method, while :meth:`float."
"fromhex` is a class method."
msgstr ""
"Notez que :meth:`float.hex` est une méthode d'instance, alors que :meth:"
"`float.fromhex` est une méthode de classe."

#: ../Doc/library/stdtypes.rst:565
msgid "A hexadecimal string takes the form::"
msgstr "Une chaîne hexadécimale prend la forme : ::"

#: ../Doc/library/stdtypes.rst:569
msgid ""
"where the optional ``sign`` may by either ``+`` or ``-``, ``integer`` and "
"``fraction`` are strings of hexadecimal digits, and ``exponent`` is a "
"decimal integer with an optional leading sign.  Case is not significant, and "
"there must be at least one hexadecimal digit in either the integer or the "
"fraction.  This syntax is similar to the syntax specified in section 6.4.4.2 "
"of the C99 standard, and also to the syntax used in Java 1.5 onwards.  In "
"particular, the output of :meth:`float.hex` is usable as a hexadecimal "
"floating-point literal in C or Java code, and hexadecimal strings produced "
"by C's ``%a`` format character or Java's ``Double.toHexString`` are accepted "
"by :meth:`float.fromhex`."
msgstr ""
"où ``sign`` peut être soit ``+`` soit ``-``, ``integer`` et ``fraction`` "
"sont des chaînes de chiffres hexadécimales, et ``exponent`` est un entier "
"décimal facultativement signé. La casse n'est pas significative, et il doit "
"y avoir au moins un chiffre hexadécimal soit dans le nombre entier soit dans "
"la fraction. Cette syntaxe est similaire à la syntaxe spécifiée dans la "
"section 6.4.4.2 de la norme C99, et est aussi la syntaxe utilisée à partir "
"de Java 1.5. En particulier, la sortie de :meth:`float.hex` est utilisable "
"comme valeur hexadécimale à virgule flottante littérale en C ou Java, et des "
"chaînes hexadécimales produites en C via un format ``%a`` ou Java via "
"``Double.toHexString`` sont acceptées par :meth:`float.fromhex`."

#: ../Doc/library/stdtypes.rst:582
msgid ""
"Note that the exponent is written in decimal rather than hexadecimal, and "
"that it gives the power of 2 by which to multiply the coefficient. For "
"example, the hexadecimal string ``0x3.a7p10`` represents the floating-point "
"number ``(3 + 10./16 + 7./16**2) * 2.0**10``, or ``3740.0``::"
msgstr ""
"Notez que l'exposant est écrit en décimal plutôt qu'en hexadécimal, et qu'il "
"donne la puissance de 2 par lequel multiplier le coefficient. Par exemple, "
"la chaîne hexadécimale ``0x3.a7p10`` représente le nombre à virgule "
"flottante ``(3 + 10./16 + 7./16**2) *2.0**10``, ou ``3740.0`` ::"

#: ../Doc/library/stdtypes.rst:592
msgid ""
"Applying the reverse conversion to ``3740.0`` gives a different hexadecimal "
"string representing the same number::"
msgstr ""
"L'application de la conversion inverse à ``3740.0`` donne une chaîne "
"hexadécimale différente représentant le même nombre ::"

#: ../Doc/library/stdtypes.rst:602
msgid "Iterator Types"
msgstr "Les types itérateurs"

#: ../Doc/library/stdtypes.rst:612
msgid ""
"Python supports a concept of iteration over containers.  This is implemented "
"using two distinct methods; these are used to allow user-defined classes to "
"support iteration.  Sequences, described below in more detail, always "
"support the iteration methods."
msgstr ""
"Python supporte un concept d'itération sur les conteneurs. C'est implémenté "
"en utilisant deux méthodes distinctes qui permettent aux classes définies "
"par l'utilisateur de devenir itérables. Les séquences, décrites plus bas en "
"détail, supportent toujours les méthodes d'itération."

#: ../Doc/library/stdtypes.rst:617
msgid ""
"One method needs to be defined for container objects to provide iteration "
"support:"
msgstr ""
"Une méthode doit être définie afin que les objets conteneurs  supportent "
"l'itération :"

#: ../Doc/library/stdtypes.rst:624
msgid ""
"Return an iterator object.  The object is required to support the iterator "
"protocol described below.  If a container supports different types of "
"iteration, additional methods can be provided to specifically request "
"iterators for those iteration types.  (An example of an object supporting "
"multiple forms of iteration would be a tree structure which supports both "
"breadth-first and depth-first traversal.)  This method corresponds to the :c:"
"member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects "
"in the Python/C API."
msgstr ""
"Donne un objet itérateur. L'objet doit implémenter le protocole d'itération "
"décrit ci-dessous. Si un conteneur prend en charge différents types "
"d'itération, d'autres méthodes peuvent être fournies pour obtenir "
"spécifiquement les itérateurs pour ces types d'itération. (Exemple d'un "
"objet supportant plusieurs formes d'itération : une structure d'arbre "
"pouvant être parcourue en largeur ou en profondeur.) Cette méthode "
"correspond à l'attribut :c:member:`~PyTypeObject.tp_iter` de la structure du "
"type des objets Python dans l'API Python/C."

#: ../Doc/library/stdtypes.rst:633
msgid ""
"The iterator objects themselves are required to support the following two "
"methods, which together form the :dfn:`iterator protocol`:"
msgstr ""
"Les itérateurs eux-mêmes doivent implémenter les deux méthodes suivantes, "
"qui forment ensemble le :dfn:`protocole d'itérateur <iterator protocol>` :"

#: ../Doc/library/stdtypes.rst:639
msgid ""
"Return the iterator object itself.  This is required to allow both "
"containers and iterators to be used with the :keyword:`for` and :keyword:"
"`in` statements. This method corresponds to the :c:member:`~PyTypeObject."
"tp_iter` slot of the type structure for Python objects in the Python/C API."
msgstr ""
"Donne l'objet itérateur lui-même. Cela est nécessaire pour permettre à la "
"fois à des conteneurs et des itérateurs d'être utilisés avec les "
"instructions :keyword:`for` et :keyword:`in`. Cette méthode correspond à "
"l'attribut :c:member:`~PyTypeObject.tp_iter` de la structure des types des "
"objets Python dans l'API Python/C."

#: ../Doc/library/stdtypes.rst:647
msgid ""
"Return the next item from the container.  If there are no further items, "
"raise the :exc:`StopIteration` exception.  This method corresponds to the :c:"
"member:`~PyTypeObject.tp_iternext` slot of the type structure for Python "
"objects in the Python/C API."
msgstr ""
"Donne l'élément suivant du conteneur. S'il n'y a pas d'autres éléments, une "
"exception :exc:`StopIteration` est levée. Cette méthode correspond à "
"l'attribut :c:member:`PyTypeObject.tp_iternext` de la structure du type des "
"objets Python dans l'API Python/C."

#: ../Doc/library/stdtypes.rst:652
msgid ""
"Python defines several iterator objects to support iteration over general "
"and specific sequence types, dictionaries, and other more specialized "
"forms.  The specific types are not important beyond their implementation of "
"the iterator protocol."
msgstr ""
"Python définit plusieurs objets itérateurs pour itérer sur les types "
"standards ou spécifiques de séquence, de  dictionnaires et d'autres formes "
"plus spécialisées. Les types spécifiques ne sont  pas importants au-delà de "
"leur implémentation du protocole d'itération."

#: ../Doc/library/stdtypes.rst:657
msgid ""
"The intention of the protocol is that once an iterator's :meth:`~iterator."
"next` method raises :exc:`StopIteration`, it will continue to do so on "
"subsequent calls. Implementations that do not obey this property are deemed "
"broken.  (This constraint was added in Python 2.3; in Python 2.2, various "
"iterators are broken according to this rule.)"
msgstr ""

#: ../Doc/library/stdtypes.rst:667
msgid "Generator Types"
msgstr "Types générateurs"

#: ../Doc/library/stdtypes.rst:669
msgid ""
"Python's :term:`generator`\\s provide a convenient way to implement the "
"iterator protocol.  If a container object's :meth:`__iter__` method is "
"implemented as a generator, it will automatically return an iterator object "
"(technically, a generator object) supplying the :meth:`~iterator.__iter__` "
"and :meth:`~iterator.next` methods.  More information about generators can "
"be found in :ref:`the documentation for the yield expression <yieldexpr>`."
msgstr ""

#: ../Doc/library/stdtypes.rst:680
msgid ""
"Sequence Types --- :class:`str`, :class:`unicode`, :class:`list`, :class:"
"`tuple`, :class:`bytearray`, :class:`buffer`, :class:`xrange`"
msgstr ""

#: ../Doc/library/stdtypes.rst:682
msgid ""
"There are seven sequence types: strings, Unicode strings, lists, tuples, "
"bytearrays, buffers, and xrange objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:685
msgid ""
"For other containers see the built in :class:`dict` and :class:`set` "
"classes, and the :mod:`collections` module."
msgstr ""

#: ../Doc/library/stdtypes.rst:699
msgid ""
"String literals are written in single or double quotes: ``'xyzzy'``, ``"
"\"frobozz\"``.  See :ref:`strings` for more about string literals. Unicode "
"strings are much like strings, but are specified in the syntax using a "
"preceding ``'u'`` character: ``u'abc'``, ``u\"def\"``. In addition to the "
"functionality described here, there are also string-specific methods "
"described in the :ref:`string-methods` section. Lists are constructed with "
"square brackets, separating items with commas: ``[a, b, c]``. Tuples are "
"constructed by the comma operator (not within square brackets), with or "
"without enclosing parentheses, but an empty tuple must have the enclosing "
"parentheses, such as ``a, b, c`` or ``()``.  A single item tuple must have a "
"trailing comma, such as ``(d,)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:711
msgid ""
"Bytearray objects are created with the built-in function :func:`bytearray`."
msgstr ""

#: ../Doc/library/stdtypes.rst:713
msgid ""
"Buffer objects are not directly supported by Python syntax, but can be "
"created by calling the built-in function :func:`buffer`.  They don't support "
"concatenation or repetition."
msgstr ""

#: ../Doc/library/stdtypes.rst:717
msgid ""
"Objects of type xrange are similar to buffers in that there is no specific "
"syntax to create them, but they are created using the :func:`xrange` "
"function.  They don't support slicing, concatenation or repetition, and "
"using ``in``, ``not in``, :func:`min` or :func:`max` on them is inefficient."
msgstr ""

#: ../Doc/library/stdtypes.rst:722
msgid ""
"Most sequence types support the following operations.  The ``in`` and ``not "
"in`` operations have the same priorities as the comparison operations.  The "
"``+`` and ``*`` operations have the same priority as the corresponding "
"numeric operations. [3]_ Additional methods are provided for :ref:`typesseq-"
"mutable`."
msgstr ""

#: ../Doc/library/stdtypes.rst:727
msgid ""
"This table lists the sequence operations sorted in ascending priority. In "
"the table, *s* and *t* are sequences of the same type; *n*, *i* and *j* are "
"integers:"
msgstr ""

#: ../Doc/library/stdtypes.rst:733
msgid "``x in s``"
msgstr "``x in s``"

#: ../Doc/library/stdtypes.rst:733
msgid "``True`` if an item of *s* is equal to *x*, else ``False``"
msgstr "``True`` si un élément de *s* est égal à *x*, sinon ``False``"

#: ../Doc/library/stdtypes.rst:736
msgid "``x not in s``"
msgstr "``x not in s``"

#: ../Doc/library/stdtypes.rst:736
msgid "``False`` if an item of *s* is equal to *x*, else ``True``"
msgstr "``False`` si un élément de *s* est égal à *x*, sinon ``True``"

#: ../Doc/library/stdtypes.rst:739
msgid "``s + t``"
msgstr "``s + t``"

#: ../Doc/library/stdtypes.rst:739
msgid "the concatenation of *s* and *t*"
msgstr "la concaténation de *s* et *t*"

#: ../Doc/library/stdtypes.rst:742
msgid "``s * n, n * s``"
msgstr ""

#: ../Doc/library/stdtypes.rst:742
msgid "equivalent to adding *s* to itself *n* times"
msgstr "équivalent à ajouter *s* *n* fois à lui même"

#: ../Doc/library/stdtypes.rst:745
msgid "``s[i]``"
msgstr "``s[i]``"

#: ../Doc/library/stdtypes.rst:745
msgid "*i*\\ th item of *s*, origin 0"
msgstr "*i*\\ :sup:`e` élément de *s* en commençant par 0"

#: ../Doc/library/stdtypes.rst:747
msgid "``s[i:j]``"
msgstr "``s[i:j]``"

#: ../Doc/library/stdtypes.rst:747
msgid "slice of *s* from *i* to *j*"
msgstr "tranche (*slice*) de *s* de *i* à *j*"

#: ../Doc/library/stdtypes.rst:749
msgid "``s[i:j:k]``"
msgstr "``s[i:j:k]``"

#: ../Doc/library/stdtypes.rst:749
msgid "slice of *s* from *i* to *j* with step *k*"
msgstr "tranche (*slice*) de *s* de *i* à *j* avec un pas de *k*"

#: ../Doc/library/stdtypes.rst:749
msgid "(3)(5)"
msgstr "(3)(5)"

#: ../Doc/library/stdtypes.rst:752
msgid "``len(s)``"
msgstr "``len(s)``"

#: ../Doc/library/stdtypes.rst:752
msgid "length of *s*"
msgstr "longueur de *s*"

#: ../Doc/library/stdtypes.rst:754
msgid "``min(s)``"
msgstr "``min(s)``"

#: ../Doc/library/stdtypes.rst:754
msgid "smallest item of *s*"
msgstr "plus petit élément de *s*"

#: ../Doc/library/stdtypes.rst:756
msgid "``max(s)``"
msgstr "``max(s)``"

#: ../Doc/library/stdtypes.rst:756
msgid "largest item of *s*"
msgstr "plus grand élément de *s*"

#: ../Doc/library/stdtypes.rst:758
msgid "``s.index(x)``"
msgstr ""

#: ../Doc/library/stdtypes.rst:758
msgid "index of the first occurrence of *x* in *s*"
msgstr ""

#: ../Doc/library/stdtypes.rst:761 ../Doc/library/stdtypes.rst:1679
msgid "``s.count(x)``"
msgstr "``s.count(x)``"

#: ../Doc/library/stdtypes.rst:761
msgid "total number of occurrences of *x* in *s*"
msgstr "nombre total d'occurrences de *x* dans *s*"

#: ../Doc/library/stdtypes.rst:765
msgid ""
"Sequence types also support comparisons. In particular, tuples and lists are "
"compared lexicographically by comparing corresponding elements. This means "
"that to compare equal, every element must compare equal and the two "
"sequences must be of the same type and have the same length. (For full "
"details see :ref:`comparisons` in the language reference.)"
msgstr ""

#: ../Doc/library/stdtypes.rst:788
msgid ""
"When *s* is a string or Unicode string object the ``in`` and ``not in`` "
"operations act like a substring test.  In Python versions before 2.3, *x* "
"had to be a string of length 1. In Python 2.3 and beyond, *x* may be a "
"string of any length."
msgstr ""

#: ../Doc/library/stdtypes.rst:794
msgid ""
"Values of *n* less than ``0`` are treated as ``0`` (which yields an empty "
"sequence of the same type as *s*).  Note that items in the sequence *s* are "
"not copied; they are referenced multiple times.  This often haunts new "
"Python programmers; consider:"
msgstr ""

#: ../Doc/library/stdtypes.rst:806
msgid ""
"What has happened is that ``[[]]`` is a one-element list containing an empty "
"list, so all three elements of ``[[]] * 3`` are references to this single "
"empty list.  Modifying any of the elements of ``lists`` modifies this single "
"list. You can create a list of different lists this way:"
msgstr ""

#: ../Doc/library/stdtypes.rst:818
msgid ""
"Further explanation is available in the FAQ entry :ref:`faq-multidimensional-"
"list`."
msgstr ""
"De plus amples explications sont disponibles dans la FAQ à la question :ref:"
"`faq-multidimensional-list`."

#: ../Doc/library/stdtypes.rst:822
msgid ""
"If *i* or *j* is negative, the index is relative to the end of the string: "
"``len(s) + i`` or ``len(s) + j`` is substituted.  But note that ``-0`` is "
"still ``0``."
msgstr ""
"Si *i* ou *j* sont négatifs, l'indice est relatif à la fin de la chaîne : "
"``len(s) + i`` ou ``len(s) + j`` est substitué. Mais notez que ``-0`` est "
"toujours ``0``."

#: ../Doc/library/stdtypes.rst:827
msgid ""
"The slice of *s* from *i* to *j* is defined as the sequence of items with "
"index *k* such that ``i <= k < j``.  If *i* or *j* is greater than "
"``len(s)``, use ``len(s)``.  If *i* is omitted or ``None``, use ``0``.  If "
"*j* is omitted or ``None``, use ``len(s)``.  If *i* is greater than or equal "
"to *j*, the slice is empty."
msgstr ""
"La tranche de *s* de *i* à *j* est définie comme la séquence d'éléments "
"d'indice *k* tels que ``i <= k < j``. Si *i* ou *j* est supérieur à "
"``len(s)``, ``len(s)`` est utilisé. Si *i* est omis ou ``None``, ``0`` est "
"utilisé. Si *j* est omis ou ``None``, ``len(s)`` est utilisé. Si *i* est "
"supérieure ou égale à *j*, la tranche est vide."

#: ../Doc/library/stdtypes.rst:834
msgid ""
"The slice of *s* from *i* to *j* with step *k* is defined as the sequence of "
"items with index  ``x = i + n*k`` such that ``0 <= n < (j-i)/k``.  In other "
"words, the indices are ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` and so on, "
"stopping when *j* is reached (but never including *j*).  If *i* or *j* is "
"greater than ``len(s)``, use ``len(s)``.  If *i* or *j* are omitted or "
"``None``, they become \"end\" values (which end depends on the sign of "
"*k*).  Note, *k* cannot be zero. If *k* is ``None``, it is treated like "
"``1``."
msgstr ""
"La tranche de *s* de *i* à *j* avec un pas de *k* est définie comme la "
"séquence d'éléments d'indice ``x = i + n*k`` tels que ``0 <= n < (j-i)/k``. "
"En d'autres termes, les indices sont ``i``, ``i+k``, ``i+2*k``, ``i+3*k`` et "
"ainsi de suite, en arrêtant lorsque *j* est atteint (mais jamais inclus). Si "
"*i* ou *j* est supérieur à ``len(s)``, ``len(s)`` est utilisé. Si *i* ou *j* "
"sont omis ou ``None``, ils deviennent des valeurs \"extrêmes\" (où l'ordre "
"dépend du signe de *k*). Remarquez, *k* ne peut pas valoir zéro. Si *k* est "
"``None``, il est traité comme ``1``."

#: ../Doc/library/stdtypes.rst:845
msgid ""
"If *s* and *t* are both strings, some Python implementations such as CPython "
"can usually perform an in-place optimization for assignments of the form ``s "
"= s + t`` or ``s += t``.  When applicable, this optimization makes quadratic "
"run-time much less likely.  This optimization is both version and "
"implementation dependent.  For performance sensitive code, it is preferable "
"to use the :meth:`str.join` method which assures consistent linear "
"concatenation performance across versions and implementations."
msgstr ""

#: ../Doc/library/stdtypes.rst:853
msgid "Formerly, string concatenation never occurred in-place."
msgstr ""

#: ../Doc/library/stdtypes.rst:860
msgid "String Methods"
msgstr "Méthodes de chaînes de caractères"

#: ../Doc/library/stdtypes.rst:864
msgid ""
"Below are listed the string methods which both 8-bit strings and Unicode "
"objects support.  Some of them are also available on :class:`bytearray` "
"objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:868
msgid ""
"In addition, Python's strings support the sequence type methods described in "
"the :ref:`typesseq` section. To output formatted strings use template "
"strings or the ``%`` operator described in the :ref:`string-formatting` "
"section. Also, see the :mod:`re` module for string functions based on "
"regular expressions."
msgstr ""

#: ../Doc/library/stdtypes.rst:876
msgid ""
"Return a copy of the string with its first character capitalized and the "
"rest lowercased."
msgstr ""
"Renvoie une copie de la chaîne avec son premier caractère en majuscule et le "
"reste en minuscule."

#: ../Doc/library/stdtypes.rst:879 ../Doc/library/stdtypes.rst:1015
#: ../Doc/library/stdtypes.rst:1023 ../Doc/library/stdtypes.rst:1031
#: ../Doc/library/stdtypes.rst:1039 ../Doc/library/stdtypes.rst:1047
#: ../Doc/library/stdtypes.rst:1056 ../Doc/library/stdtypes.rst:1064
#: ../Doc/library/stdtypes.rst:1089 ../Doc/library/stdtypes.rst:1317
#: ../Doc/library/stdtypes.rst:1345 ../Doc/library/stdtypes.rst:1382
msgid "For 8-bit strings, this method is locale-dependent."
msgstr ""

#: ../Doc/library/stdtypes.rst:884
msgid ""
"Return centered in a string of length *width*. Padding is done using the "
"specified *fillchar* (default is a space)."
msgstr ""

#: ../Doc/library/stdtypes.rst:887 ../Doc/library/stdtypes.rst:1080
#: ../Doc/library/stdtypes.rst:1144
msgid "Support for the *fillchar* argument."
msgstr ""

#: ../Doc/library/stdtypes.rst:893
msgid ""
"Return the number of non-overlapping occurrences of substring *sub* in the "
"range [*start*, *end*].  Optional arguments *start* and *end* are "
"interpreted as in slice notation."
msgstr ""
"Donne le nombre d'occurrences de *sub* ne se chevauchant pas dans le *range* "
"[*start*, *end*]. Les arguments facultatifs *start* et *end* sont "
"interprétés comme pour des *slices*."

#: ../Doc/library/stdtypes.rst:900
msgid ""
"Decodes the string using the codec registered for *encoding*. *encoding* "
"defaults to the default string encoding.  *errors* may be given to set a "
"different error handling scheme.  The default is ``'strict'``, meaning that "
"encoding errors raise :exc:`UnicodeError`.  Other possible values are "
"``'ignore'``, ``'replace'`` and any other name registered via :func:`codecs."
"register_error`, see section :ref:`codec-base-classes`."
msgstr ""

#: ../Doc/library/stdtypes.rst:909
msgid "Support for other error handling schemes added."
msgstr ""

#: ../Doc/library/stdtypes.rst:912 ../Doc/library/stdtypes.rst:932
msgid "Support for keyword arguments added."
msgstr "Gestion des arguments par mot clef."

#: ../Doc/library/stdtypes.rst:917
msgid ""
"Return an encoded version of the string.  Default encoding is the current "
"default string encoding.  *errors* may be given to set a different error "
"handling scheme.  The default for *errors* is ``'strict'``, meaning that "
"encoding errors raise a :exc:`UnicodeError`.  Other possible values are "
"``'ignore'``, ``'replace'``, ``'xmlcharrefreplace'``, ``'backslashreplace'`` "
"and any other name registered via :func:`codecs.register_error`, see "
"section :ref:`codec-base-classes`. For a list of possible encodings, see "
"section :ref:`standard-encodings`."
msgstr ""

#: ../Doc/library/stdtypes.rst:928
msgid ""
"Support for ``'xmlcharrefreplace'`` and ``'backslashreplace'`` and other "
"error handling schemes added."
msgstr ""

#: ../Doc/library/stdtypes.rst:937
msgid ""
"Return ``True`` if the string ends with the specified *suffix*, otherwise "
"return ``False``.  *suffix* can also be a tuple of suffixes to look for.  "
"With optional *start*, test beginning at that position.  With optional "
"*end*, stop comparing at that position."
msgstr ""
"Donne ``True`` si la chaîne se termine par *suffix*, sinon ``False``. "
"*suffix* peut aussi être un tuple de suffixes à rechercher. Si l'argument "
"optionnel *start* est donné, le test se fait à partir de cette position. Si "
"l'argument optionnel *end* est fourni, la comparaison s'arrête à cette "
"position."

#: ../Doc/library/stdtypes.rst:942
msgid "Accept tuples as *suffix*."
msgstr ""

#: ../Doc/library/stdtypes.rst:948
msgid ""
"Return a copy of the string where all tab characters are replaced by one or "
"more spaces, depending on the current column and the given tab size.  Tab "
"positions occur every *tabsize* characters (default is 8, giving tab "
"positions at columns 0, 8, 16 and so on).  To expand the string, the current "
"column is set to zero and the string is examined character by character.  If "
"the character is a tab (``\\t``), one or more space characters are inserted "
"in the result until the current column is equal to the next tab position. "
"(The tab character itself is not copied.)  If the character is a newline (``"
"\\n``) or return (``\\r``), it is copied and the current column is reset to "
"zero.  Any other character is copied unchanged and the current column is "
"incremented by one regardless of how the character is represented when "
"printed."
msgstr ""
"Donne une copie de la chaîne où toutes les tabulations sont remplacées par "
"un ou plusieurs espaces, en fonction de la colonne courante et de la taille "
"de tabulation donnée. Les positions des tabulations se trouvent tous les "
"*tabsize* caractères (8 par défaut, ce qui donne les positions de "
"tabulations aux colonnes 0, 8, 16 et ainsi de suite). Pour travailler sur la "
"chaîne, la colonne en cours est mise à zéro et la chaîne est examinée "
"caractère par caractère. Si le caractère est une tabulation (``\\t``), un ou "
"plusieurs caractères d'espacement sont insérés dans le résultat jusqu'à ce "
"que la colonne courante soit égale à la position de tabulation suivante. (Le "
"caractère tabulation lui-même n'est pas copié.) Si le caractère est un saut "
"de ligne (``\\n``) ou un retour chariot (``\\r``), il est copié et la "
"colonne en cours est remise à zéro. Tout autre caractère est copié inchangé "
"et la colonne en cours est incrémentée de un indépendamment de la façon dont "
"le caractère est représenté lors de l'affichage."

#: ../Doc/library/stdtypes.rst:969
msgid ""
"Return the lowest index in the string where substring *sub* is found within "
"the slice ``s[start:end]``.  Optional arguments *start* and *end* are "
"interpreted as in slice notation.  Return ``-1`` if *sub* is not found."
msgstr ""
"Donne la première la position dans la chaîne où *sub* est trouvé dans le "
"*slice* ``s[start:end]``. Les arguments facultatifs *start* et *end* sont "
"interprétés comme dans la notation des *slice*. Donne ``-1`` si *sub* n'est "
"pas trouvé."

#: ../Doc/library/stdtypes.rst:975
msgid ""
"The :meth:`~str.find` method should be used only if you need to know the "
"position of *sub*.  To check if *sub* is a substring or not, use the :"
"keyword:`in` operator::"
msgstr ""
"La méthode :meth:`~str.find` ne doit être utilisée que si vous avez besoin "
"de connaître la position de *sub*. Pour vérifier si *sub* est une sous "
"chaine ou non, utilisez l'opérateur :keyword:`in` ::"

#: ../Doc/library/stdtypes.rst:985
msgid ""
"Perform a string formatting operation.  The string on which this method is "
"called can contain literal text or replacement fields delimited by braces "
"``{}``.  Each replacement field contains either the numeric index of a "
"positional argument, or the name of a keyword argument.  Returns a copy of "
"the string where each replacement field is replaced with the string value of "
"the corresponding argument."
msgstr ""
"Formate une chaîne. La chaîne sur laquelle cette méthode est appelée peut "
"contenir du texte littéral ou des emplacements de remplacement délimités par "
"des accolades ``{}``. Chaque champ de remplacement contient soit l'indice "
"numérique d'un argument positionnel, ou le nom d'un argument donné par mot-"
"clé. Renvoie une copie de la chaîne où chaque champ de remplacement est "
"remplacé par la valeur de chaîne de l'argument correspondant."

#: ../Doc/library/stdtypes.rst:995
msgid ""
"See :ref:`formatstrings` for a description of the various formatting options "
"that can be specified in format strings."
msgstr ""
"Voir :ref:`formatstrings` pour une description des options de formatage qui "
"peuvent être spécifiées dans les chaînes de format."

#: ../Doc/library/stdtypes.rst:998
msgid ""
"This method of string formatting is the new standard in Python 3, and should "
"be preferred to the ``%`` formatting described in :ref:`string-formatting` "
"in new code."
msgstr ""

#: ../Doc/library/stdtypes.rst:1007
msgid ""
"Like :meth:`find`, but raise :exc:`ValueError` when the substring is not "
"found."
msgstr ""

#: ../Doc/library/stdtypes.rst:1012
msgid ""
"Return true if all characters in the string are alphanumeric and there is at "
"least one character, false otherwise."
msgstr ""

#: ../Doc/library/stdtypes.rst:1020
msgid ""
"Return true if all characters in the string are alphabetic and there is at "
"least one character, false otherwise."
msgstr ""

#: ../Doc/library/stdtypes.rst:1028
msgid ""
"Return true if all characters in the string are digits and there is at least "
"one character, false otherwise."
msgstr ""

#: ../Doc/library/stdtypes.rst:1036
msgid ""
"Return true if all cased characters [4]_ in the string are lowercase and "
"there is at least one cased character, false otherwise."
msgstr ""
"Donne ``True`` si tous les caractères capitalisables [4]_ de la chaîne sont "
"en minuscules et qu'elle contient au moins un caractère capitalisable. Donne "
"``False`` dans le cas contraire."

#: ../Doc/library/stdtypes.rst:1044
msgid ""
"Return true if there are only whitespace characters in the string and there "
"is at least one character, false otherwise."
msgstr ""

#: ../Doc/library/stdtypes.rst:1052
msgid ""
"Return true if the string is a titlecased string and there is at least one "
"character, for example uppercase characters may only follow uncased "
"characters and lowercase characters only cased ones.  Return false otherwise."
msgstr ""
"Donne ``True`` si la chaîne est une chaîne *titlecased* et qu'elle contient "
"au moins un caractère, par exemple les caractères majuscules ne peuvent "
"suivre les caractères non capitalisables et les caractères minuscules ne "
"peuvent suivre que des caractères capitalisables. Donne ``False`` dans le "
"cas contraire."

#: ../Doc/library/stdtypes.rst:1061
msgid ""
"Return true if all cased characters [4]_ in the string are uppercase and "
"there is at least one cased character, false otherwise."
msgstr ""
"Donne ``True`` si tous les caractères différentiables sur la casse [4]_ de "
"la chaîne sont en majuscules et il y a au moins un caractère différentiable "
"sur la casse, sinon ``False``."

#: ../Doc/library/stdtypes.rst:1069
msgid ""
"Return a string which is the concatenation of the strings in the :term:"
"`iterable` *iterable*.  The separator between elements is the string "
"providing this method."
msgstr ""

#: ../Doc/library/stdtypes.rst:1076
msgid ""
"Return the string left justified in a string of length *width*. Padding is "
"done using the specified *fillchar* (default is a space).  The original "
"string is returned if *width* is less than or equal to ``len(s)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:1086
msgid ""
"Return a copy of the string with all the cased characters [4]_ converted to "
"lowercase."
msgstr ""
"Renvoie une copie de la chaîne avec tous les caractères capitalisables [4]_ "
"convertis en minuscules."

#: ../Doc/library/stdtypes.rst:1094
msgid ""
"Return a copy of the string with leading characters removed.  The *chars* "
"argument is a string specifying the set of characters to be removed.  If "
"omitted or ``None``, the *chars* argument defaults to removing whitespace.  "
"The *chars* argument is not a prefix; rather, all combinations of its values "
"are stripped:"
msgstr ""

#: ../Doc/library/stdtypes.rst:1104 ../Doc/library/stdtypes.rst:1181
#: ../Doc/library/stdtypes.rst:1308
msgid "Support for the *chars* argument."
msgstr ""

#: ../Doc/library/stdtypes.rst:1110
msgid ""
"Split the string at the first occurrence of *sep*, and return a 3-tuple "
"containing the part before the separator, the separator itself, and the part "
"after the separator.  If the separator is not found, return a 3-tuple "
"containing the string itself, followed by two empty strings."
msgstr ""
"Divise la chaîne à la première occurrence de *sep*, et donne un *tuple* de "
"trois éléments contenant la partie avant le séparateur, le séparateur lui-"
"même, et la partie après le séparateur. Si le séparateur n'est pas trouvé, "
"le *tuple* contiendra la chaîne elle-même, suivie de deux chaînes vides."

#: ../Doc/library/stdtypes.rst:1120
msgid ""
"Return a copy of the string with all occurrences of substring *old* replaced "
"by *new*.  If the optional argument *count* is given, only the first *count* "
"occurrences are replaced."
msgstr ""
"Renvoie une copie de la chaîne dont toutes les occurrences de la sous-"
"chaîne  *old* sont remplacés par *new*. Si l'argument optionnel *count* est "
"donné, seules les *count* premières occurrences sont remplacées."

#: ../Doc/library/stdtypes.rst:1127
msgid ""
"Return the highest index in the string where substring *sub* is found, such "
"that *sub* is contained within ``s[start:end]``.  Optional arguments *start* "
"and *end* are interpreted as in slice notation.  Return ``-1`` on failure."
msgstr ""
"Donne l'indice le plus élevé dans la chaîne où la sous-chaîne *sub* se "
"trouve, de telle sorte que *sub* soit contenue dans ``s[start:end]``. Les "
"arguments facultatifs *start* et *end* sont interprétés comme dans la "
"notation des *slices*. Donne  ``-1`` en cas d'échec."

#: ../Doc/library/stdtypes.rst:1134
msgid ""
"Like :meth:`rfind` but raises :exc:`ValueError` when the substring *sub* is "
"not found."
msgstr ""
"Comme :meth:`rfind` mais lève une exception :exc:`ValueError` lorsque la "
"sous-chaîne *sub* est introuvable."

#: ../Doc/library/stdtypes.rst:1140
msgid ""
"Return the string right justified in a string of length *width*. Padding is "
"done using the specified *fillchar* (default is a space). The original "
"string is returned if *width* is less than or equal to ``len(s)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:1150
msgid ""
"Split the string at the last occurrence of *sep*, and return a 3-tuple "
"containing the part before the separator, the separator itself, and the part "
"after the separator.  If the separator is not found, return a 3-tuple "
"containing two empty strings, followed by the string itself."
msgstr ""
"Divise la chaîne à la dernière occurrence de *sep*, et donne un tuple de "
"trois éléments contenant la partie avant le séparateur, le séparateur lui-"
"même, et la partie après le séparateur. Si le séparateur n'est pas trouvé, "
"le *tuple* contiendra deux chaînes vides, puis par la chaîne elle-même."

#: ../Doc/library/stdtypes.rst:1160
msgid ""
"Return a list of the words in the string, using *sep* as the delimiter "
"string. If *maxsplit* is given, at most *maxsplit* splits are done, the "
"*rightmost* ones.  If *sep* is not specified or ``None``, any whitespace "
"string is a separator.  Except for splitting from the right, :meth:`rsplit` "
"behaves like :meth:`split` which is described in detail below."
msgstr ""
"Renvoie une liste des mots de la chaîne, en utilisant *sep* comme "
"séparateur. Si *maxsplit* est donné, c'est le nombre maximum de divisions "
"qui pourront être faites, celles \"à droite\". Si *sep* est pas spécifié ou "
"est ``None``, tout espace est un séparateur. En dehors du fait qu'il découpe "
"par la droite, :meth:`rsplit` se comporte comme :meth:`split` qui est décrit "
"en détail ci-dessous."

#: ../Doc/library/stdtypes.rst:1171
msgid ""
"Return a copy of the string with trailing characters removed.  The *chars* "
"argument is a string specifying the set of characters to be removed.  If "
"omitted or ``None``, the *chars* argument defaults to removing whitespace.  "
"The *chars* argument is not a suffix; rather, all combinations of its values "
"are stripped:"
msgstr ""

#: ../Doc/library/stdtypes.rst:1187
msgid ""
"Return a list of the words in the string, using *sep* as the delimiter "
"string.  If *maxsplit* is given, at most *maxsplit* splits are done (thus, "
"the list will have at most ``maxsplit+1`` elements).  If *maxsplit* is not "
"specified or ``-1``, then there is no limit on the number of splits (all "
"possible splits are made)."
msgstr ""
"Renvoie une liste des mots de la chaîne, en utilisant *sep* comme séparateur "
"de mots. Si *maxsplit* est donné, c'est le nombre maximum de divisions qui "
"pourront être effectuées, (donnant ainsi une liste de longueur ``maxsplit"
"+1``). Si *maxsplit* n'est pas fourni, ou vaut ``-1``, le nombre de découpes "
"n'est pas limité (Toutes les découpes possibles sont faites)."

#: ../Doc/library/stdtypes.rst:1193
msgid ""
"If *sep* is given, consecutive delimiters are not grouped together and are "
"deemed to delimit empty strings (for example, ``'1,,2'.split(',')`` returns "
"``['1', '', '2']``).  The *sep* argument may consist of multiple characters "
"(for example, ``'1<>2<>3'.split('<>')`` returns ``['1', '2', '3']``). "
"Splitting an empty string with a specified separator returns ``['']``."
msgstr ""
"Si *sep* est donné, les délimiteurs consécutifs ne sont pas regroupés et "
"ainsi délimitent des chaînes vides (par exemple, ``'1,,2'.split(',')`` donne "
"``['1', '', '2']``). L'argument *sep* peut contenir plusieurs caractères "
"(par exemple, ``'1<>2<>3'.split('<>')`` renvoie ``['1', '2', '3']``). "
"Découper une chaîne vide en spécifiant *sep* donne ``['']``."

#: ../Doc/library/stdtypes.rst:1199
msgid ""
"If *sep* is not specified or is ``None``, a different splitting algorithm is "
"applied: runs of consecutive whitespace are regarded as a single separator, "
"and the result will contain no empty strings at the start or end if the "
"string has leading or trailing whitespace.  Consequently, splitting an empty "
"string or a string consisting of just whitespace with a ``None`` separator "
"returns ``[]``."
msgstr ""
"Si *sep* n'est pas spécifié ou est ``None``, un autre algorithme de "
"découpage est appliqué : les espaces consécutifs sont considérés comme un "
"seul séparateur, et le résultat ne contiendra pas les chaînes vides de début "
"ou de la fin si la chaîne est préfixée ou suffixé d'espaces. Par conséquent, "
"diviser une chaîne vide ou une chaîne composée d'espaces avec un séparateur "
"``None`` renvoie ``[]``."

#: ../Doc/library/stdtypes.rst:1206
msgid ""
"For example, ``' 1  2   3  '.split()`` returns ``['1', '2', '3']``, and ``'  "
"1  2   3  '.split(None, 1)`` returns ``['1', '2   3  ']``."
msgstr ""

#: ../Doc/library/stdtypes.rst:1215
msgid ""
"Return a list of the lines in the string, breaking at line boundaries. This "
"method uses the :term:`universal newlines` approach to splitting lines. Line "
"breaks are not included in the resulting list unless *keepends* is given and "
"true."
msgstr ""

#: ../Doc/library/stdtypes.rst:1220
msgid ""
"Python recognizes ``\"\\r\"``, ``\"\\n\"``, and ``\"\\r\\n\"`` as line "
"boundaries for 8-bit strings."
msgstr ""

#: ../Doc/library/stdtypes.rst:1223
msgid "For example::"
msgstr "Par exemple ::"

#: ../Doc/library/stdtypes.rst:1230
msgid ""
"Unlike :meth:`~str.split` when a delimiter string *sep* is given, this "
"method returns an empty list for the empty string, and a terminal line break "
"does not result in an extra line::"
msgstr ""
"Contrairement à :meth:`~str.split` lorsque *sep* est fourni, cette méthode "
"renvoie une liste vide pour la chaîne vide, et un saut de ligne à la fin ne "
"se traduit pas par une ligne supplémentaire : ::"

#: ../Doc/library/stdtypes.rst:1239
msgid "For comparison, ``split('\\n')`` gives::"
msgstr "À titre de comparaison, ``split('\\n')`` donne : ::"

#: ../Doc/library/stdtypes.rst:1248
msgid ""
"Return a list of the lines in the string, like :meth:`str.splitlines`. "
"However, the Unicode method splits on the following line boundaries, which "
"are a superset of the :term:`universal newlines` recognized for 8-bit "
"strings."
msgstr ""

#: ../Doc/library/stdtypes.rst:1254
msgid "Representation"
msgstr "Représentation"

#: ../Doc/library/stdtypes.rst:1254
msgid "Description"
msgstr "Description"

#: ../Doc/library/stdtypes.rst:1256
msgid "``\\n``"
msgstr "``\\n``"

#: ../Doc/library/stdtypes.rst:1256
msgid "Line Feed"
msgstr "Saut de ligne"

#: ../Doc/library/stdtypes.rst:1258
msgid "``\\r``"
msgstr "``\\r``"

#: ../Doc/library/stdtypes.rst:1258
msgid "Carriage Return"
msgstr "Retour chariot"

#: ../Doc/library/stdtypes.rst:1260
msgid "``\\r\\n``"
msgstr "``\\r\\n``"

#: ../Doc/library/stdtypes.rst:1260
msgid "Carriage Return + Line Feed"
msgstr "Retour chariot + saut de ligne"

#: ../Doc/library/stdtypes.rst:1262
msgid "``\\v`` or ``\\x0b``"
msgstr "``\\v`` or ``\\x0b``"

#: ../Doc/library/stdtypes.rst:1262
msgid "Line Tabulation"
msgstr "Tabulation verticale"

#: ../Doc/library/stdtypes.rst:1264
msgid "``\\f`` or ``\\x0c``"
msgstr "``\\f`` or ``\\x0c``"

#: ../Doc/library/stdtypes.rst:1264
msgid "Form Feed"
msgstr "Saut de page"

#: ../Doc/library/stdtypes.rst:1266
msgid "``\\x1c``"
msgstr "``\\x1c``"

#: ../Doc/library/stdtypes.rst:1266
msgid "File Separator"
msgstr "Séparateur de fichiers"

#: ../Doc/library/stdtypes.rst:1268
msgid "``\\x1d``"
msgstr "``\\x1d``"

#: ../Doc/library/stdtypes.rst:1268
msgid "Group Separator"
msgstr "Séparateur de groupes"

#: ../Doc/library/stdtypes.rst:1270
msgid "``\\x1e``"
msgstr "``\\x1e``"

#: ../Doc/library/stdtypes.rst:1270
msgid "Record Separator"
msgstr "Séparateur d'enregistrements"

#: ../Doc/library/stdtypes.rst:1272
msgid "``\\x85``"
msgstr "``\\x85``"

#: ../Doc/library/stdtypes.rst:1272
msgid "Next Line (C1 Control Code)"
msgstr "Ligne suivante (code de contrôle *C1*)"

#: ../Doc/library/stdtypes.rst:1274
msgid "``\\u2028``"
msgstr "``\\u2028``"

#: ../Doc/library/stdtypes.rst:1274
msgid "Line Separator"
msgstr "Séparateur de ligne"

#: ../Doc/library/stdtypes.rst:1276
msgid "``\\u2029``"
msgstr "``\\u2029``"

#: ../Doc/library/stdtypes.rst:1276
msgid "Paragraph Separator"
msgstr "Séparateur de paragraphe"

#: ../Doc/library/stdtypes.rst:1281
msgid "``\\v`` and ``\\f`` added to list of line boundaries."
msgstr "``\\v`` et ``\\f`` ajoutés à la liste des limites de lignes."

#: ../Doc/library/stdtypes.rst:1286
msgid ""
"Return ``True`` if string starts with the *prefix*, otherwise return "
"``False``. *prefix* can also be a tuple of prefixes to look for.  With "
"optional *start*, test string beginning at that position.  With optional "
"*end*, stop comparing string at that position."
msgstr ""
"Donne ``True`` si la chaîne commence par *prefix*, sinon  ``False``. "
"*prefix* peut aussi être un tuple de préfixes à rechercher. Lorsque *start* "
"est donné, la comparaison commence à cette position, et lorsque *end* est "
"donné, la comparaison s'arrête à celle ci."

#: ../Doc/library/stdtypes.rst:1291
msgid "Accept tuples as *prefix*."
msgstr ""

#: ../Doc/library/stdtypes.rst:1297
msgid ""
"Return a copy of the string with the leading and trailing characters "
"removed. The *chars* argument is a string specifying the set of characters "
"to be removed. If omitted or ``None``, the *chars* argument defaults to "
"removing whitespace. The *chars* argument is not a prefix or suffix; rather, "
"all combinations of its values are stripped:"
msgstr ""

#: ../Doc/library/stdtypes.rst:1314
msgid ""
"Return a copy of the string with uppercase characters converted to lowercase "
"and vice versa."
msgstr ""

#: ../Doc/library/stdtypes.rst:1322
msgid ""
"Return a titlecased version of the string where words start with an "
"uppercase character and the remaining characters are lowercase."
msgstr ""
"Renvoie une version en initiales majuscules de la chaîne où les mots "
"commencent par une capitale et les caractères restants sont en minuscules."

#: ../Doc/library/stdtypes.rst:1325
msgid ""
"The algorithm uses a simple language-independent definition of a word as "
"groups of consecutive letters.  The definition works in many contexts but it "
"means that apostrophes in contractions and possessives form word boundaries, "
"which may not be the desired result::"
msgstr ""
"Pour l'algorithme, la notion de mot est définie simplement et indépendamment "
"de la langue comme un groupe de lettres consécutives. La définition "
"fonctionne dans de nombreux contextes, mais cela signifie que les "
"apostrophes (typiquement de la forme possessive en Anglais) forment les "
"limites de mot, ce qui n'est pas toujours le résultat souhaité : ::"

#: ../Doc/library/stdtypes.rst:1333
msgid ""
"A workaround for apostrophes can be constructed using regular expressions::"
msgstr ""
"Une solution pour contourner le problème des apostrophes peut être obtenue "
"en utilisant des expressions rationnelles : ::"

#: ../Doc/library/stdtypes.rst:1350
msgid ""
"Return a copy of the string where all characters occurring in the optional "
"argument *deletechars* are removed, and the remaining characters have been "
"mapped through the given translation table, which must be a string of length "
"256."
msgstr ""

#: ../Doc/library/stdtypes.rst:1355
msgid ""
"You can use the :func:`~string.maketrans` helper function in the :mod:"
"`string` module to create a translation table. For string objects, set the "
"*table* argument to ``None`` for translations that only delete characters:"
msgstr ""

#: ../Doc/library/stdtypes.rst:1362
msgid "Support for a ``None`` *table* argument."
msgstr ""

#: ../Doc/library/stdtypes.rst:1365
msgid ""
"For Unicode objects, the :meth:`translate` method does not accept the "
"optional *deletechars* argument.  Instead, it returns a copy of the *s* "
"where all characters have been mapped through the given translation table "
"which must be a mapping of Unicode ordinals to Unicode ordinals, Unicode "
"strings or ``None``. Unmapped characters are left untouched. Characters "
"mapped to ``None`` are deleted.  Note, a more flexible approach is to create "
"a custom character mapping codec using the :mod:`codecs` module (see :mod:"
"`encodings.cp1251` for an example)."
msgstr ""

#: ../Doc/library/stdtypes.rst:1377
msgid ""
"Return a copy of the string with all the cased characters [4]_ converted to "
"uppercase.  Note that ``str.upper().isupper()`` might be ``False`` if ``s`` "
"contains uncased characters or if the Unicode category of the resulting "
"character(s) is not \"Lu\" (Letter, uppercase), but e.g. \"Lt\" (Letter, "
"titlecase)."
msgstr ""
"Renvoie une copie de la chaîne dont tous les caractères capitalisables [4]_ "
"sontconvertis en capitales. Notez que ``str.upper().isupper()`` pourrait "
"être ``False`` si ``s`` contient des caractères non capitalisables ou si la "
"catégorieUnicode d'un caractère du résultant est pas \"Lu\" (Lettre, "
"majuscule), mais par exemple \"Lt\" (Lettre, titlecase)."

#: ../Doc/library/stdtypes.rst:1387
msgid ""
"Return the numeric string left filled with zeros in a string of length "
"*width*.  A sign prefix is handled correctly.  The original string is "
"returned if *width* is less than or equal to ``len(s)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:1394
msgid "The following methods are present only on unicode objects:"
msgstr ""

#: ../Doc/library/stdtypes.rst:1398
msgid ""
"Return ``True`` if there are only numeric characters in S, ``False`` "
"otherwise. Numeric characters include digit characters, and all characters "
"that have the Unicode numeric value property, e.g. U+2155, VULGAR FRACTION "
"ONE FIFTH."
msgstr ""

#: ../Doc/library/stdtypes.rst:1405
msgid ""
"Return ``True`` if there are only decimal characters in S, ``False`` "
"otherwise. Decimal characters include digit characters, and all characters "
"that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC "
"DIGIT ZERO."
msgstr ""

#: ../Doc/library/stdtypes.rst:1414
msgid "String Formatting Operations"
msgstr ""

#: ../Doc/library/stdtypes.rst:1426
msgid ""
"String and Unicode objects have one unique built-in operation: the ``%`` "
"operator (modulo).  This is also known as the string *formatting* or "
"*interpolation* operator.  Given ``format % values`` (where *format* is a "
"string or Unicode object), ``%`` conversion specifications in *format* are "
"replaced with zero or more elements of *values*.  The effect is similar to "
"the using :c:func:`sprintf` in the C language.  If *format* is a Unicode "
"object, or if any of the objects being converted using the ``%s`` conversion "
"are Unicode objects, the result will also be a Unicode object."
msgstr ""

#: ../Doc/library/stdtypes.rst:1435
msgid ""
"If *format* requires a single argument, *values* may be a single non-tuple "
"object. [5]_  Otherwise, *values* must be a tuple with exactly the number of "
"items specified by the format string, or a single mapping object (for "
"example, a dictionary)."
msgstr ""
"Si *format* ne nécessite qu'un seul argument, *values* peut être un objet "
"unique. [5]_ Si *values* est un tuple, il doit contenir exactement le nombre "
"d'éléments spécifiés par la chaîne de format, ou un seul objet de "
"correspondances ( *mapping object*, par exemple, un dictionnaire)."

#: ../Doc/library/stdtypes.rst:1440
msgid ""
"A conversion specifier contains two or more characters and has the following "
"components, which must occur in this order:"
msgstr ""
"Un indicateur de conversion contient deux ou plusieurs caractères et "
"comporte les éléments suivants, qui doivent apparaître dans cet ordre :"

#: ../Doc/library/stdtypes.rst:1443
msgid "The ``'%'`` character, which marks the start of the specifier."
msgstr "Le caractère ``'%'``, qui marque le début du marqueur."

#: ../Doc/library/stdtypes.rst:1445
msgid ""
"Mapping key (optional), consisting of a parenthesised sequence of characters "
"(for example, ``(somename)``)."
msgstr ""
"La clé de correspondance (facultative), composée d'une suite de caractères "
"entre parenthèse (par exemple, ``(somename)``)."

#: ../Doc/library/stdtypes.rst:1448
msgid ""
"Conversion flags (optional), which affect the result of some conversion "
"types."
msgstr ""
"Des options de conversion, facultatives, qui affectent le résultat de "
"certains types de conversion."

#: ../Doc/library/stdtypes.rst:1451
msgid ""
"Minimum field width (optional).  If specified as an ``'*'`` (asterisk), the "
"actual width is read from the next element of the tuple in *values*, and the "
"object to convert comes after the minimum field width and optional precision."
msgstr ""
"Largeur minimum (facultative). Si elle vaut ``'*'`` (astérisque), la largeur "
"est lue de l'élément suivant du tuple *values*, et l'objet à convertir vient "
"après la largeur de champ minimale et la précision facultative."

#: ../Doc/library/stdtypes.rst:1455
msgid ""
"Precision (optional), given as a ``'.'`` (dot) followed by the precision.  "
"If specified as ``'*'`` (an asterisk), the actual width is read from the "
"next element of the tuple in *values*, and the value to convert comes after "
"the precision."
msgstr ""

#: ../Doc/library/stdtypes.rst:1460
msgid "Length modifier (optional)."
msgstr "Modificateur de longueur (facultatif)."

#: ../Doc/library/stdtypes.rst:1462
msgid "Conversion type."
msgstr "Type de conversion."

#: ../Doc/library/stdtypes.rst:1464
msgid ""
"When the right argument is a dictionary (or other mapping type), then the "
"formats in the string *must* include a parenthesised mapping key into that "
"dictionary inserted immediately after the ``'%'`` character. The mapping key "
"selects the value to be formatted from the mapping.  For example:"
msgstr ""
"Lorsque l'argument de droite est un dictionnaire (ou un autre type de "
"*mapping*), les marqueurs dans la chaîne *doivent* inclure une clé présente "
"dans le dictionnaire, écrite entre parenthèses,  immédiatement après le "
"caractère ``'%'``. La clé indique quelle valeur du dictionnaire doit être "
"formatée. Par exemple :"

#: ../Doc/library/stdtypes.rst:1473
msgid ""
"In this case no ``*`` specifiers may occur in a format (since they require a "
"sequential parameter list)."
msgstr ""
"Dans ce cas, aucune ``*`` ne peuvent se trouver dans le format (car ces "
"``*`` nécessitent une liste (accès séquentiel) de paramètres)."

#: ../Doc/library/stdtypes.rst:1476
msgid "The conversion flag characters are:"
msgstr "Les caractères indicateurs de conversion sont :"

#: ../Doc/library/stdtypes.rst:1479
msgid "Flag"
msgstr "Option"

#: ../Doc/library/stdtypes.rst:1481
msgid "``'#'``"
msgstr "``'#'``"

#: ../Doc/library/stdtypes.rst:1481
msgid ""
"The value conversion will use the \"alternate form\" (where defined below)."
msgstr "La conversion utilisera la \"forme alternative\" (définie ci-dessous)."

#: ../Doc/library/stdtypes.rst:1484
msgid "``'0'``"
msgstr "``'0'``"

#: ../Doc/library/stdtypes.rst:1484
msgid "The conversion will be zero padded for numeric values."
msgstr "Les valeurs numériques converties seront complétée de zéros."

#: ../Doc/library/stdtypes.rst:1486
msgid "``'-'``"
msgstr "``'-'``"

#: ../Doc/library/stdtypes.rst:1486
msgid ""
"The converted value is left adjusted (overrides the ``'0'`` conversion if "
"both are given)."
msgstr ""
"La valeur convertie est ajustée à gauche (remplace la conversion ``'0'`` si "
"les deux sont données)."

#: ../Doc/library/stdtypes.rst:1489
msgid "``' '``"
msgstr "``' '``"

#: ../Doc/library/stdtypes.rst:1489
msgid ""
"(a space) A blank should be left before a positive number (or empty string) "
"produced by a signed conversion."
msgstr ""
"(un espace) Un espace doit être laissé avant un nombre positif (ou chaîne "
"vide) produite par la conversion d'une valeur signée."

#: ../Doc/library/stdtypes.rst:1492
msgid "``'+'``"
msgstr "``'+'``"

#: ../Doc/library/stdtypes.rst:1492
msgid ""
"A sign character (``'+'`` or ``'-'``) will precede the conversion (overrides "
"a \"space\" flag)."
msgstr ""
"Un caractère de signe (``'+'`` ou ``'-'``) précède la valeur convertie "
"(remplace le marqueur \"espace\")."

#: ../Doc/library/stdtypes.rst:1496
msgid ""
"A length modifier (``h``, ``l``, or ``L``) may be present, but is ignored as "
"it is not necessary for Python -- so e.g. ``%ld`` is identical to ``%d``."
msgstr ""
"Un modificateur de longueur (``h``, ``l`` ou ``L``) peut être présent, mais "
"est ignoré car il est pas nécessaire pour Python, donc par exemple ``%ld`` "
"est identique à ``%d``."

#: ../Doc/library/stdtypes.rst:1499
msgid "The conversion types are:"
msgstr "Les types utilisables dans les conversion sont :"

#: ../Doc/library/stdtypes.rst:1502
msgid "Conversion"
msgstr "Conversion"

#: ../Doc/library/stdtypes.rst:1504
msgid "``'d'``"
msgstr "``'d'``"

#: ../Doc/library/stdtypes.rst:1504 ../Doc/library/stdtypes.rst:1506
msgid "Signed integer decimal."
msgstr "Entier décimal signé."

#: ../Doc/library/stdtypes.rst:1506
msgid "``'i'``"
msgstr "``'i'``"

#: ../Doc/library/stdtypes.rst:1508
msgid "``'o'``"
msgstr "``'o'``"

#: ../Doc/library/stdtypes.rst:1508
msgid "Signed octal value."
msgstr "Valeur octale signée."

#: ../Doc/library/stdtypes.rst:1510
msgid "``'u'``"
msgstr "``'u'``"

#: ../Doc/library/stdtypes.rst:1510
msgid "Obsolete type -- it is identical to ``'d'``."
msgstr "Type obsolète --- identique à ``'d'``."

#: ../Doc/library/stdtypes.rst:1512
msgid "``'x'``"
msgstr "``'x'``"

#: ../Doc/library/stdtypes.rst:1512
msgid "Signed hexadecimal (lowercase)."
msgstr "Hexadécimal signé (en minuscules)."

#: ../Doc/library/stdtypes.rst:1514
msgid "``'X'``"
msgstr "``'X'``"

#: ../Doc/library/stdtypes.rst:1514
msgid "Signed hexadecimal (uppercase)."
msgstr "Hexadécimal signé (capitales)."

#: ../Doc/library/stdtypes.rst:1516
msgid "``'e'``"
msgstr "``'e'``"

#: ../Doc/library/stdtypes.rst:1516
msgid "Floating point exponential format (lowercase)."
msgstr "Format exponentiel pour un *float* (minuscule)."

#: ../Doc/library/stdtypes.rst:1518
msgid "``'E'``"
msgstr "``'E'``"

#: ../Doc/library/stdtypes.rst:1518
msgid "Floating point exponential format (uppercase)."
msgstr "Format exponentiel pour un *float* (en capitales)."

#: ../Doc/library/stdtypes.rst:1520
msgid "``'f'``"
msgstr "``'f'``"

#: ../Doc/library/stdtypes.rst:1520 ../Doc/library/stdtypes.rst:1522
msgid "Floating point decimal format."
msgstr "Format décimal pour un *float*."

#: ../Doc/library/stdtypes.rst:1522
msgid "``'F'``"
msgstr "``'F'``"

#: ../Doc/library/stdtypes.rst:1524
msgid "``'g'``"
msgstr "``'g'``"

#: ../Doc/library/stdtypes.rst:1524
msgid ""
"Floating point format. Uses lowercase exponential format if exponent is less "
"than -4 or not less than precision, decimal format otherwise."
msgstr ""
"Format *float*. Utilise le format exponentiel minuscules si l'exposant est "
"inférieur à ``-4`` ou pas plus petit que la précision, sinon le format "
"décimal."

#: ../Doc/library/stdtypes.rst:1528
msgid "``'G'``"
msgstr "``'G'``"

#: ../Doc/library/stdtypes.rst:1528
msgid ""
"Floating point format. Uses uppercase exponential format if exponent is less "
"than -4 or not less than precision, decimal format otherwise."
msgstr ""
"Format *float*. Utilise le format exponentiel en capitales si l'exposant est "
"inférieur à ``-4`` ou pas plus petit que la précision, sinon le format "
"décimal."

#: ../Doc/library/stdtypes.rst:1532
msgid "``'c'``"
msgstr "``'c'``"

#: ../Doc/library/stdtypes.rst:1532
msgid "Single character (accepts integer or single character string)."
msgstr ""
"Un seul caractère (accepte des entiers ou une chaîne d'un seul caractère)."

#: ../Doc/library/stdtypes.rst:1535
msgid "``'r'``"
msgstr "``'r'``"

#: ../Doc/library/stdtypes.rst:1535
msgid "String (converts any Python object using :ref:`repr() <func-repr>`)."
msgstr ""

#: ../Doc/library/stdtypes.rst:1535 ../Doc/library/stdtypes.rst:1686
msgid "\\(5)"
msgstr "\\(5)"

#: ../Doc/library/stdtypes.rst:1538
msgid "``'s'``"
msgstr "``'s'``"

#: ../Doc/library/stdtypes.rst:1538
msgid "String (converts any Python object using :func:`str`)."
msgstr "String (convertit n'importe quel objet Python avec :func:`str`)."

#: ../Doc/library/stdtypes.rst:1541
msgid "``'%'``"
msgstr "``'%'``"

#: ../Doc/library/stdtypes.rst:1541
msgid "No argument is converted, results in a ``'%'`` character in the result."
msgstr ""
"Aucun argument n'est converti, donne un caractère de ``'%'`` dans le "
"résultat."

#: ../Doc/library/stdtypes.rst:1548
msgid ""
"The alternate form causes a leading zero (``'0'``) to be inserted between "
"left-hand padding and the formatting of the number if the leading character "
"of the result is not already a zero."
msgstr ""
"La forme alternative insère un zéro (``'0'``) entre le rembourrage gauche et "
"le formatage du nombre si son premier caractère n'est pas déjà un zéro."

#: ../Doc/library/stdtypes.rst:1553
msgid ""
"The alternate form causes a leading ``'0x'`` or ``'0X'`` (depending on "
"whether the ``'x'`` or ``'X'`` format was used) to be inserted between left-"
"hand padding and the formatting of the number if the leading character of "
"the result is not already a zero."
msgstr ""
"La forme alternative insère ``'0x'`` ou ``'0X'`` (respectivement pour les "
"formats ``'x'`` et ``'X'``) entre le rembourrage de gauche et nombre "
"formaté, si le premier caractère n'est pas déjà un zéro."

#: ../Doc/library/stdtypes.rst:1559
msgid ""
"The alternate form causes the result to always contain a decimal point, even "
"if no digits follow it."
msgstr ""
"La forme alternative implique la présence d'un point décimal, même si aucun "
"chiffre ne le suit."

#: ../Doc/library/stdtypes.rst:1562
msgid ""
"The precision determines the number of digits after the decimal point and "
"defaults to 6."
msgstr ""
"La précision détermine le nombre de chiffres après la virgule, 6 par défaut."

#: ../Doc/library/stdtypes.rst:1566
msgid ""
"The alternate form causes the result to always contain a decimal point, and "
"trailing zeroes are not removed as they would otherwise be."
msgstr ""
"La forme alternative implique la présence d'un point décimal et les zéros "
"non significatifs sont conservés (ils ne le seraient pas autrement)."

#: ../Doc/library/stdtypes.rst:1569
msgid ""
"The precision determines the number of significant digits before and after "
"the decimal point and defaults to 6."
msgstr ""
"La précision détermine le nombre de chiffres significatifs avant et après la "
"virgule. 6 par défaut."

#: ../Doc/library/stdtypes.rst:1573
msgid "The ``%r`` conversion was added in Python 2.0."
msgstr ""

#: ../Doc/library/stdtypes.rst:1575 ../Doc/library/stdtypes.rst:1581
msgid "The precision determines the maximal number of characters used."
msgstr ""

#: ../Doc/library/stdtypes.rst:1578
msgid ""
"If the object or format provided is a :class:`unicode` string, the resulting "
"string will also be :class:`unicode`."
msgstr ""

#: ../Doc/library/stdtypes.rst:1584
msgid "See :pep:`237`."
msgstr "Voir la :pep:`237`."

#: ../Doc/library/stdtypes.rst:1586
msgid ""
"Since Python strings have an explicit length, ``%s`` conversions do not "
"assume that ``'\\0'`` is the end of the string."
msgstr ""
"Puisque les chaînes Python ont une longueur explicite, les conversions ``"
"%s`` ne considèrent pas ``'\\0'`` comme la fin de la chaîne."

#: ../Doc/library/stdtypes.rst:1591
msgid ""
"``%f`` conversions for numbers whose absolute value is over 1e50 are no "
"longer replaced by ``%g`` conversions."
msgstr ""
"Les conversions ``%f`` pour nombres dont la valeur absolue est supérieure à "
"``1e50`` ne sont plus remplacés par des conversions ``%g``."

#: ../Doc/library/stdtypes.rst:1599
msgid ""
"Additional string operations are defined in standard modules :mod:`string` "
"and :mod:`re`."
msgstr ""

#: ../Doc/library/stdtypes.rst:1606
msgid "XRange Type"
msgstr ""

#: ../Doc/library/stdtypes.rst:1610
msgid ""
"The :class:`xrange` type is an immutable sequence which is commonly used for "
"looping.  The advantage of the :class:`xrange` type is that an :class:"
"`xrange` object will always take the same amount of memory, no matter the "
"size of the range it represents.  There are no consistent performance "
"advantages."
msgstr ""

#: ../Doc/library/stdtypes.rst:1615
msgid ""
"XRange objects have very little behavior: they only support indexing, "
"iteration, and the :func:`len` function."
msgstr ""

#: ../Doc/library/stdtypes.rst:1622
msgid "Mutable Sequence Types"
msgstr "Types de séquences muables"

#: ../Doc/library/stdtypes.rst:1628
msgid ""
"List and :class:`bytearray` objects support additional operations that allow "
"in-place modification of the object. Other mutable sequence types (when "
"added to the language) should also support these operations. Strings and "
"tuples are immutable sequence types: such objects cannot be modified once "
"created. The following operations are defined on mutable sequence types "
"(where *x* is an arbitrary object):"
msgstr ""

#: ../Doc/library/stdtypes.rst:1655
msgid "``s[i] = x``"
msgstr "``s[i] = x``"

#: ../Doc/library/stdtypes.rst:1655
msgid "item *i* of *s* is replaced by *x*"
msgstr "élément *i* de *s* est remplacé par *x*"

#: ../Doc/library/stdtypes.rst:1658
msgid "``s[i:j] = t``"
msgstr "``s[i:j] = t``"

#: ../Doc/library/stdtypes.rst:1658
msgid ""
"slice of *s* from *i* to *j* is replaced by the contents of the iterable *t*"
msgstr ""
"tranche de *s* de *i* à *j* est remplacée par le contenu de l'itérable *t*"

#: ../Doc/library/stdtypes.rst:1662
msgid "``del s[i:j]``"
msgstr "``del s[i:j]``"

#: ../Doc/library/stdtypes.rst:1662
msgid "same as ``s[i:j] = []``"
msgstr "identique à ``s[i:j] = []``"

#: ../Doc/library/stdtypes.rst:1664
msgid "``s[i:j:k] = t``"
msgstr "``s[i:j:k] = t``"

#: ../Doc/library/stdtypes.rst:1664
msgid "the elements of ``s[i:j:k]`` are replaced by those of *t*"
msgstr "les éléments de ``s[i:j:k]`` sont remplacés par ceux de *t*"

#: ../Doc/library/stdtypes.rst:1667
msgid "``del s[i:j:k]``"
msgstr "``del s[i:j:k]``"

#: ../Doc/library/stdtypes.rst:1667
msgid "removes the elements of ``s[i:j:k]`` from the list"
msgstr "supprime les éléments de ``s[i:j:k]`` de la liste"

#: ../Doc/library/stdtypes.rst:1670
msgid "``s.append(x)``"
msgstr "``s.append(x)``"

#: ../Doc/library/stdtypes.rst:1670
msgid "same as ``s[len(s):len(s)] = [x]``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1673
msgid "``s.extend(t)`` or ``s += t``"
msgstr "``s.extend(t)`` or ``s += t``"

#: ../Doc/library/stdtypes.rst:1673
msgid "for the most part the same as ``s[len(s):len(s)] = t``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1676
msgid "``s *= n``"
msgstr "``s *= n``"

#: ../Doc/library/stdtypes.rst:1676
msgid "updates *s* with its contents repeated *n* times"
msgstr "met à jour *s* avec son contenu répété *n* fois"

#: ../Doc/library/stdtypes.rst:1676
msgid "\\(11)"
msgstr ""

#: ../Doc/library/stdtypes.rst:1679
msgid "return number of *i*'s for which ``s[i] == x``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1682
msgid "``s.index(x[, i[, j]])``"
msgstr "``s.index(x[, i[, j]])``"

#: ../Doc/library/stdtypes.rst:1682
msgid "return smallest *k* such that ``s[k] == x`` and ``i <= k < j``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1686
msgid "``s.insert(i, x)``"
msgstr "``s.insert(i, x)``"

#: ../Doc/library/stdtypes.rst:1686
msgid "same as ``s[i:i] = [x]``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1688
msgid "``s.pop([i])``"
msgstr "``s.pop([i])``"

#: ../Doc/library/stdtypes.rst:1688
msgid "same as ``x = s[i]; del s[i]; return x``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1691
msgid "``s.remove(x)``"
msgstr "``s.remove(x)``"

#: ../Doc/library/stdtypes.rst:1691
msgid "same as ``del s[s.index(x)]``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1693
msgid "``s.reverse()``"
msgstr "``s.reverse()``"

#: ../Doc/library/stdtypes.rst:1693
msgid "reverses the items of *s* in place"
msgstr "inverse sur place les éléments de *s*"

#: ../Doc/library/stdtypes.rst:1696
msgid "``s.sort([cmp[, key[, reverse]]])``"
msgstr ""

#: ../Doc/library/stdtypes.rst:1696
msgid "sort the items of *s* in place"
msgstr ""

#: ../Doc/library/stdtypes.rst:1696
msgid "(7)(8)(9)(10)"
msgstr ""

#: ../Doc/library/stdtypes.rst:1703
msgid "*t* must have the same length as the slice it is  replacing."
msgstr ""

#: ../Doc/library/stdtypes.rst:1706
msgid ""
"The C implementation of Python has historically accepted multiple parameters "
"and implicitly joined them into a tuple; this no longer works in Python "
"2.0.  Use of this misfeature has been deprecated since Python 1.4."
msgstr ""

#: ../Doc/library/stdtypes.rst:1711
msgid "*t* can be any iterable object."
msgstr ""

#: ../Doc/library/stdtypes.rst:1714
msgid ""
"Raises :exc:`ValueError` when *x* is not found in *s*. When a negative index "
"is passed as the second or third parameter to the :meth:`index` method, the "
"list length is added, as for slice indices.  If it is still negative, it is "
"truncated to zero, as for slice indices."
msgstr ""

#: ../Doc/library/stdtypes.rst:1719
msgid ""
"Previously, :meth:`index` didn't have arguments for specifying start and "
"stop positions."
msgstr ""

#: ../Doc/library/stdtypes.rst:1724
msgid ""
"When a negative index is passed as the first parameter to the :meth:`insert` "
"method, the list length is added, as for slice indices.  If it is still "
"negative, it is truncated to zero, as for slice indices."
msgstr ""

#: ../Doc/library/stdtypes.rst:1728
msgid "Previously, all negative indices were truncated to zero."
msgstr ""

#: ../Doc/library/stdtypes.rst:1732
msgid ""
"The :meth:`pop` method's optional argument *i* defaults to ``-1``, so that "
"by default the last item is removed and returned."
msgstr ""

#: ../Doc/library/stdtypes.rst:1736
msgid ""
"The :meth:`sort` and :meth:`reverse` methods modify the list in place for "
"economy of space when sorting or reversing a large list.  To remind you that "
"they operate by side effect, they don't return the sorted or reversed list."
msgstr ""

#: ../Doc/library/stdtypes.rst:1741
msgid ""
"The :meth:`sort` method takes optional arguments for controlling the "
"comparisons."
msgstr ""

#: ../Doc/library/stdtypes.rst:1744
msgid ""
"*cmp* specifies a custom comparison function of two arguments (list items) "
"which should return a negative, zero or positive number depending on whether "
"the first argument is considered smaller than, equal to, or larger than the "
"second argument: ``cmp=lambda x,y: cmp(x.lower(), y.lower())``.  The default "
"value is ``None``."
msgstr ""

#: ../Doc/library/stdtypes.rst:1750
msgid ""
"*key* specifies a function of one argument that is used to extract a "
"comparison key from each list element: ``key=str.lower``.  The default value "
"is ``None``."
msgstr ""

#: ../Doc/library/stdtypes.rst:1753
msgid ""
"*reverse* is a boolean value.  If set to ``True``, then the list elements "
"are sorted as if each comparison were reversed."
msgstr ""
"*reverse*, une valeur booléenne. Si elle est ``True``, la liste d'éléments "
"est triée comme si toutes les comparaisons étaient inversées."

#: ../Doc/library/stdtypes.rst:1756
msgid ""
"In general, the *key* and *reverse* conversion processes are much faster "
"than specifying an equivalent *cmp* function.  This is because *cmp* is "
"called multiple times for each list element while *key* and *reverse* touch "
"each element only once.  Use :func:`functools.cmp_to_key` to convert an old-"
"style *cmp* function to a *key* function."
msgstr ""

#: ../Doc/library/stdtypes.rst:1762
msgid "Support for ``None`` as an equivalent to omitting *cmp* was added."
msgstr ""

#: ../Doc/library/stdtypes.rst:1765
msgid "Support for *key* and *reverse* was added."
msgstr ""

#: ../Doc/library/stdtypes.rst:1769
msgid ""
"Starting with Python 2.3, the :meth:`sort` method is guaranteed to be "
"stable.  A sort is stable if it guarantees not to change the relative order "
"of elements that compare equal --- this is helpful for sorting in multiple "
"passes (for example, sort by department, then by salary grade)."
msgstr ""

#: ../Doc/library/stdtypes.rst:1777
msgid ""
"While a list is being sorted, the effect of attempting to mutate, or even "
"inspect, the list is undefined.  The C implementation of Python 2.3 and "
"newer makes the list appear empty for the duration, and raises :exc:"
"`ValueError` if it can detect that the list has been mutated during a sort."
msgstr ""

#: ../Doc/library/stdtypes.rst:1784
msgid ""
"The value *n* is an integer, or an object implementing :meth:`~object."
"__index__`.  Zero and negative values of *n* clear the sequence.  Items in "
"the sequence are not copied; they are referenced multiple times, as "
"explained for ``s * n`` under :ref:`typesseq`."
msgstr ""

#: ../Doc/library/stdtypes.rst:1793
msgid "Set Types --- :class:`set`, :class:`frozenset`"
msgstr "Types d'ensembles --- :class:`set`, :class:`frozenset`"

#: ../Doc/library/stdtypes.rst:1797
msgid ""
"A :dfn:`set` object is an unordered collection of distinct :term:`hashable` "
"objects. Common uses include membership testing, removing duplicates from a "
"sequence, and computing mathematical operations such as intersection, union, "
"difference, and symmetric difference. (For other containers see the built "
"in :class:`dict`, :class:`list`, and :class:`tuple` classes, and the :mod:"
"`collections` module.)"
msgstr ""

#: ../Doc/library/stdtypes.rst:1807
msgid ""
"Like other collections, sets support ``x in set``, ``len(set)``, and ``for x "
"in set``.  Being an unordered collection, sets do not record element "
"position or order of insertion.  Accordingly, sets do not support indexing, "
"slicing, or other sequence-like behavior."
msgstr ""
"Comme pour les autres collections, les ensembles supportent ``x in set``, "
"``len(set)``, et ``for x in set``. En tant que collection non-triée, les "
"ensembles n'enregistrent pas la position des éléments ou leur ordre "
"d'insertion.  En conséquence, les *sets* n'autorisent ni l'indexation, ni le "
"découpage, ou tout autre comportement de séquence."

#: ../Doc/library/stdtypes.rst:1812
msgid ""
"There are currently two built-in set types, :class:`set` and :class:"
"`frozenset`. The :class:`set` type is mutable --- the contents can be "
"changed using methods like :meth:`~set.add` and :meth:`~set.remove`.  Since "
"it is mutable, it has no hash value and cannot be used as either a "
"dictionary key or as an element of another set.  The :class:`frozenset` type "
"is immutable and :term:`hashable` --- its contents cannot be altered after "
"it is created; it can therefore be used as a dictionary key or as an element "
"of another set."
msgstr ""
"Il existe actuellement deux types natifs pour les ensembles, :class:`set` "
"et :class:`fronzenset`. Le type :class:`set` est muable --- son contenu peut "
"changer en utilisant des méthodes comme :meth:`~set.add` et :meth:`~set."
"remove`. Puisqu'il est muable, il n'a pas de valeur de hachage et ne peut "
"donc pas être utilisé ni comme clef de dictionnaire ni comme élément d'un "
"autre ensemble. Le type :class:`frozenset` est immuable et :term:`hashable` "
"--- son contenu ne peut être modifié après sa création, il peut ainsi être "
"utilisé comme clef de dictionnaire ou élément d'un autre *set*."

#: ../Doc/library/stdtypes.rst:1820
msgid ""
"As of Python 2.7, non-empty sets (not frozensets) can be created by placing "
"a comma-separated list of elements within braces, for example: ``{'jack', "
"'sjoerd'}``, in addition to the :class:`set` constructor."
msgstr ""

#: ../Doc/library/stdtypes.rst:1824
msgid "The constructors for both classes work the same:"
msgstr "Les constructeurs des deux classes fonctionnent pareil :"

#: ../Doc/library/stdtypes.rst:1829
msgid ""
"Return a new set or frozenset object whose elements are taken from "
"*iterable*.  The elements of a set must be :term:`hashable`.  To represent "
"sets of sets, the inner sets must be :class:`frozenset` objects.  If "
"*iterable* is not specified, a new empty set is returned."
msgstr ""
"Renvoie un nouveau *set* ou *frozenset* dont les éléments viennent "
"d'*iterable*.  Les éléments d'un *set* doivent être :term:`hashable`.  Pour "
"représenter des *sets* de *sets* les *sets* intérieurs doivent être des :"
"class:`frozenset`.  Si *iterable* n'est pas spécifié, un nouveau *set* vide "
"est renvoyé."

#: ../Doc/library/stdtypes.rst:1835
msgid ""
"Instances of :class:`set` and :class:`frozenset` provide the following "
"operations:"
msgstr ""
"Les instances de :class:`set` et :class:`frozenset` fournissent les "
"opérations suivantes :"

#: ../Doc/library/stdtypes.rst:1840
msgid "Return the number of elements in set *s* (cardinality of *s*)."
msgstr "Donne le nombre d'éléments dans le *set* *s* (cardinalité de *s*)."

#: ../Doc/library/stdtypes.rst:1844
msgid "Test *x* for membership in *s*."
msgstr "Test d'appartenance de *x* dans *s*."

#: ../Doc/library/stdtypes.rst:1848
msgid "Test *x* for non-membership in *s*."
msgstr "Test de non-appartenance de *x* dans *s*."

#: ../Doc/library/stdtypes.rst:1852
msgid ""
"Return ``True`` if the set has no elements in common with *other*.  Sets are "
"disjoint if and only if their intersection is the empty set."
msgstr ""
"Renvoie ``True`` si l'ensemble n'a aucun élément en commun avec *other*.  "
"Les ensembles sont disjoints si et seulement si leurs intersection est un "
"ensemble vide."

#: ../Doc/library/stdtypes.rst:1860
msgid "Test whether every element in the set is in *other*."
msgstr "Teste si tous les éléments du set sont dans *other*."

#: ../Doc/library/stdtypes.rst:1864
msgid ""
"Test whether the set is a proper subset of *other*, that is, ``set <= other "
"and set != other``."
msgstr ""
"Teste si l'ensemble est un sous-ensemble de *other*, c'est-à-dire, ``set <= "
"other and set != other``."

#: ../Doc/library/stdtypes.rst:1870
msgid "Test whether every element in *other* is in the set."
msgstr "Teste si tous les éléments de *other* sont dans l'ensemble."

#: ../Doc/library/stdtypes.rst:1874
msgid ""
"Test whether the set is a proper superset of *other*, that is, ``set >= "
"other and set != other``."
msgstr ""
"Teste si l'ensemble est un sur-ensemble de *other*, c'est-à-dire, ``set >= "
"other and set != other``."

#: ../Doc/library/stdtypes.rst:1880
msgid "Return a new set with elements from the set and all others."
msgstr ""
"Renvoie un nouvel ensemble dont les éléments viennent de l'ensemble et de "
"tous les autres."

#: ../Doc/library/stdtypes.rst:1882 ../Doc/library/stdtypes.rst:1890
#: ../Doc/library/stdtypes.rst:1898 ../Doc/library/stdtypes.rst:1952
#: ../Doc/library/stdtypes.rst:1960 ../Doc/library/stdtypes.rst:1968
msgid "Accepts multiple input iterables."
msgstr ""

#: ../Doc/library/stdtypes.rst:1888
msgid "Return a new set with elements common to the set and all others."
msgstr ""
"Renvoie un nouvel ensemble dont les éléments sont commun à l'ensemble et à "
"tous les autres."

#: ../Doc/library/stdtypes.rst:1896
msgid "Return a new set with elements in the set that are not in the others."
msgstr ""
"Renvoie un nouvel ensemble dont les éléments sont dans l'ensemble mais ne "
"sont dans aucun des autres."

#: ../Doc/library/stdtypes.rst:1904
msgid ""
"Return a new set with elements in either the set or *other* but not both."
msgstr ""
"Renvoie un nouvel ensemble dont les éléments sont soit dans l'ensemble, soit "
"dans les autres, mais pas dans les deux."

#: ../Doc/library/stdtypes.rst:1908
msgid "Return a new set with a shallow copy of *s*."
msgstr "Renvoie un nouvel ensemble, copie de surface de *s*."

#: ../Doc/library/stdtypes.rst:1911
msgid ""
"Note, the non-operator versions of :meth:`union`, :meth:`intersection`, :"
"meth:`difference`, and :meth:`symmetric_difference`, :meth:`issubset`, and :"
"meth:`issuperset` methods will accept any iterable as an argument.  In "
"contrast, their operator based counterparts require their arguments to be "
"sets.  This precludes error-prone constructions like ``set('abc') & 'cbs'`` "
"in favor of the more readable ``set('abc').intersection('cbs')``."
msgstr ""
"Remarque : Les méthodes  :meth:`union`, :meth:`intersection`, :meth:"
"`difference`, et :meth:`symmetric_difference`, :meth:`issubset`, et :meth:"
"`issuperset`acceptent n'importe quel itérable comme argument, contrairement "
"aux opérateurs équivalents qui n'acceptent que des *sets*. Il est donc "
"préférable d'éviter les constructions comme ``set('abc') & 'cbs'``, sources "
"typiques d'erreurs, en faveur d'une construction plus lisible : ``set('abc')."
"intersection('cbs')``."

#: ../Doc/library/stdtypes.rst:1918
msgid ""
"Both :class:`set` and :class:`frozenset` support set to set comparisons. Two "
"sets are equal if and only if every element of each set is contained in the "
"other (each is a subset of the other). A set is less than another set if and "
"only if the first set is a proper subset of the second set (is a subset, but "
"is not equal). A set is greater than another set if and only if the first "
"set is a proper superset of the second set (is a superset, but is not equal)."
msgstr ""
"Les classes :class:`set` et :class:`frozenset` supportent les comparaisons "
"d'ensemble à ensemble. Deux ensembles sont égaux si et seulement si chaque "
"éléments de chaque ensemble est contenu dans l'autre (autrement dit que "
"chaque ensemble est un sous-ensemble de l'autre). Un ensemble est plus petit "
"qu'un autre ensemble si et seulement si le premier est un sous-ensemble du "
"second (un sous-ensemble, mais pas égal). Un ensemble est plus grand qu'un "
"autre ensemble si et seulement si le premier est un sur-ensemble du second "
"(est un sur-ensemble mais n'est pas égal)."

#: ../Doc/library/stdtypes.rst:1925
msgid ""
"Instances of :class:`set` are compared to instances of :class:`frozenset` "
"based on their members.  For example, ``set('abc') == frozenset('abc')`` "
"returns ``True`` and so does ``set('abc') in set([frozenset('abc')])``."
msgstr ""
"Les instances de :class:`set` se comparent aux instances de :class:"
"`frozenset` en fonction de leurs membres.  Par exemple, ``set('abc') == "
"frozenset('abc')`` envoie ``True``, ainsi que ``set('abc') in "
"set([frozenset('abc')])``."

#: ../Doc/library/stdtypes.rst:1929
msgid ""
"The subset and equality comparisons do not generalize to a total ordering "
"function.  For example, any two non-empty disjoint sets are not equal and "
"are not subsets of each other, so *all* of the following return ``False``: "
"``a<b``, ``a==b``, or ``a>b``. Accordingly, sets do not implement the :meth:"
"`__cmp__` method."
msgstr ""

#: ../Doc/library/stdtypes.rst:1935
msgid ""
"Since sets only define partial ordering (subset relationships), the output "
"of the :meth:`list.sort` method is undefined for lists of sets."
msgstr ""
"Puisque les *sets* ne définissent qu'un ordre partiel (par leurs relations "
"de sous-ensembles), la sortie de la méthode :meth:`list.sort` n'est pas "
"définie pour des listes d'ensembles."

#: ../Doc/library/stdtypes.rst:1938
msgid "Set elements, like dictionary keys, must be :term:`hashable`."
msgstr ""
"Les éléments des *sets*, comme les clefs de dictionnaires, doivent être :"
"term:`hashable`."

#: ../Doc/library/stdtypes.rst:1940
msgid ""
"Binary operations that mix :class:`set` instances with :class:`frozenset` "
"return the type of the first operand.  For example: ``frozenset('ab') | "
"set('bc')`` returns an instance of :class:`frozenset`."
msgstr ""
"Les opérations binaires mélangeant des instances de :class:`set` et :class:"
"`frozenset` renvoient le type de la première opérande.  Par exemple : "
"``frozenset('ab') | set('bc')`` renvoie une instance de :class:`frozenset`."

#: ../Doc/library/stdtypes.rst:1944
msgid ""
"The following table lists operations available for :class:`set` that do not "
"apply to immutable instances of :class:`frozenset`:"
msgstr ""
"La table suivante liste les opérations disponibles pour les :class:`set` "
"mais qui ne s'appliquent pas aux instances de :class:`frozenset` :"

#: ../Doc/library/stdtypes.rst:1950
msgid "Update the set, adding elements from all others."
msgstr "Met à jour l'ensemble, ajoutant les éléments de tous les autres."

#: ../Doc/library/stdtypes.rst:1958
msgid "Update the set, keeping only elements found in it and all others."
msgstr ""
"Met à jour l'ensemble, ne gardant que les éléments trouvés dans tous les "
"autres."

#: ../Doc/library/stdtypes.rst:1966
msgid "Update the set, removing elements found in others."
msgstr "Met à jour l'ensemble, retirant les éléments trouvés dans les autres."

#: ../Doc/library/stdtypes.rst:1974
msgid ""
"Update the set, keeping only elements found in either set, but not in both."
msgstr ""
"Met à jour le set, ne gardant que les éléments trouvés dans un des ensembles "
"mais pas dans les deux."

#: ../Doc/library/stdtypes.rst:1978
msgid "Add element *elem* to the set."
msgstr "Ajoute l'élément *elem* au set."

#: ../Doc/library/stdtypes.rst:1982
msgid ""
"Remove element *elem* from the set.  Raises :exc:`KeyError` if *elem* is not "
"contained in the set."
msgstr ""
"Retire l'élément *elem* de l'ensemble. Lève une exception :exc:`KeyError` si "
"*elem* n'est pas dans l'ensemble."

#: ../Doc/library/stdtypes.rst:1987
msgid "Remove element *elem* from the set if it is present."
msgstr "Retire l'élément *elem* de l'ensemble s'il y est."

#: ../Doc/library/stdtypes.rst:1991
msgid ""
"Remove and return an arbitrary element from the set.  Raises :exc:`KeyError` "
"if the set is empty."
msgstr ""
"Retire et renvoie un élément arbitraire de l'ensemble. Lève une exception :"
"exc:`KeyError` si l'ensemble est vide."

#: ../Doc/library/stdtypes.rst:1996
msgid "Remove all elements from the set."
msgstr "Supprime tous les éléments du *set*."

#: ../Doc/library/stdtypes.rst:1999
msgid ""
"Note, the non-operator versions of the :meth:`update`, :meth:"
"`intersection_update`, :meth:`difference_update`, and :meth:"
"`symmetric_difference_update` methods will accept any iterable as an "
"argument."
msgstr ""
"Notez que les versions non-opérateurs des méthodes :meth:`update`, :meth:"
"`intersection_update`, :meth:`difference_update`, et :meth:"
"`symmetric_difference_update` acceptent n'importe quel itérable comme "
"argument."

#: ../Doc/library/stdtypes.rst:2004
msgid ""
"Note, the *elem* argument to the :meth:`__contains__`, :meth:`remove`, and :"
"meth:`discard` methods may be a set.  To support searching for an equivalent "
"frozenset, the *elem* set is temporarily mutated during the search and then "
"restored.  During the search, the *elem* set should not be read or mutated "
"since it does not have a meaningful value."
msgstr ""

#: ../Doc/library/stdtypes.rst:2013
msgid ":ref:`comparison-to-builtin-set`"
msgstr ""

#: ../Doc/library/stdtypes.rst:2014
msgid "Differences between the :mod:`sets` module and the built-in set types."
msgstr ""

#: ../Doc/library/stdtypes.rst:2020
msgid "Mapping Types --- :class:`dict`"
msgstr "Les types de correspondances --- :class:`dict`"

#: ../Doc/library/stdtypes.rst:2030
msgid ""
"A :term:`mapping` object maps :term:`hashable` values to arbitrary objects. "
"Mappings are mutable objects.  There is currently only one standard mapping "
"type, the :dfn:`dictionary`.  (For other containers see the built in :class:"
"`list`, :class:`set`, and :class:`tuple` classes, and the :mod:`collections` "
"module.)"
msgstr ""

#: ../Doc/library/stdtypes.rst:2036
msgid ""
"A dictionary's keys are *almost* arbitrary values.  Values that are not :"
"term:`hashable`, that is, values containing lists, dictionaries or other "
"mutable types (that are compared by value rather than by object identity) "
"may not be used as keys.  Numeric types used for keys obey the normal rules "
"for numeric comparison: if two numbers compare equal (such as ``1`` and "
"``1.0``) then they can be used interchangeably to index the same dictionary "
"entry.  (Note however, that since computers store floating-point numbers as "
"approximations it is usually unwise to use them as dictionary keys.)"
msgstr ""
"Les clefs d'un dictionnaire sont *presque* des données arbitraires. Les "
"valeurs qui ne sont pas :term:`hashable`, c'est-à-dire qui contiennent les "
"listes, des dictionnaires ou autre type muable (qui sont comparés par valeur "
"plutôt que par leur identité) ne peuvent pas être utilisées comme clef de "
"dictionnaire. Les types numériques utilisés comme clef obéissent aux règles "
"classiques en ce qui concerne les comparaisons : si deux nombres sont égaux "
"(comme ``1`` et ``1.0``) ils peuvent tous les deux être utilisés pour "
"obtenir la même entrée d'un dictionnaire.  (Notez cependant que puisque les "
"ordinateurs stockent les nombres à virgule flottante sous forme "
"d'approximations, il est généralement imprudent de les utiliser comme clefs "
"de dictionnaires.)"

#: ../Doc/library/stdtypes.rst:2045
msgid ""
"Dictionaries can be created by placing a comma-separated list of ``key: "
"value`` pairs within braces, for example: ``{'jack': 4098, 'sjoerd': 4127}`` "
"or ``{4098: 'jack', 4127: 'sjoerd'}``, or by the :class:`dict` constructor."
msgstr ""
"Il est possible de créer des dictionnaires en plaçant entre accolades une "
"liste de paires de ``key: value`` séparés par des virgules, par exemple: "
"``{'jack': 4098, 'sjoerd': 4127}`` ou ``{4098: 'jack', 4127: 'sjoerd'}``, ou "
"en utilisant le constructeur de :class:`dict`."

#: ../Doc/library/stdtypes.rst:2053
msgid ""
"Return a new dictionary initialized from an optional positional argument and "
"a possibly empty set of keyword arguments."
msgstr ""
"Renvoie un nouveau dictionnaire initialisé depuis un argument positionnel "
"optionnel, et un ensemble (vide ou non) d'arguments par mot clef."

#: ../Doc/library/stdtypes.rst:2056
msgid ""
"If no positional argument is given, an empty dictionary is created. If a "
"positional argument is given and it is a mapping object, a dictionary is "
"created with the same key-value pairs as the mapping object.  Otherwise, the "
"positional argument must be an :term:`iterable` object.  Each item in the "
"iterable must itself be an iterable with exactly two objects.  The first "
"object of each item becomes a key in the new dictionary, and the second "
"object the corresponding value.  If a key occurs more than once, the last "
"value for that key becomes the corresponding value in the new dictionary."
msgstr ""
"Si aucun argument positionnel n'est donné, un dictionnaire vide est crée. Si "
"un argument positionnel est donné et est un *mapping object*, un "
"dictionnaire est crée avec les mêmes paires de clef-valeurs que le *mapping* "
"donné. Autrement, l'argument positionnel doit être un objet :term:"
"`iterable`. Chaque élément de cet itérable doit lui même être un itérable "
"contenant exactement deux objets.  Le premier objet de chaque élément "
"devient la une clef du nouveau dictionnaire, et le second devient sa valeur "
"correspondante.  Si une clef apparaît plus d'une fois, la dernière valeur "
"pour cette clef devient la valeur correspondante à cette clef dans le "
"nouveau dictionnaire."

#: ../Doc/library/stdtypes.rst:2066
msgid ""
"If keyword arguments are given, the keyword arguments and their values are "
"added to the dictionary created from the positional argument.  If a key "
"being added is already present, the value from the keyword argument replaces "
"the value from the positional argument."
msgstr ""
"Si des arguments nommés sont donnés, ils sont ajoutés au dictionnaire crée "
"depuis l'argument positionnel.  Si une clef est déjà présente, la valeur de "
"l'argument nommé remplace la valeur reçue par l'argument positionnel."

#: ../Doc/library/stdtypes.rst:2071
msgid ""
"To illustrate, the following examples all return a dictionary equal to "
"``{\"one\": 1, \"two\": 2, \"three\": 3}``::"
msgstr ""
"Typiquement, les exemples suivants renvoient tous un dictionnaire valant "
"``{\"one\": 1, \"two\": 2, \"three\": 3}`` : ::"

#: ../Doc/library/stdtypes.rst:2082
msgid ""
"Providing keyword arguments as in the first example only works for keys that "
"are valid Python identifiers.  Otherwise, any valid keys can be used."
msgstr ""
"Fournir les arguments nommés comme dans le premier exemple en fonctionne que "
"pour des clefs qui sont des identifiants valide en Python.  Dans les autres "
"cas, toutes les clefs valides sont utilisables."

#: ../Doc/library/stdtypes.rst:2087
msgid "Support for building a dictionary from keyword arguments added."
msgstr ""

#: ../Doc/library/stdtypes.rst:2091
msgid ""
"These are the operations that dictionaries support (and therefore, custom "
"mapping types should support too):"
msgstr ""
"Voici les opérations gérées par les dictionnaires, (par conséquent, d'autres "
"types de *mapping* peuvent les gérer aussi) :"

#: ../Doc/library/stdtypes.rst:2096
msgid "Return the number of items in the dictionary *d*."
msgstr "Renvoie le nombre d'éléments dans le dictionnaire *d*."

#: ../Doc/library/stdtypes.rst:2100
msgid ""
"Return the item of *d* with key *key*.  Raises a :exc:`KeyError` if *key* is "
"not in the map."
msgstr ""
"Donne l'élément de *d* dont la clef est *key*. Lève une exception :exc:"
"`KeyError` si *key* n'est pas dans le dictionnaire."

#: ../Doc/library/stdtypes.rst:2105
msgid ""
"If a subclass of dict defines a method :meth:`__missing__` and *key* is not "
"present, the ``d[key]`` operation calls that method with the key *key* as "
"argument.  The ``d[key]`` operation then returns or raises whatever is "
"returned or raised by the ``__missing__(key)`` call. No other operations or "
"methods invoke :meth:`__missing__`. If :meth:`__missing__` is not defined, :"
"exc:`KeyError` is raised. :meth:`__missing__` must be a method; it cannot be "
"an instance variable::"
msgstr ""
"Si une sous-classe de *dict* définit une méthode :meth:`__missing__` et que "
"*key* manque, l'opération ``d[key]`` appelle cette méthode avec la clef "
"*key* en argument. L'opération ``d[key]`` renverra la valeur, ou lèvera "
"l'exception renvoyée ou levée par l'appel à ``__missing__(key)``. Aucune "
"autre opération ni méthode n'appellent :meth:`__missing__`. If :meth:"
"`__missing__` n'est pas définie, une exception :exc:`KeyError` est levée. :"
"meth:`__missing__` doit être une méthode; ça ne peut être une variable "
"d'instance ::"

#: ../Doc/library/stdtypes.rst:2123
msgid ""
"The example above shows part of the implementation of :class:`collections."
"Counter`.  A different ``__missing__`` method is used by :class:`collections."
"defaultdict`."
msgstr ""
"L'exemple ci-dessus montre une partie de l'implémentation de :class:"
"`collections.Counter`.  :class:`collections.defaultdict` implémente aussi "
"``__missing__``."

#: ../Doc/library/stdtypes.rst:2127
msgid "Recognition of __missing__ methods of dict subclasses."
msgstr ""

#: ../Doc/library/stdtypes.rst:2132
msgid "Set ``d[key]`` to *value*."
msgstr "Assigne ``d[key]`` à *value*."

#: ../Doc/library/stdtypes.rst:2136
msgid ""
"Remove ``d[key]`` from *d*.  Raises a :exc:`KeyError` if *key* is not in the "
"map."
msgstr ""
"Supprime ``d[key]`` de *d*.  Lève une exception :exc:`KeyError` si *key* "
"n'est pas dans le dictionnaire."

#: ../Doc/library/stdtypes.rst:2141
msgid "Return ``True`` if *d* has a key *key*, else ``False``."
msgstr "Renvoie ``True`` si *d* a la clef *key*, sinon ``False``."

#: ../Doc/library/stdtypes.rst:2147
msgid "Equivalent to ``not key in d``."
msgstr "Équivalent à ``not key in d``."

#: ../Doc/library/stdtypes.rst:2153
msgid ""
"Return an iterator over the keys of the dictionary.  This is a shortcut for :"
"meth:`iterkeys`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2158
msgid "Remove all items from the dictionary."
msgstr "Supprime tous les éléments du dictionnaire."

#: ../Doc/library/stdtypes.rst:2162
msgid "Return a shallow copy of the dictionary."
msgstr "Renvoie une copie de surface du dictionnaire."

#: ../Doc/library/stdtypes.rst:2166
msgid "Create a new dictionary with keys from *seq* and values set to *value*."
msgstr ""
"Crée un nouveau dictionnaire avec les clefs de *seq* et les valeurs à "
"*value*."

#: ../Doc/library/stdtypes.rst:2168
msgid ""
":func:`fromkeys` is a class method that returns a new dictionary. *value* "
"defaults to ``None``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2175
msgid ""
"Return the value for *key* if *key* is in the dictionary, else *default*. If "
"*default* is not given, it defaults to ``None``, so that this method never "
"raises a :exc:`KeyError`."
msgstr ""
"Renvoie la valeur de *key* si *key* est dans le dictionnaire, sinon "
"*default*. Si *default* n'est pas donné, il vaut ``None`` par défaut, de "
"manière à ce que cette méthode ne lève jamais :exc:`KeyError`."

#: ../Doc/library/stdtypes.rst:2181
msgid ""
"Test for the presence of *key* in the dictionary.  :meth:`has_key` is "
"deprecated in favor of ``key in d``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2186
msgid "Return a copy of the dictionary's list of ``(key, value)`` pairs."
msgstr ""

#: ../Doc/library/stdtypes.rst:2190
msgid ""
"Keys and values are listed in an arbitrary order which is non-random, varies "
"across Python implementations, and depends on the dictionary's history of "
"insertions and deletions."
msgstr ""

#: ../Doc/library/stdtypes.rst:2194
msgid ""
"If :meth:`items`, :meth:`keys`, :meth:`values`, :meth:`iteritems`, :meth:"
"`iterkeys`, and :meth:`itervalues` are called with no intervening "
"modifications to the dictionary, the lists will directly correspond.  This "
"allows the creation of ``(value, key)`` pairs using :func:`zip`: ``pairs = "
"zip(d.values(), d.keys())``.  The same relationship holds for the :meth:"
"`iterkeys` and :meth:`itervalues` methods: ``pairs = zip(d.itervalues(), d."
"iterkeys())`` provides the same value for ``pairs``. Another way to create "
"the same list is ``pairs = [(v, k) for (k, v) in d.iteritems()]``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2206
msgid ""
"Return an iterator over the dictionary's ``(key, value)`` pairs.  See the "
"note for :meth:`dict.items`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2209
msgid ""
"Using :meth:`iteritems` while adding or deleting entries in the dictionary "
"may raise a :exc:`RuntimeError` or fail to iterate over all entries."
msgstr ""

#: ../Doc/library/stdtypes.rst:2216
msgid ""
"Return an iterator over the dictionary's keys.  See the note for :meth:`dict."
"items`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2219
msgid ""
"Using :meth:`iterkeys` while adding or deleting entries in the dictionary "
"may raise a :exc:`RuntimeError` or fail to iterate over all entries."
msgstr ""

#: ../Doc/library/stdtypes.rst:2226
msgid ""
"Return an iterator over the dictionary's values.  See the note for :meth:"
"`dict.items`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2229
msgid ""
"Using :meth:`itervalues` while adding or deleting entries in the dictionary "
"may raise a :exc:`RuntimeError` or fail to iterate over all entries."
msgstr ""

#: ../Doc/library/stdtypes.rst:2237
msgid ""
"Return a copy of the dictionary's list of keys.  See the note for :meth:"
"`dict.items`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2242
msgid ""
"If *key* is in the dictionary, remove it and return its value, else return "
"*default*.  If *default* is not given and *key* is not in the dictionary, a :"
"exc:`KeyError` is raised."
msgstr ""
"Si *key* est dans le dictionnaire elle est supprimée et sa valeur est "
"renvoyée, sinon renvoie *default*.  Si *default* n'est pas donné et que "
"*key* n'est pas dans le dictionnaire, une :exc:`KeyError` est levée."

#: ../Doc/library/stdtypes.rst:2250
msgid ""
"Remove and return an arbitrary ``(key, value)`` pair from the dictionary."
msgstr "Supprime et renvoie une ``(key, value)`` arbitraire du dictionnaire."

#: ../Doc/library/stdtypes.rst:2252
msgid ""
":func:`popitem` is useful to destructively iterate over a dictionary, as "
"often used in set algorithms.  If the dictionary is empty, calling :func:"
"`popitem` raises a :exc:`KeyError`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2258
msgid ""
"If *key* is in the dictionary, return its value.  If not, insert *key* with "
"a value of *default* and return *default*.  *default* defaults to ``None``."
msgstr ""
"Si *key* est dans le dictionnaire, sa valeur est renvoyée. Sinon, insère "
"*key* avec comme valeur *default* et renvoie *default*.  *default* vaut "
"``None`` par défaut."

#: ../Doc/library/stdtypes.rst:2264
msgid ""
"Update the dictionary with the key/value pairs from *other*, overwriting "
"existing keys.  Return ``None``."
msgstr ""
"Met à jour le dictionnaire avec les paires de clef/valeur d'*other*, "
"écrasant les clefs existantes. Renvoie ``None``."

#: ../Doc/library/stdtypes.rst:2267
msgid ""
":func:`update` accepts either another dictionary object or an iterable of "
"key/value pairs (as tuples or other iterables of length two).  If keyword "
"arguments are specified, the dictionary is then updated with those key/value "
"pairs: ``d.update(red=1, blue=2)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2272
msgid ""
"Allowed the argument to be an iterable of key/value pairs and allowed "
"keyword arguments."
msgstr ""

#: ../Doc/library/stdtypes.rst:2278
msgid ""
"Return a copy of the dictionary's list of values.  See the note for :meth:"
"`dict.items`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2283
msgid ""
"Return a new view of the dictionary's items (``(key, value)`` pairs).  See "
"below for documentation of view objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:2290
msgid ""
"Return a new view of the dictionary's keys.  See below for documentation of "
"view objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:2297
msgid ""
"Return a new view of the dictionary's values.  See below for documentation "
"of view objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:2302
msgid ""
"Dictionaries compare equal if and only if they have the same ``(key, "
"value)`` pairs."
msgstr ""

#: ../Doc/library/stdtypes.rst:2309
msgid "Dictionary view objects"
msgstr "Les vues de dictionnaires"

#: ../Doc/library/stdtypes.rst:2311
msgid ""
"The objects returned by :meth:`dict.viewkeys`, :meth:`dict.viewvalues` and :"
"meth:`dict.viewitems` are *view objects*.  They provide a dynamic view on "
"the dictionary's entries, which means that when the dictionary changes, the "
"view reflects these changes."
msgstr ""

#: ../Doc/library/stdtypes.rst:2316
msgid ""
"Dictionary views can be iterated over to yield their respective data, and "
"support membership tests:"
msgstr ""
"Les vues de dictionnaires peuvent être itérées et ainsi renvoyer les données "
"du dictionnaire, elle gèrent aussi les tests de présence :"

#: ../Doc/library/stdtypes.rst:2321
msgid "Return the number of entries in the dictionary."
msgstr "Renvoie le nombre d'entrées du dictionnaire."

#: ../Doc/library/stdtypes.rst:2325
msgid ""
"Return an iterator over the keys, values or items (represented as tuples of "
"``(key, value)``) in the dictionary."
msgstr ""
"Renvoie un itérateur sur les clefs, les valeurs, ou les éléments "
"(représentés par des *tuples* de ``(key, value)`` du dictionnaire."

#: ../Doc/library/stdtypes.rst:2328
msgid ""
"Keys and values are iterated over in an arbitrary order which is non-random, "
"varies across Python implementations, and depends on the dictionary's "
"history of insertions and deletions. If keys, values and items views are "
"iterated over with no intervening modifications to the dictionary, the order "
"of items will directly correspond.  This allows the creation of ``(value, "
"key)`` pairs using :func:`zip`: ``pairs = zip(d.values(), d.keys())``.  "
"Another way to create the same list is ``pairs = [(v, k) for (k, v) in d."
"items()]``."
msgstr ""
"Les clefs et les valeurs sont itérées dans un ordre arbitraire qui n'est pas "
"aléatoire, qui peut varier d'une implémentation de Python à l'autre, et qui "
"dépend de l'historique d'insertion et de suppressions d'éléments. Si les "
"vues de clefs, de valeurs, et d'éléments sont parcourues sans que le "
"dictionnaire ne soit modifié, l'ordre des éléments correspondra "
"directement.  Ceci permet la création de paires de ``(key, value)`` en "
"utilisant :func:`zip` : ``pairs = zip(d.values(), d.keys())``.  Un autre "
"moyen de construire la même liste est  ``pairs = [(v, k) for (k, v) in d."
"items()]``."

#: ../Doc/library/stdtypes.rst:2336
msgid ""
"Iterating views while adding or deleting entries in the dictionary may raise "
"a :exc:`RuntimeError` or fail to iterate over all entries."
msgstr ""
"Parcourir des vues tout en ajoutant ou supprimant des entrées dans un "
"dictionnaire peut lever une :exc:`RuntimeError` ou ne pas fournir toutes les "
"entrées."

#: ../Doc/library/stdtypes.rst:2341
msgid ""
"Return ``True`` if *x* is in the underlying dictionary's keys, values or "
"items (in the latter case, *x* should be a ``(key, value)`` tuple)."
msgstr ""
"Renvoie ``True`` si *x* est dans les clefs, les valeurs, ou les éléments du "
"dictionnaire sous-jacent (dans le dernier cas, *x* doit être un *tuple* "
"``(key, value)``)."

#: ../Doc/library/stdtypes.rst:2345
msgid ""
"Keys views are set-like since their entries are unique and hashable.  If all "
"values are hashable, so that (key, value) pairs are unique and hashable, "
"then the items view is also set-like.  (Values views are not treated as set-"
"like since the entries are generally not unique.)  Then these set operations "
"are available (\"other\" refers either to another view or a set):"
msgstr ""

#: ../Doc/library/stdtypes.rst:2353
msgid ""
"Return the intersection of the dictview and the other object as a new set."
msgstr ""

#: ../Doc/library/stdtypes.rst:2357
msgid "Return the union of the dictview and the other object as a new set."
msgstr ""

#: ../Doc/library/stdtypes.rst:2361
msgid ""
"Return the difference between the dictview and the other object (all "
"elements in *dictview* that aren't in *other*) as a new set."
msgstr ""

#: ../Doc/library/stdtypes.rst:2366
msgid ""
"Return the symmetric difference (all elements either in *dictview* or "
"*other*, but not in both) of the dictview and the other object as a new set."
msgstr ""

#: ../Doc/library/stdtypes.rst:2370
msgid "An example of dictionary view usage::"
msgstr "Exemple d'utilisation de vue de dictionnaire : ::"

#: ../Doc/library/stdtypes.rst:2403
msgid "File Objects"
msgstr "Objets fichiers"

#: ../Doc/library/stdtypes.rst:2411
msgid ""
"File objects are implemented using C's ``stdio`` package and can be created "
"with the built-in :func:`open` function.  File objects are also returned by "
"some other built-in functions and methods, such as :func:`os.popen` and :"
"func:`os.fdopen` and the :meth:`makefile` method of socket objects. "
"Temporary files can be created using the :mod:`tempfile` module, and high-"
"level file operations such as copying, moving, and deleting files and "
"directories can be achieved with the :mod:`shutil` module."
msgstr ""

#: ../Doc/library/stdtypes.rst:2420
msgid ""
"When a file operation fails for an I/O-related reason, the exception :exc:"
"`IOError` is raised.  This includes situations where the operation is not "
"defined for some reason, like :meth:`seek` on a tty device or writing a file "
"opened for reading."
msgstr ""

#: ../Doc/library/stdtypes.rst:2425
msgid "Files have the following methods:"
msgstr ""

#: ../Doc/library/stdtypes.rst:2430
msgid ""
"Close the file.  A closed file cannot be read or written any more. Any "
"operation which requires that the file be open will raise a :exc:"
"`ValueError` after the file has been closed.  Calling :meth:`close` more "
"than once is allowed."
msgstr ""

#: ../Doc/library/stdtypes.rst:2434
msgid ""
"As of Python 2.5, you can avoid having to call this method explicitly if you "
"use the :keyword:`with` statement.  For example, the following code will "
"automatically close *f* when the :keyword:`with` block is exited::"
msgstr ""

#: ../Doc/library/stdtypes.rst:2444
msgid ""
"In older versions of Python, you would have needed to do this to get the "
"same effect::"
msgstr ""

#: ../Doc/library/stdtypes.rst:2456
msgid ""
"Not all \"file-like\" types in Python support use as a context manager for "
"the :keyword:`with` statement.  If your code is intended to work with any "
"file-like object, you can use the function :func:`contextlib.closing` "
"instead of using the object directly."
msgstr ""

#: ../Doc/library/stdtypes.rst:2464
msgid ""
"Flush the internal buffer, like ``stdio``'s :c:func:`fflush`.  This may be a "
"no-op on some file-like objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:2469
msgid ""
":meth:`flush` does not necessarily write the file's data to disk.  Use :meth:"
"`flush` followed by :func:`os.fsync` to ensure this behavior."
msgstr ""

#: ../Doc/library/stdtypes.rst:2479
msgid ""
"Return the integer \"file descriptor\" that is used by the underlying "
"implementation to request I/O operations from the operating system.  This "
"can be useful for other, lower level interfaces that use file descriptors, "
"such as the :mod:`fcntl` module or :func:`os.read` and friends."
msgstr ""

#: ../Doc/library/stdtypes.rst:2486
msgid ""
"File-like objects which do not have a real file descriptor should *not* "
"provide this method!"
msgstr ""

#: ../Doc/library/stdtypes.rst:2492
msgid ""
"Return ``True`` if the file is connected to a tty(-like) device, else "
"``False``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2496
msgid ""
"If a file-like object is not associated with a real file, this method should "
"*not* be implemented."
msgstr ""

#: ../Doc/library/stdtypes.rst:2502
msgid ""
"A file object is its own iterator, for example ``iter(f)`` returns *f* "
"(unless *f* is closed).  When a file is used as an iterator, typically in a :"
"keyword:`for` loop (for example, ``for line in f: print line.strip()``), "
"the :meth:`~file.next` method is called repeatedly.  This method returns the "
"next input line, or raises :exc:`StopIteration` when EOF is hit when the "
"file is open for reading (behavior is undefined when the file is open for "
"writing).  In order to make a :keyword:`for` loop the most efficient way of "
"looping over the lines of a file (a very common operation), the :meth:`~file."
"next` method uses a hidden read-ahead buffer.  As a consequence of using a "
"read-ahead buffer, combining :meth:`~file.next` with other file methods "
"(like :meth:`~file.readline`) does not work right.  However, using :meth:"
"`seek` to reposition the file to an absolute position will flush the read-"
"ahead buffer."
msgstr ""

#: ../Doc/library/stdtypes.rst:2520
msgid ""
"Read at most *size* bytes from the file (less if the read hits EOF before "
"obtaining *size* bytes).  If the *size* argument is negative or omitted, "
"read all data until EOF is reached.  The bytes are returned as a string "
"object.  An empty string is returned when EOF is encountered immediately.  "
"(For certain files, like ttys, it makes sense to continue reading after an "
"EOF is hit.)  Note that this method may call the underlying C function :c:"
"func:`fread` more than once in an effort to acquire as close to *size* bytes "
"as possible. Also note that when in non-blocking mode, less data than was "
"requested may be returned, even if no *size* parameter was given."
msgstr ""

#: ../Doc/library/stdtypes.rst:2531
msgid ""
"This function is simply a wrapper for the underlying :c:func:`fread` C "
"function, and will behave the same in corner cases, such as whether the EOF "
"value is cached."
msgstr ""

#: ../Doc/library/stdtypes.rst:2538
msgid ""
"Read one entire line from the file.  A trailing newline character is kept in "
"the string (but may be absent when a file ends with an incomplete line). "
"[6]_ If the *size* argument is present and non-negative, it is a maximum "
"byte count (including the trailing newline) and an incomplete line may be "
"returned. When *size* is not 0, an empty string is returned *only* when EOF "
"is encountered immediately."
msgstr ""

#: ../Doc/library/stdtypes.rst:2547
msgid ""
"Unlike ``stdio``'s :c:func:`fgets`, the returned string contains null "
"characters (``'\\0'``) if they occurred in the input."
msgstr ""

#: ../Doc/library/stdtypes.rst:2553
msgid ""
"Read until EOF using :meth:`~file.readline` and return a list containing the "
"lines thus read.  If the optional *sizehint* argument is present, instead of "
"reading up to EOF, whole lines totalling approximately *sizehint* bytes "
"(possibly after rounding up to an internal buffer size) are read.  Objects "
"implementing a file-like interface may choose to ignore *sizehint* if it "
"cannot be implemented, or cannot be implemented efficiently."
msgstr ""

#: ../Doc/library/stdtypes.rst:2563
msgid "This method returns the same thing as ``iter(f)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2567
msgid "Use ``for line in file`` instead."
msgstr ""

#: ../Doc/library/stdtypes.rst:2573
msgid ""
"Set the file's current position, like ``stdio``'s :c:func:`fseek`. The "
"*whence* argument is optional and defaults to  ``os.SEEK_SET`` or ``0`` "
"(absolute file positioning); other values are ``os.SEEK_CUR`` or ``1`` (seek "
"relative to the current position) and ``os.SEEK_END`` or ``2``  (seek "
"relative to the file's end).  There is no return value."
msgstr ""

#: ../Doc/library/stdtypes.rst:2579
msgid ""
"For example, ``f.seek(2, os.SEEK_CUR)`` advances the position by two and ``f."
"seek(-3, os.SEEK_END)`` sets the position to the third to last."
msgstr ""

#: ../Doc/library/stdtypes.rst:2582
msgid ""
"Note that if the file is opened for appending (mode ``'a'`` or ``'a+'``), "
"any :meth:`seek` operations will be undone at the next write.  If the file "
"is only opened for writing in append mode (mode ``'a'``), this method is "
"essentially a no-op, but it remains useful for files opened in append mode "
"with reading enabled (mode ``'a+'``).  If the file is opened in text mode "
"(without ``'b'``), only offsets returned by :meth:`tell` are legal.  Use of "
"other offsets causes undefined behavior."
msgstr ""

#: ../Doc/library/stdtypes.rst:2590
msgid "Note that not all file objects are seekable."
msgstr ""

#: ../Doc/library/stdtypes.rst:2592
msgid "Passing float values as offset has been deprecated."
msgstr ""

#: ../Doc/library/stdtypes.rst:2598
msgid "Return the file's current position, like ``stdio``'s :c:func:`ftell`."
msgstr ""

#: ../Doc/library/stdtypes.rst:2602
msgid ""
"On Windows, :meth:`tell` can return illegal values (after an :c:func:"
"`fgets`) when reading files with Unix-style line-endings. Use binary mode "
"(``'rb'``) to circumvent this problem."
msgstr ""

#: ../Doc/library/stdtypes.rst:2609
msgid ""
"Truncate the file's size.  If the optional *size* argument is present, the "
"file is truncated to (at most) that size.  The size defaults to the current "
"position. The current file position is not changed.  Note that if a "
"specified size exceeds the file's current size, the result is platform-"
"dependent:  possibilities include that the file may remain unchanged, "
"increase to the specified size as if zero-filled, or increase to the "
"specified size with undefined new content. Availability:  Windows, many Unix "
"variants."
msgstr ""

#: ../Doc/library/stdtypes.rst:2620
msgid ""
"Write a string to the file.  There is no return value.  Due to buffering, "
"the string may not actually show up in the file until the :meth:`flush` or :"
"meth:`close` method is called."
msgstr ""

#: ../Doc/library/stdtypes.rst:2627
msgid ""
"Write a sequence of strings to the file.  The sequence can be any iterable "
"object producing strings, typically a list of strings. There is no return "
"value. (The name is intended to match :meth:`readlines`; :meth:`writelines` "
"does not add line separators.)"
msgstr ""

#: ../Doc/library/stdtypes.rst:2632
msgid ""
"Files support the iterator protocol.  Each iteration returns the same result "
"as :meth:`~file.readline`, and iteration ends when the :meth:`~file."
"readline` method returns an empty string."
msgstr ""

#: ../Doc/library/stdtypes.rst:2636
msgid ""
"File objects also offer a number of other interesting attributes. These are "
"not required for file-like objects, but should be implemented if they make "
"sense for the particular object."
msgstr ""

#: ../Doc/library/stdtypes.rst:2643
msgid ""
"bool indicating the current state of the file object.  This is a read-only "
"attribute; the :meth:`close` method changes the value. It may not be "
"available on all file-like objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:2650
msgid ""
"The encoding that this file uses. When Unicode strings are written to a "
"file, they will be converted to byte strings using this encoding. In "
"addition, when the file is connected to a terminal, the attribute gives the "
"encoding that the terminal is likely to use (that  information might be "
"incorrect if the user has misconfigured the  terminal). The attribute is "
"read-only and may not be present on all file-like objects. It may also be "
"``None``, in which case the file uses the system default encoding for "
"converting Unicode strings."
msgstr ""

#: ../Doc/library/stdtypes.rst:2663
msgid "The Unicode error handler used along with the encoding."
msgstr ""

#: ../Doc/library/stdtypes.rst:2670
msgid ""
"The I/O mode for the file.  If the file was created using the :func:`open` "
"built-in function, this will be the value of the *mode* parameter.  This is "
"a read-only attribute and may not be present on all file-like objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:2677
msgid ""
"If the file object was created using :func:`open`, the name of the file. "
"Otherwise, some string that indicates the source of the file object, of the "
"form ``<...>``.  This is a read-only attribute and may not be present on all "
"file-like objects."
msgstr ""

#: ../Doc/library/stdtypes.rst:2688
msgid ""
"If Python was built with :term:`universal newlines` enabled (the default) "
"this read-only attribute exists, and for files opened in universal newline "
"read mode it keeps track of the types of newlines encountered while reading "
"the file. The values it can take are ``'\\r'``, ``'\\n'``, ``'\\r\\n'``, "
"``None`` (unknown, no newlines read yet) or a tuple containing all the "
"newline types seen, to indicate that multiple newline conventions were "
"encountered. For files not opened in universal newlines read mode the value "
"of this attribute will be ``None``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2700
msgid ""
"Boolean that indicates whether a space character needs to be printed before "
"another value when using the :keyword:`print` statement. Classes that are "
"trying to simulate a file object should also have a writable :attr:"
"`softspace` attribute, which should be initialized to zero.  This will be "
"automatic for most classes implemented in Python (care may be needed for "
"objects that override attribute access); types implemented in C will have to "
"provide a writable :attr:`softspace` attribute."
msgstr ""

#: ../Doc/library/stdtypes.rst:2710
msgid ""
"This attribute is not used to control the :keyword:`print` statement, but to "
"allow the implementation of :keyword:`print` to keep track of its internal "
"state."
msgstr ""

#: ../Doc/library/stdtypes.rst:2718
msgid "memoryview type"
msgstr ""

#: ../Doc/library/stdtypes.rst:2722
msgid ""
":class:`memoryview` objects allow Python code to access the internal data of "
"an object that supports the buffer protocol without copying.  Memory is "
"generally interpreted as simple bytes."
msgstr ""

#: ../Doc/library/stdtypes.rst:2728
msgid ""
"Create a :class:`memoryview` that references *obj*.  *obj* must support the "
"buffer protocol.  Built-in objects that support the buffer protocol include :"
"class:`str` and :class:`bytearray` (but not :class:`unicode`)."
msgstr ""

#: ../Doc/library/stdtypes.rst:2732
msgid ""
"A :class:`memoryview` has the notion of an *element*, which is the atomic "
"memory unit handled by the originating object *obj*.  For many simple types "
"such as :class:`str` and :class:`bytearray`, an element is a single byte, "
"but other third-party types may expose larger elements."
msgstr ""

#: ../Doc/library/stdtypes.rst:2737
msgid ""
"``len(view)`` returns the total number of elements in the memoryview, "
"*view*.  The :class:`~memoryview.itemsize` attribute will give you the "
"number of bytes in a single element."
msgstr ""

#: ../Doc/library/stdtypes.rst:2741
msgid ""
"A :class:`memoryview` supports slicing to expose its data.  Taking a single "
"index will return a single element as a :class:`str` object.  Full slicing "
"will result in a subview::"
msgstr ""

#: ../Doc/library/stdtypes.rst:2755
msgid ""
"If the object the memoryview is over supports changing its data, the "
"memoryview supports slice assignment::"
msgstr ""

#: ../Doc/library/stdtypes.rst:2773
msgid "Notice how the size of the memoryview object cannot be changed."
msgstr ""

#: ../Doc/library/stdtypes.rst:2775
msgid ":class:`memoryview` has two methods:"
msgstr ""

#: ../Doc/library/stdtypes.rst:2779
msgid ""
"Return the data in the buffer as a bytestring (an object of class :class:"
"`str`). ::"
msgstr ""

#: ../Doc/library/stdtypes.rst:2788
msgid "Return the data in the buffer as a list of integers. ::"
msgstr ""

#: ../Doc/library/stdtypes.rst:2793
msgid "There are also several readonly attributes available:"
msgstr "Plusieurs attributs en lecture seule sont également disponibles :"

#: ../Doc/library/stdtypes.rst:2797
msgid ""
"A string containing the format (in :mod:`struct` module style) for each "
"element in the view.  This defaults to ``'B'``, a simple bytestring."
msgstr ""

#: ../Doc/library/stdtypes.rst:2802
msgid "The size in bytes of each element of the memoryview."
msgstr ""

#: ../Doc/library/stdtypes.rst:2806
msgid ""
"A tuple of integers the length of :attr:`ndim` giving the shape of the "
"memory as an N-dimensional array."
msgstr ""
"Un *tuple* d'entiers de longueur :attr:`ndim` donnant la forme de la "
"*memoryview* sous forme d'un tableau à N dimensions."

#: ../Doc/library/stdtypes.rst:2811
msgid ""
"An integer indicating how many dimensions of a multi-dimensional array the "
"memory represents."
msgstr ""
"Un nombre entier indiquant le nombre de dimensions d'un tableau multi-"
"dimensionnel représenté par la *memoryview*."

#: ../Doc/library/stdtypes.rst:2816
msgid ""
"A tuple of integers the length of :attr:`ndim` giving the size in bytes to "
"access each element for each dimension of the array."
msgstr ""
"Un *tuple* d'entiers de longueur :attr:`ndim` donnant la taille en octets "
"permettant d'accéder à chaque dimensions du tableau."

#: ../Doc/library/stdtypes.rst:2821
msgid "A bool indicating whether the memory is read only."
msgstr "Un booléen indiquant si la mémoire est en lecture seule."

#: ../Doc/library/stdtypes.rst:2829
msgid "Context Manager Types"
msgstr "Le type gestionnaire de contexte"

#: ../Doc/library/stdtypes.rst:2838
msgid ""
"Python's :keyword:`with` statement supports the concept of a runtime context "
"defined by a context manager.  This is implemented using two separate "
"methods that allow user-defined classes to define a runtime context that is "
"entered before the statement body is executed and exited when the statement "
"ends."
msgstr ""

#: ../Doc/library/stdtypes.rst:2843
msgid ""
"The :dfn:`context management protocol` consists of a pair of methods that "
"need to be provided for a context manager object to define a runtime context:"
msgstr ""

#: ../Doc/library/stdtypes.rst:2849
msgid ""
"Enter the runtime context and return either this object or another object "
"related to the runtime context. The value returned by this method is bound "
"to the identifier in the :keyword:`as` clause of :keyword:`with` statements "
"using this context manager."
msgstr ""
"Entre dans le contexte à l'exécution, soit se renvoyant lui-même, soit en "
"renvoyant un autre objet en lien avec ce contexte.  La valeur renvoyée par "
"cette méthode est liée à l'identifiant donné au :keyword:`as` de "
"l'instruction :keyword:`with` utilisant ce gestionnaire de contexte."

#: ../Doc/library/stdtypes.rst:2854
msgid ""
"An example of a context manager that returns itself is a file object. File "
"objects return themselves from __enter__() to allow :func:`open` to be used "
"as the context expression in a :keyword:`with` statement."
msgstr ""

#: ../Doc/library/stdtypes.rst:2858
msgid ""
"An example of a context manager that returns a related object is the one "
"returned by :func:`decimal.localcontext`. These managers set the active "
"decimal context to a copy of the original decimal context and then return "
"the copy. This allows changes to be made to the current decimal context in "
"the body of the :keyword:`with` statement without affecting code outside "
"the :keyword:`with` statement."
msgstr ""
"Un exemple de gestionnaire de contexte renvoyant un objet connexe est celui "
"renvoyé par :func:`decimal.localcontext`. Ces gestionnaires remplacent le "
"contexte décimal courant par une copie de l'original, copie qui est "
"renvoyée. Ça permet de changer le contexte courant dans le corps du :keyword:"
"`with` sans affecter le code en dehors de l'instruction :keyword:`with`."

#: ../Doc/library/stdtypes.rst:2868
msgid ""
"Exit the runtime context and return a Boolean flag indicating if any "
"exception that occurred should be suppressed. If an exception occurred while "
"executing the body of the :keyword:`with` statement, the arguments contain "
"the exception type, value and traceback information. Otherwise, all three "
"arguments are ``None``."
msgstr ""
"Sort du contexte et renvoie un booléen indiquant si une exception survenue "
"doit être supprimée.  Si une exception est survenue lors de l'exécution du "
"corps de l'instruction :keyword:`with`, les arguments contiennent le type de "
"l'exception, sa valeur, et la trace de la pile (*traceback*). Sinon les "
"trois arguments valent ``None``."

#: ../Doc/library/stdtypes.rst:2873
msgid ""
"Returning a true value from this method will cause the :keyword:`with` "
"statement to suppress the exception and continue execution with the "
"statement immediately following the :keyword:`with` statement. Otherwise the "
"exception continues propagating after this method has finished executing. "
"Exceptions that occur during execution of this method will replace any "
"exception that occurred in the body of the :keyword:`with` statement."
msgstr ""
"L'instruction :keyword:`with` inhibera l'exception si cette méthode renvoie "
"une valeur vraie, l'exécution continuera ainsi à l'instruction suivant "
"immédiatement l'instruction :keyword:`with`. Sinon, l'exception continuera "
"de se propager après la fin de cette méthode. Les exceptions se produisant "
"pendant l'exécution de cette méthode remplaceront toute exception qui s'est "
"produite dans le corps du :keyword:`with`."

#: ../Doc/library/stdtypes.rst:2880
msgid ""
"The exception passed in should never be reraised explicitly - instead, this "
"method should return a false value to indicate that the method completed "
"successfully and does not want to suppress the raised exception. This allows "
"context management code (such as ``contextlib.nested``) to easily detect "
"whether or not an :meth:`__exit__` method has actually failed."
msgstr ""

#: ../Doc/library/stdtypes.rst:2886
msgid ""
"Python defines several context managers to support easy thread "
"synchronisation, prompt closure of files or other objects, and simpler "
"manipulation of the active decimal arithmetic context. The specific types "
"are not treated specially beyond their implementation of the context "
"management protocol. See the :mod:`contextlib` module for some examples."
msgstr ""
"Python définit plusieurs gestionnaires de contexte pour faciliter la "
"synchronisation des fils d'exécution, la fermeture des fichiers ou d'autres "
"objets, et la configuration du contexte arithmétique décimal. Ces types "
"spécifiques ne sont pas traités différemment, ils respectent simplement le "
"protocole de gestion du contexte. Voir les exemples dans la documentation du "
"module :mod:`contextlib`."

#: ../Doc/library/stdtypes.rst:2892
msgid ""
"Python's :term:`generator`\\s and the ``contextlib.contextmanager`` :term:"
"`decorator` provide a convenient way to implement these protocols.  If a "
"generator function is decorated with the ``contextlib.contextmanager`` "
"decorator, it will return a context manager implementing the necessary :meth:"
"`__enter__` and :meth:`__exit__` methods, rather than the iterator produced "
"by an undecorated generator function."
msgstr ""

#: ../Doc/library/stdtypes.rst:2899
msgid ""
"Note that there is no specific slot for any of these methods in the type "
"structure for Python objects in the Python/C API. Extension types wanting to "
"define these methods must provide them as a normal Python accessible method. "
"Compared to the overhead of setting up the runtime context, the overhead of "
"a single class dictionary lookup is negligible."
msgstr ""
"Notez qu'il n'y a pas d'emplacement spécifique pour ces méthodes dans la "
"structure de type pour les objets Python dans l'API Python/C. Les types "
"souhaitant définir ces méthodes doivent les fournir comme une méthode "
"accessible en Python. Comparé au coût de la mise en place du contexte "
"d'exécution, les le coût d'un accès au dictionnaire d'une classe unique est "
"négligeable."

#: ../Doc/library/stdtypes.rst:2909
msgid "Other Built-in Types"
msgstr "Autres types natifs"

#: ../Doc/library/stdtypes.rst:2911
msgid ""
"The interpreter supports several other kinds of objects. Most of these "
"support only one or two operations."
msgstr ""
"L'interpréteur gère aussi d'autres types d'objets, la plupart ne supportant "
"cependant qu'une ou deux opérations."

#: ../Doc/library/stdtypes.rst:2918
msgid "Modules"
msgstr "Modules"

#: ../Doc/library/stdtypes.rst:2920
msgid ""
"The only special operation on a module is attribute access: ``m.name``, "
"where *m* is a module and *name* accesses a name defined in *m*'s symbol "
"table. Module attributes can be assigned to.  (Note that the :keyword:"
"`import` statement is not, strictly speaking, an operation on a module "
"object; ``import foo`` does not require a module object named *foo* to "
"exist, rather it requires an (external) *definition* for a module named "
"*foo* somewhere.)"
msgstr ""
"La seule opération spéciale sur un module est l'accès à ses attributs : ``m."
"name``, où *m* est un module et *name* donne accès un nom défini dans la "
"table des symboles de *m*.  Il est possible d'assigner un attribut de "
"module.  (Notez que l'instruction :keyword:`import` n'est pas strictement "
"une opération sur un objet module. ``import foo`` ne nécessite pas qu'un "
"objet module nommé *foo* existe, il nécessite cependant une *définition* "
"(externe) d'un module nommé *foo* quelque part.)"

#: ../Doc/library/stdtypes.rst:2927
msgid ""
"A special attribute of every module is :attr:`~object.__dict__`. This is the "
"dictionary containing the module's symbol table. Modifying this dictionary "
"will actually change the module's symbol table, but direct assignment to "
"the :attr:`~object.__dict__` attribute is not possible (you can write ``m."
"__dict__['a'] = 1``, which defines ``m.a`` to be ``1``, but you can't write "
"``m.__dict__ = {}``).  Modifying :attr:`~object.__dict__` directly is not "
"recommended."
msgstr ""
"Un attribut spécial à chaque module est :attr:`~object.__dict__`. C'est le "
"dictionnaire contenant la table des symbole du module. Modifier ce "
"dictionnaire changera la table des symboles du module, mais assigner "
"directement :attr:`~object.__dict__` n'est pas possible (vous pouvez écrire "
"``m.__dict__['a'] = 1``, qui donne ``1`` comme valeur pour ``m.a``, mais "
"vous ne pouvez pas écrire ``m.__dict__ = {}``). Modifier :attr:`~object."
"__dict__` directement n'est pas recommandé."

#: ../Doc/library/stdtypes.rst:2935
msgid ""
"Modules built into the interpreter are written like this: ``<module "
"'sys' (built-in)>``.  If loaded from a file, they are written as ``<module "
"'os' from '/usr/local/lib/pythonX.Y/os.pyc'>``."
msgstr ""
"Les modules natifs à l'interpréteur sont représentés ``<module 'sys' (built-"
"in)>``.  S'ils sont chargés depuis un fichier, ils sont représentés "
"``<module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>``."

#: ../Doc/library/stdtypes.rst:2943
msgid "Classes and Class Instances"
msgstr "Les classes et instances de classes"

#: ../Doc/library/stdtypes.rst:2945
msgid "See :ref:`objects` and :ref:`class` for these."
msgstr "Voir :ref:`objects` et :ref:`class`."

#: ../Doc/library/stdtypes.rst:2951
msgid "Functions"
msgstr "Fonctions"

#: ../Doc/library/stdtypes.rst:2953
msgid ""
"Function objects are created by function definitions.  The only operation on "
"a function object is to call it: ``func(argument-list)``."
msgstr ""
"Les objets fonctions sont crées par les définitions de fonctions.  La seule "
"opération applicable à un objet fonction est de l'appeler : ``func(argument-"
"list)``."

#: ../Doc/library/stdtypes.rst:2956
msgid ""
"There are really two flavors of function objects: built-in functions and "
"user-defined functions.  Both support the same operation (to call the "
"function), but the implementation is different, hence the different object "
"types."
msgstr ""
"Il existe en fait deux catégories d'objets fonctions : Les fonctions natives "
"et les fonctions définies par l'utilisateur.  Les deux gèrent les mêmes "
"opérations (l'appel à la fonction), mais leur implémentation est différente, "
"d'où les deux types distincts."

#: ../Doc/library/stdtypes.rst:2960
msgid "See :ref:`function` for more information."
msgstr "Voir :ref:`function` pour plus d'information."

#: ../Doc/library/stdtypes.rst:2966
msgid "Methods"
msgstr "Méthodes"

#: ../Doc/library/stdtypes.rst:2970
msgid ""
"Methods are functions that are called using the attribute notation. There "
"are two flavors: built-in methods (such as :meth:`append` on lists) and "
"class instance methods.  Built-in methods are described with the types that "
"support them."
msgstr ""
"Les méthodes sont des fonctions appelées via la notation d'attribut.  Il en "
"existe deux variantes : Les méthodes natives (tel que :meth:`append` sur les "
"listes), et les méthodes d'instances de classes. Les méthodes natives sont "
"représentées avec le type qui les supporte."

#: ../Doc/library/stdtypes.rst:2975
msgid ""
"The implementation adds two special read-only attributes to class instance "
"methods: ``m.im_self`` is the object on which the method operates, and ``m."
"im_func`` is the function implementing the method.  Calling ``m(arg-1, "
"arg-2, ..., arg-n)`` is completely equivalent to calling ``m.im_func(m."
"im_self, arg-1, arg-2, ..., arg-n)``."
msgstr ""

#: ../Doc/library/stdtypes.rst:2981
msgid ""
"Class instance methods are either *bound* or *unbound*, referring to whether "
"the method was accessed through an instance or a class, respectively.  When "
"a method is unbound, its ``im_self`` attribute will be ``None`` and if "
"called, an explicit ``self`` object must be passed as the first argument.  "
"In this case, ``self`` must be an instance of the unbound method's class (or "
"a subclass of that class), otherwise a :exc:`TypeError` is raised."
msgstr ""

#: ../Doc/library/stdtypes.rst:2988
msgid ""
"Like function objects, methods objects support getting arbitrary attributes. "
"However, since method attributes are actually stored on the underlying "
"function object (``meth.im_func``), setting method attributes on either "
"bound or unbound methods is disallowed.  Attempting to set an attribute on a "
"method results in an :exc:`AttributeError` being raised.  In order to set a "
"method attribute, you need to explicitly set it on the underlying function "
"object::"
msgstr ""

#: ../Doc/library/stdtypes.rst:3009 ../Doc/library/stdtypes.rst:3037
msgid "See :ref:`types` for more information."
msgstr "Voir :ref:`types` pour plus d'information."

#: ../Doc/library/stdtypes.rst:3017
msgid "Code Objects"
msgstr "Objets code"

#: ../Doc/library/stdtypes.rst:3023
msgid ""
"Code objects are used by the implementation to represent \"pseudo-compiled\" "
"executable Python code such as a function body. They differ from function "
"objects because they don't contain a reference to their global execution "
"environment.  Code objects are returned by the built-in :func:`compile` "
"function and can be extracted from function objects through their :attr:"
"`func_code` attribute. See also the :mod:`code` module."
msgstr ""

#: ../Doc/library/stdtypes.rst:3034
msgid ""
"A code object can be executed or evaluated by passing it (instead of a "
"source string) to the :keyword:`exec` statement or the built-in :func:`eval` "
"function."
msgstr ""

#: ../Doc/library/stdtypes.rst:3043
msgid "Type Objects"
msgstr "Objets type"

#: ../Doc/library/stdtypes.rst:3049
msgid ""
"Type objects represent the various object types.  An object's type is "
"accessed by the built-in function :func:`type`.  There are no special "
"operations on types.  The standard module :mod:`types` defines names for all "
"standard built-in types."
msgstr ""
"Les objets types représentent les différents types d'objets. Le type d'un "
"objet est obtenu via la fonction native :func:`type`. Il n'existe aucune "
"opération spéciale sur les types. Le module standard :mod:`types` définit "
"les noms de tous les types natifs."

#: ../Doc/library/stdtypes.rst:3054
msgid "Types are written like this: ``<type 'int'>``."
msgstr ""

#: ../Doc/library/stdtypes.rst:3060
msgid "The Null Object"
msgstr "L'objet Null"

#: ../Doc/library/stdtypes.rst:3062
msgid ""
"This object is returned by functions that don't explicitly return a value.  "
"It supports no special operations.  There is exactly one null object, named "
"``None`` (a built-in name)."
msgstr ""

#: ../Doc/library/stdtypes.rst:3066
msgid "It is written as ``None``."
msgstr "C'est écrit ``None``."

#: ../Doc/library/stdtypes.rst:3072
msgid "The Ellipsis Object"
msgstr "L'objet points de suspension"

#: ../Doc/library/stdtypes.rst:3074
msgid ""
"This object is used by extended slice notation (see :ref:`slicings`).  It "
"supports no special operations.  There is exactly one ellipsis object, "
"named :const:`Ellipsis` (a built-in name)."
msgstr ""

#: ../Doc/library/stdtypes.rst:3078
msgid ""
"It is written as ``Ellipsis``.  When in a subscript, it can also be written "
"as ``...``, for example ``seq[...]``."
msgstr ""

#: ../Doc/library/stdtypes.rst:3083
msgid "The NotImplemented Object"
msgstr "L'objet *NotImplemented*"

#: ../Doc/library/stdtypes.rst:3085
msgid ""
"This object is returned from comparisons and binary operations when they are "
"asked to operate on types they don't support. See :ref:`comparisons` for "
"more information."
msgstr ""

#: ../Doc/library/stdtypes.rst:3089
msgid "It is written as ``NotImplemented``."
msgstr "C'est écrit ``NotImplemented``."

#: ../Doc/library/stdtypes.rst:3093
msgid "Boolean Values"
msgstr "Valeurs Booléennes"

#: ../Doc/library/stdtypes.rst:3095
msgid ""
"Boolean values are the two constant objects ``False`` and ``True``.  They "
"are used to represent truth values (although other values can also be "
"considered false or true).  In numeric contexts (for example when used as "
"the argument to an arithmetic operator), they behave like the integers 0 and "
"1, respectively. The built-in function :func:`bool` can be used to convert "
"any value to a Boolean, if the value can be interpreted as a truth value "
"(see section :ref:`truth` above)."
msgstr ""
"Les valeurs booléennes sont les deux objet constants ``False`` et ``True``. "
"Ils son utilisés pour représenter les valeurs de vérité (bien que d'autres "
"valeurs peuvent être considérées vraies ou fausses). Dans des contextes "
"numériques (par exemple en argument d'un opérateur arithmétique), ils se "
"comportent comme les nombres entiers 0 et 1, respectivement.  La fonction "
"native :func:`bool` peut être utilisée pour convertir n'importe quelle "
"valeur en booléen tant que la valeur peut être interprétée en une valeur de "
"vérité (voir :ref:`truth` au dessus)."

#: ../Doc/library/stdtypes.rst:3108
msgid "They are written as ``False`` and ``True``, respectively."
msgstr "Ils s'écrivent ``False`` et ``True``, respectivement."

#: ../Doc/library/stdtypes.rst:3114
msgid "Internal Objects"
msgstr "Objets Internes"

#: ../Doc/library/stdtypes.rst:3116
msgid ""
"See :ref:`types` for this information.  It describes stack frame objects, "
"traceback objects, and slice objects."
msgstr ""
"Voir :ref:`types`. Ils décrivent les objets *stack frame*, *traceback*, et "
"*slice*."

#: ../Doc/library/stdtypes.rst:3123
msgid "Special Attributes"
msgstr "Attributs Spéciaux"

#: ../Doc/library/stdtypes.rst:3125
msgid ""
"The implementation adds a few special read-only attributes to several object "
"types, where they are relevant.  Some of these are not reported by the :func:"
"`dir` built-in function."
msgstr ""
"L'implémentation ajoute quelques attributs spéciaux et en lecture seule, à "
"certains types, lorsque ça a du sens. Certains ne sont *pas* listés par la "
"fonction native :func:`dir`."

#: ../Doc/library/stdtypes.rst:3132
msgid ""
"A dictionary or other mapping object used to store an object's (writable) "
"attributes."
msgstr ""
"Un dictionnaire ou un autre *mapping object* utilisé pour stocker les "
"attributs (modifiables) de l'objet."

#: ../Doc/library/stdtypes.rst:3138 ../Doc/library/stdtypes.rst:3145
msgid ""
"Use the built-in function :func:`dir` to get a list of an object's "
"attributes. This attribute is no longer available."
msgstr ""

#: ../Doc/library/stdtypes.rst:3152
msgid "The class to which a class instance belongs."
msgstr "La classe de l'instance de classe."

#: ../Doc/library/stdtypes.rst:3157
msgid "The tuple of base classes of a class object."
msgstr "Le *tuple* des classes parentes d'un objet classe."

#: ../Doc/library/stdtypes.rst:3162
msgid ""
"The name of the class, type, function, method, descriptor, or generator "
"instance."
msgstr ""

#: ../Doc/library/stdtypes.rst:3166
msgid ""
"The following attributes are only supported by :term:`new-style class`\\ es."
msgstr ""

#: ../Doc/library/stdtypes.rst:3170
msgid ""
"This attribute is a tuple of classes that are considered when looking for "
"base classes during method resolution."
msgstr ""
"Cet attribut est un *tuple* contenant les classes parents prises en compte "
"lors de la résolution de méthode."

#: ../Doc/library/stdtypes.rst:3176
msgid ""
"This method can be overridden by a metaclass to customize the method "
"resolution order for its instances.  It is called at class instantiation, "
"and its result is stored in :attr:`~class.__mro__`."
msgstr ""
"Cette méthode peut être surchargée par une méta-classe pour personnaliser "
"l'ordre de la recherche de méthode pour ses instances.  Elle est appelée à "
"la l'initialisation de la classe, et son résultat est stocké dans "
"l'attribut :attr:`~class.__mro__`."

#: ../Doc/library/stdtypes.rst:3183
msgid ""
"Each new-style class keeps a list of weak references to its immediate "
"subclasses.  This method returns a list of all those references still alive. "
"Example::"
msgstr ""

#: ../Doc/library/stdtypes.rst:3192
msgid "Footnotes"
msgstr "Notes"

#: ../Doc/library/stdtypes.rst:3193
msgid ""
"Additional information on these special methods may be found in the Python "
"Reference Manual (:ref:`customization`)."
msgstr ""
"Plus d'informations sur ces méthodes spéciales peuvent être trouvées dans le "
"*Python Reference Manual* (:ref:`customization`)."

#: ../Doc/library/stdtypes.rst:3196
msgid ""
"As a consequence, the list ``[1, 2]`` is considered equal to ``[1.0, 2.0]``, "
"and similarly for tuples."
msgstr ""
"Par conséquent, la liste ``[1, 2]`` est considérée égale à ``[1.0, 2.0]``. "
"Idem avec des tuples."

#: ../Doc/library/stdtypes.rst:3199
msgid "They must have since the parser can't tell the type of the operands."
msgstr ""
"Nécessairement, puisque l'analyseur ne peut pas discerner le type des "
"opérandes."

#: ../Doc/library/stdtypes.rst:3201
msgid ""
"Cased characters are those with general category property being one of \"Lu"
"\" (Letter, uppercase), \"Ll\" (Letter, lowercase), or \"Lt\" (Letter, "
"titlecase)."
msgstr ""
"Les caractères capitalisables sont ceux dont la propriété Unicode *general "
"category* est soit \"Lu\" (pour *Letter*, *uppercase*), soit \"Ll\" (pour "
"*Letter*, *lowercase*), soit \"Lt\" (pour *Letter*, *titlecase*)."

#: ../Doc/library/stdtypes.rst:3204
msgid ""
"To format only a tuple you should therefore provide a singleton tuple whose "
"only element is the tuple to be formatted."
msgstr ""
"Pour insérer un *tuple*, vous devez donc donner un *tuple* d'un seul "
"élément, contenant le *tuple* à insérer."

#: ../Doc/library/stdtypes.rst:3207
msgid ""
"The advantage of leaving the newline on is that returning an empty string is "
"then an unambiguous EOF indication.  It is also possible (in cases where it "
"might matter, for example, if you want to make an exact copy of a file while "
"scanning its lines) to tell whether the last line of a file ended in a "
"newline or not (yes this happens!)."
msgstr ""