forked from AFPy/python-docs-fr
4452 lines
168 KiB
Plaintext
4452 lines
168 KiB
Plaintext
# 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 ""
|