python-docs-fr/library/functions.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2016-10-30 10:40+0100\n"
"PO-Revision-Date: 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/functions.rst:5 ../Doc/library/functions.rst:11
msgid "Built-in Functions"
msgstr "Fonctions Natives"

#: ../Doc/library/functions.rst:7
msgid ""
"The Python interpreter has a number of functions and types built into it "
"that are always available.  They are listed here in alphabetical order."
msgstr ""
"L'interpréteur Python propose quelques fonctions et types natifs qui sont "
"toujours disponibles. Ils sont listés ici par ordre alphabétique."

#: ../Doc/library/functions.rst:13
msgid ":func:`abs`"
msgstr ":func:`abs`"

#: ../Doc/library/functions.rst:13
msgid "|func-dict|_"
msgstr "|func-dict|_"

#: ../Doc/library/functions.rst:13
msgid ":func:`help`"
msgstr ":func:`help`"

#: ../Doc/library/functions.rst:13
msgid ":func:`min`"
msgstr ":func:`min`"

#: ../Doc/library/functions.rst:13
msgid ":func:`setattr`"
msgstr ":func:`setattr`"

#: ../Doc/library/functions.rst:14
msgid ":func:`all`"
msgstr ":func:`all`"

#: ../Doc/library/functions.rst:14
msgid ":func:`dir`"
msgstr ":func:`dir`"

#: ../Doc/library/functions.rst:14
msgid ":func:`hex`"
msgstr ":func:`hex`"

#: ../Doc/library/functions.rst:14
msgid ":func:`next`"
msgstr ":func:`next`"

#: ../Doc/library/functions.rst:14
msgid ":func:`slice`"
msgstr ":func:`slice`"

#: ../Doc/library/functions.rst:15
msgid ":func:`any`"
msgstr ":func:`any`"

#: ../Doc/library/functions.rst:15
msgid ":func:`divmod`"
msgstr ":func:`divmod`"

#: ../Doc/library/functions.rst:15
msgid ":func:`id`"
msgstr ":func:`id`"

#: ../Doc/library/functions.rst:15
msgid ":func:`object`"
msgstr ":func:`object`"

#: ../Doc/library/functions.rst:15
msgid ":func:`sorted`"
msgstr ":func:`sorted`"

#: ../Doc/library/functions.rst:16
msgid ":func:`ascii`"
msgstr ":func:`ascii`"

#: ../Doc/library/functions.rst:16
msgid ":func:`enumerate`"
msgstr ":func:`enumerate`"

#: ../Doc/library/functions.rst:16
msgid ":func:`input`"
msgstr ":func:`input`"

#: ../Doc/library/functions.rst:16
msgid ":func:`oct`"
msgstr ":func:`oct`"

#: ../Doc/library/functions.rst:16
msgid ":func:`staticmethod`"
msgstr ":func:`staticmethod`"

#: ../Doc/library/functions.rst:17
msgid ":func:`bin`"
msgstr ":func:`bin`"

#: ../Doc/library/functions.rst:17
msgid ":func:`eval`"
msgstr ":func:`eval`"

#: ../Doc/library/functions.rst:17
msgid ":func:`int`"
msgstr ":func:`int`"

#: ../Doc/library/functions.rst:17
msgid ":func:`open`"
msgstr ":func:`open`"

#: ../Doc/library/functions.rst:17
msgid "|func-str|_"
msgstr "|func-str|_"

#: ../Doc/library/functions.rst:18
msgid ":func:`bool`"
msgstr ":func:`bool`"

#: ../Doc/library/functions.rst:18
msgid ":func:`exec`"
msgstr ":func:`exec`"

#: ../Doc/library/functions.rst:18
msgid ":func:`isinstance`"
msgstr ":func:`isinstance`"

#: ../Doc/library/functions.rst:18
msgid ":func:`ord`"
msgstr ":func:`ord`"

#: ../Doc/library/functions.rst:18
msgid ":func:`sum`"
msgstr ":func:`sum`"

#: ../Doc/library/functions.rst:19
msgid ":func:`bytearray`"
msgstr ":func:`bytearray`"

#: ../Doc/library/functions.rst:19
msgid ":func:`filter`"
msgstr ":func:`filter`"

#: ../Doc/library/functions.rst:19
msgid ":func:`issubclass`"
msgstr ":func:`issubclass`"

#: ../Doc/library/functions.rst:19
msgid ":func:`pow`"
msgstr ":func:`pow`"

#: ../Doc/library/functions.rst:19
msgid ":func:`super`"
msgstr ":func:`super`"

#: ../Doc/library/functions.rst:20
msgid ":func:`bytes`"
msgstr ":func:`bytes`"

#: ../Doc/library/functions.rst:20
msgid ":func:`float`"
msgstr ":func:`float`"

#: ../Doc/library/functions.rst:20
msgid ":func:`iter`"
msgstr ":func:`iter`"

#: ../Doc/library/functions.rst:20
msgid ":func:`print`"
msgstr ":func:`print`"

#: ../Doc/library/functions.rst:20
msgid "|func-tuple|_"
msgstr "|func-tuple|_"

#: ../Doc/library/functions.rst:21
msgid ":func:`callable`"
msgstr ":func:`callable`"

#: ../Doc/library/functions.rst:21
msgid ":func:`format`"
msgstr ":func:`format`"

#: ../Doc/library/functions.rst:21
msgid ":func:`len`"
msgstr ":func:`len`"

#: ../Doc/library/functions.rst:21
msgid ":func:`property`"
msgstr ":func:`property`"

#: ../Doc/library/functions.rst:21
msgid ":func:`type`"
msgstr ":func:`type`"

#: ../Doc/library/functions.rst:22
msgid ":func:`chr`"
msgstr ":func:`chr`"

#: ../Doc/library/functions.rst:22
msgid "|func-frozenset|_"
msgstr "|func-frozenset|_"

#: ../Doc/library/functions.rst:22
msgid "|func-list|_"
msgstr "|func-list|_"

#: ../Doc/library/functions.rst:22
msgid "|func-range|_"
msgstr "|func-range|_"

#: ../Doc/library/functions.rst:22
msgid ":func:`vars`"
msgstr ":func:`vars`"

#: ../Doc/library/functions.rst:23
msgid ":func:`classmethod`"
msgstr ":func:`classmethod`"

#: ../Doc/library/functions.rst:23
msgid ":func:`getattr`"
msgstr ":func:`getattr`"

#: ../Doc/library/functions.rst:23
msgid ":func:`locals`"
msgstr ":func:`locals`"

#: ../Doc/library/functions.rst:23
msgid ":func:`repr`"
msgstr ":func:`repr`"

#: ../Doc/library/functions.rst:23
msgid ":func:`zip`"
msgstr ":func:`zip`"

#: ../Doc/library/functions.rst:24
msgid ":func:`compile`"
msgstr ":func:`compile`"

#: ../Doc/library/functions.rst:24
msgid ":func:`globals`"
msgstr ":func:`globals`"

#: ../Doc/library/functions.rst:24
msgid ":func:`map`"
msgstr ":func:`map`"

#: ../Doc/library/functions.rst:24
msgid ":func:`reversed`"
msgstr ":func:`reversed`"

#: ../Doc/library/functions.rst:24
msgid ":func:`__import__`"
msgstr ":func:`__import__`"

#: ../Doc/library/functions.rst:25
msgid ":func:`complex`"
msgstr ":func:`complex`"

#: ../Doc/library/functions.rst:25
msgid ":func:`hasattr`"
msgstr ":func:`hasattr`"

#: ../Doc/library/functions.rst:25
msgid ":func:`max`"
msgstr ":func:`max`"

#: ../Doc/library/functions.rst:25
msgid ":func:`round`"
msgstr ":func:`round`"

#: ../Doc/library/functions.rst:26
msgid ":func:`delattr`"
msgstr ":func:`delattr`"

#: ../Doc/library/functions.rst:26
msgid ":func:`hash`"
msgstr ":func:`hash`"

#: ../Doc/library/functions.rst:26
msgid "|func-memoryview|_"
msgstr "|func-memoryview|_"

#: ../Doc/library/functions.rst:26
msgid "|func-set|_"
msgstr "|func-set|_"

#: ../Doc/library/functions.rst:44
msgid ""
"Return the absolute value of a number.  The argument may be an integer or a "
"floating point number.  If the argument is a complex number, its magnitude "
"is returned."
msgstr ""
"Donne la valeur absolue d'un nombre. L'argument peut être un nombre entier "
"ou un nombre à virgule flottante. Si l'argument est un nombre complexe, son "
"`module <https://fr.wikipedia.org/wiki/Module_d%27un_nombre_complexe>`_ est "
"donné."

#: ../Doc/library/functions.rst:51
msgid ""
"Return ``True`` if all elements of the *iterable* are true (or if the "
"iterable is empty).  Equivalent to::"
msgstr ""
"Donne ``True`` si tous les éléments de *iterable* sont vrais (ou s'il est "
"vide), équivaut à : ::"

#: ../Doc/library/functions.rst:63
msgid ""
"Return ``True`` if any element of the *iterable* is true.  If the iterable "
"is empty, return ``False``.  Equivalent to::"
msgstr ""
"Donne ``True`` si au moins un élément de *iterable* est vrai. Faux est aussi "
"donné dans le cas où *iterable* est vide, équivaut à : ::"

#: ../Doc/library/functions.rst:75
msgid ""
"As :func:`repr`, return a string containing a printable representation of an "
"object, but escape the non-ASCII characters in the string returned by :func:"
"`repr` using ``\\x``, ``\\u`` or ``\\U`` escapes.  This generates a string "
"similar to that returned by :func:`repr` in Python 2."
msgstr ""
"Donne, tout comme :func:`repr`, une chaîne contenant une représentation "
"affichable d'un objet, en transformant les caractères non-ASCII donnés par :"
"func:`repr` en utilisant des séquences d'échappement ``\\x``, ``\\u`` ou ``"
"\\U``. Cela génère une chaîne similaire à ce que renvoie :func:`repr` dans "
"Python 2."

#: ../Doc/library/functions.rst:83
msgid ""
"Convert an integer number to a binary string. The result is a valid Python "
"expression.  If *x* is not a Python :class:`int` object, it has to define "
"an :meth:`__index__` method that returns an integer."
msgstr ""
"Convertit un nombre entier en binaire dans une chaîne. Le résultat est une "
"expression Python valide. Si *x* n'est pas un :class:`int`, il doit définir "
"une méthode :meth:`__index__` donnant un nombre entier."

#: ../Doc/library/functions.rst:90
msgid ""
"Return a Boolean value, i.e. one of ``True`` or ``False``.  *x* is converted "
"using the standard :ref:`truth testing procedure <truth>`.  If *x* is false "
"or omitted, this returns ``False``; otherwise it returns ``True``.  The :"
"class:`bool` class is a subclass of :class:`int` (see :ref:`typesnumeric`). "
"It cannot be subclassed further.  Its only instances are ``False`` and "
"``True`` (see :ref:`bltin-boolean-values`)."
msgstr ""
"Donne une valeur booléenne, c'est à dire soit ``True``, soit ``False``. *x* "
"est converti en utilisant la :ref:`procédure standard d'évaluation de valeur "
"de vérité<truth>`. Si *x* est faux, ou omis, elle donne ``False``, sinon, "
"elle donne ``True``. La classe :class:`bool` hérite de la classe :class:"
"`int` (voir :ref:`typesnumeric`). Il n'est pas possible d'en hériter. Ses "
"seules instances sont ``False`` et ``True`` (voir :ref:`bltin-boolean-"
"values`)."

#: ../Doc/library/functions.rst:103
msgid ""
"Return a new array of bytes.  The :class:`bytearray` class is a mutable "
"sequence of integers in the range 0 <= x < 256.  It has most of the usual "
"methods of mutable sequences, described in :ref:`typesseq-mutable`, as well "
"as most methods that the :class:`bytes` type has, see :ref:`bytes-methods`."
msgstr ""
"Donne un nouveau tableau d'octets. La classe :class:`bytearray` est une "
"séquence mutable de nombre entiers dans l'intervalle 0 <= x < 256. Il "
"possède la plupart des méthodes des séquences variables, décrites dans :ref:"
"`typesseq-mutable`, ainsi que la plupart des méthodes de la classe :class:"
"`bytes`, voir :ref:`bytes-methods`."

#: ../Doc/library/functions.rst:108
msgid ""
"The optional *source* parameter can be used to initialize the array in a few "
"different ways:"
msgstr ""
"Le paramètre optionnel *source* peut être utilisé pour initialiser l'*array* "
"de quelques manières différentes :"

#: ../Doc/library/functions.rst:111
msgid ""
"If it is a *string*, you must also give the *encoding* (and optionally, "
"*errors*) parameters; :func:`bytearray` then converts the string to bytes "
"using :meth:`str.encode`."
msgstr ""
"Si c'est une *chaîne*, vous devez aussi donner les paramètre *encoding* pour "
"l'encodage (et éventuellement *errors*). La fonction :func:`bytearray` "
"convertit ensuite la chaîne en *bytes* via la méthode :meth:`str.encode`."

#: ../Doc/library/functions.rst:115
msgid ""
"If it is an *integer*, the array will have that size and will be initialized "
"with null bytes."
msgstr ""
"Si c'est un *entier*, l'*array* aura cette taille et sera initialisé de "
"*null bytes*."

#: ../Doc/library/functions.rst:118
msgid ""
"If it is an object conforming to the *buffer* interface, a read-only buffer "
"of the object will be used to initialize the bytes array."
msgstr ""
"Si c'est un objet conforme à l'interface *buffer*, un *buffer* en lecture "
"seule de l'objet sera utilisé pour initialiser l'*array*."

#: ../Doc/library/functions.rst:121
msgid ""
"If it is an *iterable*, it must be an iterable of integers in the range ``0 "
"<= x < 256``, which are used as the initial contents of the array."
msgstr ""
"Si c'est un *itérable*, il doit itérer sur des nombres entier dans "
"l'intervalle ``0 <= x < 256``, qui seront utilisés pour initialiser le "
"contenu de l'*array*."

#: ../Doc/library/functions.rst:124
msgid "Without an argument, an array of size 0 is created."
msgstr "Sans argument, un *array* de taille vide est crée."

#: ../Doc/library/functions.rst:126
msgid "See also :ref:`binaryseq` and :ref:`typebytearray`."
msgstr "Voir :ref:`binaryseq` et :ref:`typebytearray`."

#: ../Doc/library/functions.rst:132
msgid ""
"Return a new \"bytes\" object, which is an immutable sequence of integers in "
"the range ``0 <= x < 256``.  :class:`bytes` is an immutable version of :"
"class:`bytearray` -- it has the same non-mutating methods and the same "
"indexing and slicing behavior."
msgstr ""
"Donne un nouvel objet *bytes*, qui est une séquence immuable de nombre "
"entiers dans l'intervalle ``0 <= x <= 256``. Les :class:`bytes` est une "
"version immuable de :class:`bytearray` -- avec les mêmes méthodes d'accès, "
"et le même comportement lors de l'indexation ou la découpe."

#: ../Doc/library/functions.rst:137
msgid ""
"Accordingly, constructor arguments are interpreted as for :func:`bytearray`."
msgstr ""
"En conséquence, les arguments du constructeur sont les mêmes que pour :func:"
"`bytearray`."

#: ../Doc/library/functions.rst:139
msgid "Bytes objects can also be created with literals, see :ref:`strings`."
msgstr ""
"Les objets *bytes* peuvent aussi être crées à partir de litéraux, voir :ref:"
"`strings`."

#: ../Doc/library/functions.rst:141
msgid "See also :ref:`binaryseq`, :ref:`typebytes`, and :ref:`bytes-methods`."
msgstr ""
"Voir aussi :ref:`binaryseq`, :ref:`typebytes`, et :ref:`bytes-methods`."

#: ../Doc/library/functions.rst:146
msgid ""
"Return :const:`True` if the *object* argument appears callable, :const:"
"`False` if not.  If this returns true, it is still possible that a call "
"fails, but if it is false, calling *object* will never succeed. Note that "
"classes are callable (calling a class returns a new instance); instances are "
"callable if their class has a :meth:`__call__` method."
msgstr ""
"Donne :const:`True` si l'argument *object* semble être appelable, sinon :"
"const:`False`. Lorsqu'elle donne vrai, il reste une éventualité pour qu'un "
"appel échoue, cependant, lorsqu'elle donne faux, il ne sera jamais possible "
"d'appeler *object*. Notez que les classes sont appelables (appeler une "
"classe donne une nouvelle instance). Les instances sont appelables si leur "
"class définit une méthode :meth:`__call__`."

#: ../Doc/library/functions.rst:152
msgid ""
"This function was first removed in Python 3.0 and then brought back in "
"Python 3.2."
msgstr ""
"Cette fonction à d'abord été supprimée avec Python 3.0 puis elle à été "
"remise dans Python 3.2."

#: ../Doc/library/functions.rst:159
msgid ""
"Return the string representing a character whose Unicode code point is the "
"integer *i*.  For example, ``chr(97)`` returns the string ``'a'``, while "
"``chr(8364)`` returns the string ``'€'``. This is the inverse of :func:`ord`."
msgstr ""

#: ../Doc/library/functions.rst:163
msgid ""
"The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in "
"base 16).  :exc:`ValueError` will be raised if *i* is outside that range."
msgstr ""
"L'intervalle valide pour cet argument est de 0 à 1114111 (0x10FFFF en base "
"16). Une exception :exc:`ValueError` sera levée si *i* est en dehors de "
"l'intervalle."

#: ../Doc/library/functions.rst:169
msgid "Return a class method for *function*."
msgstr "Donne une méthode de classe pour *fonction*."

#: ../Doc/library/functions.rst:171
msgid ""
"A class method receives the class as implicit first argument, just like an "
"instance method receives the instance. To declare a class method, use this "
"idiom::"
msgstr ""
"Une méthode de classe reçoit implicitement la classe en premier augment, "
"tout comme une méthode d'instance reçoit l'instance. Voici comment déclarer "
"une méthode de classe : ::"

#: ../Doc/library/functions.rst:179
msgid ""
"The ``@classmethod`` form is a function :term:`decorator` -- see the "
"description of function definitions in :ref:`function` for details."
msgstr ""
"La forme ``@classmethod`` est un :term:`decorator` -- consultez la "
"documentation sur la définition de fonctions dans :ref:`function` pour plus "
"de détails."

#: ../Doc/library/functions.rst:182
msgid ""
"It can be called either on the class (such as ``C.f()``) or on an instance "
"(such as ``C().f()``).  The instance is ignored except for its class. If a "
"class method is called for a derived class, the derived class object is "
"passed as the implied first argument."
msgstr ""
"Elle peut être appelée soit sur la classe (comme ``C.f()``) ou sur une "
"instance (comme ``C().f()``). L'instance est ignorée, sauf pour déterminer "
"sa classe. Si la méthode est appelée sur une instance de classe fille, c'est "
"la classe fille qui sera donnée en premier argument implicite."

#: ../Doc/library/functions.rst:187
msgid ""
"Class methods are different than C++ or Java static methods. If you want "
"those, see :func:`staticmethod` in this section."
msgstr ""
"Les méthodes de classe sont différentes des méthodes statiques du C++ ou du "
"Java. Si c'est elles sont vous avez besoin, regardez du côté de :func:"
"`staticmethod`."

#: ../Doc/library/functions.rst:190
msgid ""
"For more information on class methods, consult the documentation on the "
"standard type hierarchy in :ref:`types`."
msgstr ""
"Pour plus d'informations sur les méthodes de classe, consultez la "
"documentation sur la hiérarchie des types standards dans :ref:`types`."

#: ../Doc/library/functions.rst:196
msgid ""
"Compile the *source* into a code or AST object.  Code objects can be "
"executed by :func:`exec` or :func:`eval`.  *source* can either be a normal "
"string, a byte string, or an AST object.  Refer to the :mod:`ast` module "
"documentation for information on how to work with AST objects."
msgstr ""
"Compile *source* en un objet code ou objet AST. Les objets code peuvent être "
"exécutés par :func:`exec` ou :func:`eval`. *source* peut soit être une "
"chaîne, un objet *bytes*, ou un objet AST. Consultez la documentation du "
"module :mod:`ast` pour des informations sur la manipulation d'objets AST."

#: ../Doc/library/functions.rst:201
msgid ""
"The *filename* argument should give the file from which the code was read; "
"pass some recognizable value if it wasn't read from a file (``'<string>'`` "
"is commonly used)."
msgstr ""
"L'argument *filename* doit nommer le fichier duquel le code à été lu. Donnez "
"quelque chose de reconnaissable lorsqu'il n'a pas été lu depuis un fichier "
"(typiquement ``\"<string>\"``)."

#: ../Doc/library/functions.rst:205
msgid ""
"The *mode* argument specifies what kind of code must be compiled; it can be "
"``'exec'`` if *source* consists of a sequence of statements, ``'eval'`` if "
"it consists of a single expression, or ``'single'`` if it consists of a "
"single interactive statement (in the latter case, expression statements that "
"evaluate to something other than ``None`` will be printed)."
msgstr ""
"L'argument *mode* indique quel type de code doit être compilé : ``'exec'`` "
"si source est une suite d'instructions, ``'eval'`` pour une seule "
"expression, ou ``'single'`` si il ne contient qu'une instruction interactive "
"(dans ce dernier cas, les résultats d'expressions donnant autre chose que "
"``None`` seront affichés)."

#: ../Doc/library/functions.rst:211
msgid ""
"The optional arguments *flags* and *dont_inherit* control which future "
"statements (see :pep:`236`) affect the compilation of *source*.  If neither "
"is present (or both are zero) the code is compiled with those future "
"statements that are in effect in the code that is calling :func:`compile`.  "
"If the *flags* argument is given and *dont_inherit* is not (or is zero) then "
"the future statements specified by the *flags* argument are used in addition "
"to those that would be used anyway. If *dont_inherit* is a non-zero integer "
"then the *flags* argument is it -- the future statements in effect around "
"the call to compile are ignored."
msgstr ""
"Les arguments optionnels *flags* et *dont_inherit* contrôlent quelle "
"instructions *future* (voir :pep:`236`) affecte la compilation de *source*. "
"Si aucun des deux n'est présent (ou que les deux sont à 0) le code est "
"compilé avec les mêmes instructions *future* que le code appelant :func:"
"`compile`. Si l'argument *flags* est fourni mais que *dont_inherit* ne l'est "
"pas (ou vaut 0), alors les instructions *futures* utilisées seront celles "
"spécifiées par *flags* en plus de celles qui auraient été utilisées. Si "
"*dont_inherit* est un entier différent de zéro, *flags* est utilisé seul -- "
"les instructions futures déclarées autour de l'appel à *compile* sont "
"ignorées."

#: ../Doc/library/functions.rst:221
msgid ""
"Future statements are specified by bits which can be bitwise ORed together "
"to specify multiple statements.  The bitfield required to specify a given "
"feature can be found as the :attr:`~__future__._Feature.compiler_flag` "
"attribute on the :class:`~__future__._Feature` instance in the :mod:"
"`__future__` module."
msgstr ""
"Les instructions futures sont spécifiées par des bits, il est ainsi possible "
"d'en spécifier plusieurs en les combinant avec un *ou* binaire. Les bits "
"requis pour spécifier une certaine fonctionnalité se trouvent dans "
"l'attribut :attr:`~__future__._Feature.compiler_flag` de la classe :class:"
"`~__future__.Feature` du module :mod:`__future__`."

#: ../Doc/library/functions.rst:226
msgid ""
"The argument *optimize* specifies the optimization level of the compiler; "
"the default value of ``-1`` selects the optimization level of the "
"interpreter as given by :option:`-O` options.  Explicit levels are ``0`` (no "
"optimization; ``__debug__`` is true), ``1`` (asserts are removed, "
"``__debug__`` is false) or ``2`` (docstrings are removed too)."
msgstr ""
"L'argument *optimize* indique le niveau d'optimisation du compilateur. La "
"valeur par défaut est ``-1`` qui prend le niveau d'optimisation de "
"l'interpréteur tel que reçu via l'option :option:`-O`. Les niveau explicites "
"sont : ``0`` (pas d'optimisation, ``__debug__`` est ``True``), ``1`` (les "
"``assert`` sont supprimés, ``__debug__`` est ``False``) ou ``2`` (les "
"docstrings sont supprimés aussi)."

#: ../Doc/library/functions.rst:232
msgid ""
"This function raises :exc:`SyntaxError` if the compiled source is invalid, "
"and :exc:`ValueError` if the source contains null bytes."
msgstr ""
"Cette fonction lève une :exc:`SyntaxError` si la source n'est pas valide, "
"et :exc:`ValueError` si la source contient des octets null."

#: ../Doc/library/functions.rst:235
msgid ""
"If you want to parse Python code into its AST representation, see :func:`ast."
"parse`."
msgstr ""
"Si vous voulez transformer du code Python en sa représentation AST, voyez :"
"func:`ast.parse`."

#: ../Doc/library/functions.rst:240
msgid ""
"When compiling a string with multi-line code in ``'single'`` or ``'eval'`` "
"mode, input must be terminated by at least one newline character.  This is "
"to facilitate detection of incomplete and complete statements in the :mod:"
"`code` module."
msgstr ""
"Lors de la compilation d'une chaîne de plusieurs lignes de code avec les "
"modes ``'single'`` ou ``'eval'``, celle-ci doit être terminée d'au moins un "
"retour à la ligne. Cela permet de faciliter la distinction entre les "
"instructions complètes et incomplètes dans le module :mod:`code`."

#: ../Doc/library/functions.rst:245
msgid ""
"Allowed use of Windows and Mac newlines.  Also input in ``'exec'`` mode does "
"not have to end in a newline anymore.  Added the *optimize* parameter."
msgstr ""
"Autorise l'utilisation de retours à la ligne Mac et Windows. Aussi, la "
"chaîne donnée à ``'exec'`` n'a plus besoin de terminer par un retour à la "
"ligne. Ajout du paramètre *optimize*."

#: ../Doc/library/functions.rst:249
msgid ""
"Previously, :exc:`TypeError` was raised when null bytes were encountered in "
"*source*."
msgstr ""

#: ../Doc/library/functions.rst:256
msgid ""
"Return a complex number with the value *real* + *imag*\\*1j or convert a "
"string or number to a complex number.  If the first parameter is a string, "
"it will be interpreted as a complex number and the function must be called "
"without a second parameter.  The second parameter can never be a string. "
"Each argument may be any numeric type (including complex).  If *imag* is "
"omitted, it defaults to zero and the constructor serves as a numeric "
"conversion like :class:`int` and :class:`float`.  If both arguments are "
"omitted, returns ``0j``."
msgstr ""
"Donne un nombre complexe de valeur *real* + *imag*\\*1j, ou convertit une "
"chaîne ou un nombre en nombre complexe. Si le premier paramètre est une "
"chaîne, il sera interprété comme un nombre complexe et la fonction doit être "
"appelée dans second paramètre. Le second paramètre ne peut jamais être une "
"chaîne. Chaque argument peut être de n'importe quel type numérique (même "
"complexe). Si *imag* est omis, sa valeur par défaut est zéro, le "
"constructeur effectue alors une simple conversion numérique comme le font :"
"class:`int` ou :class:`float`. Si aucun argument n'est fourni, donne ``0j``."

#: ../Doc/library/functions.rst:267
msgid ""
"When converting from a string, the string must not contain whitespace around "
"the central ``+`` or ``-`` operator.  For example, ``complex('1+2j')`` is "
"fine, but ``complex('1 + 2j')`` raises :exc:`ValueError`."
msgstr ""
"Lors de la conversion depuis une chaîne, elle ne doit pas contenir d'espaces "
"autour des opérateurs binaires ``+`` ou ``-``. Par exemple "
"``complex('1+2j')`` est bon, mais ``complex('1 + 2j')`` lève une :exc:"
"`ValueError`."

#: ../Doc/library/functions.rst:272
msgid "The complex type is described in :ref:`typesnumeric`."
msgstr "Le type complexe est décrit dans :ref:`typesnumeric`."

#: ../Doc/library/functions.rst:274 ../Doc/library/functions.rst:537
#: ../Doc/library/functions.rst:711
msgid "Grouping digits with underscores as in code literals is allowed."
msgstr ""

#: ../Doc/library/functions.rst:280
msgid ""
"This is a relative of :func:`setattr`.  The arguments are an object and a "
"string.  The string must be the name of one of the object's attributes.  The "
"function deletes the named attribute, provided the object allows it.  For "
"example, ``delattr(x, 'foobar')`` is equivalent to ``del x.foobar``."
msgstr ""
"C'est un cousin de :func:`setattr`. Les arguments sont un objet et une "
"chaîne. La chaîne doit être le nom de l'un des attributs de l'objet. La "
"fonction supprime l'attribut nommé, si l'objet l'y autorise. Par exemple "
"``delattr(x, 'foobar')`` est l'équivalent de ``del x.foobar``."

#: ../Doc/library/functions.rst:292
msgid ""
"Create a new dictionary.  The :class:`dict` object is the dictionary class. "
"See :class:`dict` and :ref:`typesmapping` for documentation about this class."
msgstr ""
"Créé un nouveau dictionnaire. L'objet :class:`dict` est la classe du "
"dictionnaire. Voir :class:`dict` et :ref:`typesmapping` pour vous documenter "
"sur cette classe."

#: ../Doc/library/functions.rst:295
msgid ""
"For other containers see the built-in :class:`list`, :class:`set`, and :"
"class:`tuple` classes, as well as the :mod:`collections` module."
msgstr ""
"Pour les autres conteneurs, voir les classes natives :class:`list`, :class:"
"`set`, et :class:`typle`. ainsi que le module :mod:`collections`."

#: ../Doc/library/functions.rst:301
msgid ""
"Without arguments, return the list of names in the current local scope.  "
"With an argument, attempt to return a list of valid attributes for that "
"object."
msgstr ""
"Sans arguments, elle donne la liste des noms dans l'espace de noms local. "
"Avec un argument, elle essaye de donner une liste d'attributs valides pour "
"cet objet."

#: ../Doc/library/functions.rst:304
msgid ""
"If the object has a method named :meth:`__dir__`, this method will be called "
"and must return the list of attributes. This allows objects that implement a "
"custom :func:`__getattr__` or :func:`__getattribute__` function to customize "
"the way :func:`dir` reports their attributes."
msgstr ""
"Si l'objet à une méthode :meth:`__dir__`, elle est appelée et doit donner "
"une liste d'attributs. Cela permet aux objets implémentant :func:"
"`__getattr__` ou :func:`__getattribute__` de personnaliser ce que donnera :"
"func:`dir`."

#: ../Doc/library/functions.rst:309
msgid ""
"If the object does not provide :meth:`__dir__`, the function tries its best "
"to gather information from the object's :attr:`~object.__dict__` attribute, "
"if defined, and from its type object.  The resulting list is not necessarily "
"complete, and may be inaccurate when the object has a custom :func:"
"`__getattr__`."
msgstr ""

#: ../Doc/library/functions.rst:314
msgid ""
"The default :func:`dir` mechanism behaves differently with different types "
"of objects, as it attempts to produce the most relevant, rather than "
"complete, information:"
msgstr ""
"Le mécanisme par défaut de :func:`dir` se comporte différemment avec "
"différents types d'objets, car elle préfère donner une information "
"pertinente plutôt qu'exhaustive :"

#: ../Doc/library/functions.rst:318
msgid ""
"If the object is a module object, the list contains the names of the "
"module's attributes."
msgstr ""
"Si l'objet est un module, la liste contiendra les noms des attributs du "
"module."

#: ../Doc/library/functions.rst:321
msgid ""
"If the object is a type or class object, the list contains the names of its "
"attributes, and recursively of the attributes of its bases."
msgstr ""
"Si l'objet est un type ou une classe, la liste contiendra les noms de ses "
"attributs, et récursivement, des attributs de ses parents."

#: ../Doc/library/functions.rst:324
msgid ""
"Otherwise, the list contains the object's attributes' names, the names of "
"its class's attributes, and recursively of the attributes of its class's "
"base classes."
msgstr ""
"Autrement, la liste contient les noms des attributs de l'objet, le nom des "
"attributs de la classe, et récursivement des attributs des parents de la "
"classe."

#: ../Doc/library/functions.rst:328
msgid "The resulting list is sorted alphabetically.  For example:"
msgstr "La liste donnée est triée par ordre alphabétique, par exemple :"

#: ../Doc/library/functions.rst:347
msgid ""
"Because :func:`dir` is supplied primarily as a convenience for use at an "
"interactive prompt, it tries to supply an interesting set of names more than "
"it tries to supply a rigorously or consistently defined set of names, and "
"its detailed behavior may change across releases.  For example, metaclass "
"attributes are not in the result list when the argument is a class."
msgstr ""
"Étant donné que :func:`dir` est d'abord fournie pour son côté pratique en "
"mode interactif, elle a tendance à fournir un jeu intéressant de noms plutôt "
"qu'un ensemble consistant et rigoureusement défini, son comportement peut "
"aussi changer d'une version à l'autre. Par exemple, les attributs de méta-"
"classes ne sont pas données lorsque l'argument est une classe."

#: ../Doc/library/functions.rst:357
msgid ""
"Take two (non complex) numbers as arguments and return a pair of numbers "
"consisting of their quotient and remainder when using integer division.  "
"With mixed operand types, the rules for binary arithmetic operators apply.  "
"For integers, the result is the same as ``(a // b, a % b)``. For floating "
"point numbers the result is ``(q, a % b)``, where *q* is usually ``math."
"floor(a / b)`` but may be 1 less than that.  In any case ``q * b + a % b`` "
"is very close to *a*, if ``a % b`` is non-zero it has the same sign as *b*, "
"and ``0 <= abs(a % b) < abs(b)``."
msgstr ""
"Prend deux nombres (non complexes) et donne leur quotient et reste de leur "
"division entière sous forme d'une paire de nombres. Avec des opérandes de "
"types différents, les règles des opérateurs binaires s'appliquent. Pour deux "
"entiers le résultat est le même que ``(a // b, a % b)``. Pour des nombres à "
"virgule flottante le résultat est ``(q, a % b)``, où *q* est généralement "
"``math.floor(a / b)`` mais peut valoir un de moins. Dans tous les cas ``q * "
"b + a % b`` est très proche de *a*. Si ``a % b`` est différent de zéro, il a "
"le même signe que *b*, et ``0 <= abs(a % b) < abs(b)``."

#: ../Doc/library/functions.rst:369
msgid ""
"Return an enumerate object. *iterable* must be a sequence, an :term:"
"`iterator`, or some other object which supports iteration. The :meth:"
"`~iterator.__next__` method of the iterator returned by :func:`enumerate` "
"returns a tuple containing a count (from *start* which defaults to 0) and "
"the values obtained from iterating over *iterable*."
msgstr ""
"Donne un objet énumérant. *iterable* doit être une séquence, un :term:"
"`iterator`, ou tout autre objet supportant l'itération. La méthode :meth:"
"`~iterator.__next__` de l'itérateur donné par :func:`enumerate` donne un "
"tuple contenant un compte (démarrant à *start*, 0 par défaut) et les valeurs "
"obtenues de l'itération sur *iterable*."

#: ../Doc/library/functions.rst:381
msgid "Equivalent to::"
msgstr "Équivalent à : ::"

#: ../Doc/library/functions.rst:392
msgid ""
"The arguments are a string and optional globals and locals.  If provided, "
"*globals* must be a dictionary.  If provided, *locals* can be any mapping "
"object."
msgstr ""
"Les arguments sont : une chaîne, et optionnellement des locales et des "
"globales. S'il est fourni, *globals* doit être un dictionnaire. S'il est "
"fourni, *locals* peut être n'importe quel objet *mapping*."

#: ../Doc/library/functions.rst:396
msgid ""
"The *expression* argument is parsed and evaluated as a Python expression "
"(technically speaking, a condition list) using the *globals* and *locals* "
"dictionaries as global and local namespace.  If the *globals* dictionary is "
"present and lacks '__builtins__', the current globals are copied into "
"*globals* before *expression* is parsed.  This means that *expression* "
"normally has full access to the standard :mod:`builtins` module and "
"restricted environments are propagated.  If the *locals* dictionary is "
"omitted it defaults to the *globals* dictionary.  If both dictionaries are "
"omitted, the expression is executed in the environment where :func:`eval` is "
"called.  The return value is the result of the evaluated expression. Syntax "
"errors are reported as exceptions.  Example:"
msgstr ""
"L'argument *expression* est analysé et évalué comme une expression Python "
"(techniquement, une *condition list*) en utilisant les dictionnaires "
"*globals* et *locals* comme espaces de noms globaux et locaux. Si le "
"dictionnaire *globals* est présent mais n'a pas de '__builtins__', les "
"builtins sont copiées dans *globals* avant qu'*expression* ne soit évalué. "
"Cela signifie qu'*expression* à normalement un accès complet à tout le "
"module :mod:`builtins`, et que les environnements restreints sont propagés. "
"Si le dictionnaire *locals* est omis, sa valeur par défaut est le "
"dictionnaire *globals*. Si les deux dictionnaires sont omis, l'expression "
"est executée dans l'environnement où :func:`eval` est appelé. La valeur "
"donnée par *eval* est le résultat de l'exressipn évaluée. Les erreurs de "
"syntaxe sont rapportées via des exceptions. Exemple :"

#: ../Doc/library/functions.rst:411
msgid ""
"This function can also be used to execute arbitrary code objects (such as "
"those created by :func:`compile`).  In this case pass a code object instead "
"of a string.  If the code object has been compiled with ``'exec'`` as the "
"*mode* argument, :func:`eval`\\'s return value will be ``None``."
msgstr ""
"Cette fonction peut aussi être utilisée pour exécuter n'importe quel objet "
"code (tel que ceux créés par :func:`compile`). Dans ce cas, donnez un objet "
"code plutôt qu'une chaîne. Si l'objet code à été compilé avec ``'exec'`` en "
"argument pour *mode*, :func:`eval` donnera ``None``."

#: ../Doc/library/functions.rst:416
msgid ""
"Hints: dynamic execution of statements is supported by the :func:`exec` "
"function.  The :func:`globals` and :func:`locals` functions returns the "
"current global and local dictionary, respectively, which may be useful to "
"pass around for use by :func:`eval` or :func:`exec`."
msgstr ""
"Conseils : L'exécution dynamique d'instructions est gérée par la fonction :"
"func:`exec`. Les fonctions :func:`globals` et :func:`locals` donnent "
"respectivement les dictionnaires globaux et locaux, qui peuvent être utiles "
"lors de l'usage de :func:`eval` et :func:`exec`."

#: ../Doc/library/functions.rst:421
msgid ""
"See :func:`ast.literal_eval` for a function that can safely evaluate strings "
"with expressions containing only literals."
msgstr ""
"Utilisez :func:`ast.literal_eval` si vous avez besoin d'une fonction qui "
"peut évaluer en toute sécurité des chaînes avec des expressions ne contenant "
"que des valeurs littérales."

#: ../Doc/library/functions.rst:428
msgid ""
"This function supports dynamic execution of Python code. *object* must be "
"either a string or a code object.  If it is a string, the string is parsed "
"as a suite of Python statements which is then executed (unless a syntax "
"error occurs). [#]_ If it is a code object, it is simply executed.  In all "
"cases, the code that's executed is expected to be valid as file input (see "
"the section \"File input\" in the Reference Manual). Be aware that the :"
"keyword:`return` and :keyword:`yield` statements may not be used outside of "
"function definitions even within the context of code passed to the :func:"
"`exec` function. The return value is ``None``."
msgstr ""
"Cette fonction permet l'exécution dynamique de code Python. *object* doit "
"être soit une chaîne soit un objet code. Si c'est une chaîne, elle est "
"d'abord analysée en une suite d'instructions Python qui sont ensuite "
"exécutés (sauf erreur de syntaxe). [#]_ Si c'est un objet code, il est "
"simplement exécuté. dans tous les cas, le code fourni doit être valide selon "
"les mêmes critères que s'il était un script dans un fichier (voir la section "
"\"File Input\" dans le manuel). Gardez en tête que les mots clefs :keyword:"
"`return` et :keyword:`yield` ne peuvent pas être utilisés en dehors d'une "
"fonction, même dans du code passé à :func:`exec`. La fonction donne ``None``."

#: ../Doc/library/functions.rst:438
msgid ""
"In all cases, if the optional parts are omitted, the code is executed in the "
"current scope.  If only *globals* is provided, it must be a dictionary, "
"which will be used for both the global and the local variables.  If "
"*globals* and *locals* are given, they are used for the global and local "
"variables, respectively.  If provided, *locals* can be any mapping object.  "
"Remember that at module level, globals and locals are the same dictionary. "
"If exec gets two separate objects as *globals* and *locals*, the code will "
"be executed as if it were embedded in a class definition."
msgstr ""
"Dans tous les cas, si les arguments optionnels sont omis, le code est "
"exécuté dans le contexte actuel. Si seul *globals* est fourni, il doit être "
"un dictionnaire qui sera utilisé pour les globales et les locales. Si les "
"deux sont fournis, ils sont utilisés respectivement pour les variables "
"globales et locales. *locales* peut être n'importe quel objet ``mapping``. "
"Souvenez vous qu'au niveau d'un module, les dictionnaires des locales et des "
"globales ne sont qu'un. Si ``exec`` reçoit deux objets distincts dans "
"*globals* et *locals*, le code sera exécuté comme s'il était inclus dans une "
"définition de classe."

#: ../Doc/library/functions.rst:447
msgid ""
"If the *globals* dictionary does not contain a value for the key "
"``__builtins__``, a reference to the dictionary of the built-in module :mod:"
"`builtins` is inserted under that key.  That way you can control what "
"builtins are available to the executed code by inserting your own "
"``__builtins__`` dictionary into *globals* before passing it to :func:`exec`."
msgstr ""
"Si le dictionnaire *globals* ne contient pas de valeur pour la clef "
"``__builtins__``, une référence au dictionnaire du module :mod:`builtins` y "
"est inséré. Cela vous permet de contrôler quelles fonctions natives sont "
"exposées au code exécuté en insérant votre propre dictionnaire "
"``__builtins__`` dans *globals* avant de le donner à :func:`exec`."

#: ../Doc/library/functions.rst:455
msgid ""
"The built-in functions :func:`globals` and :func:`locals` return the current "
"global and local dictionary, respectively, which may be useful to pass "
"around for use as the second and third argument to :func:`exec`."
msgstr ""
"Les fonctions natives :func:`globals` et :func:`locals` donnent "
"respectivement les dictionnaires globaux et locaux, qui peuvent être utiles "
"en deuxième et troisième argument de :func:`exec`."

#: ../Doc/library/functions.rst:461
msgid ""
"The default *locals* act as described for function :func:`locals` below: "
"modifications to the default *locals* dictionary should not be attempted. "
"Pass an explicit *locals* dictionary if you need to see effects of the code "
"on *locals* after function :func:`exec` returns."
msgstr ""
"La valeur par défaut pour *locals* se comporte comme  la fonction :func:"
"`locals`: Il est déconseillé de modifier le dictionnaire *locals* par "
"défaut. Donnez un dictionnaire explicitement à *locals* si vous désirez "
"observer l'effet du code sur les variables locales, après que :func:`exec` "
"soit terminée."

#: ../Doc/library/functions.rst:469
msgid ""
"Construct an iterator from those elements of *iterable* for which *function* "
"returns true.  *iterable* may be either a sequence, a container which "
"supports iteration, or an iterator.  If *function* is ``None``, the identity "
"function is assumed, that is, all elements of *iterable* that are false are "
"removed."
msgstr ""
"Construit un itérateur depuis les éléments d'*iterable* pour lesquels "
"*function* donne vrai. *iterable* peut aussi bien être une séquence, un "
"conteneur qui supporte l'itération, ou un itérateur. Si *function* est "
"``None``, la fonction identité est prise, c'est à dire que tous les éléments "
"faux d'*iterable* sont supprimés."

#: ../Doc/library/functions.rst:475
msgid ""
"Note that ``filter(function, iterable)`` is equivalent to the generator "
"expression ``(item for item in iterable if function(item))`` if function is "
"not ``None`` and ``(item for item in iterable if item)`` if function is "
"``None``."
msgstr ""
"Notez que ``filter(fonction, iterable)`` est l'équivalent du générateur "
"``(item for item in iterable if fonction(item))`` si *fonction* n'est pas "
"``None`` et de ``(item for item in iterable if item)`` si *function* est "
"``None``."

#: ../Doc/library/functions.rst:480
msgid ""
"See :func:`itertools.filterfalse` for the complementary function that "
"returns elements of *iterable* for which *function* returns false."
msgstr ""
"Voir :func:`itertools.filterfalse` pour la fonction complémentaire qui donne "
"les éléments d'*iterable* pour lesquels *fonction* donne ``False``."

#: ../Doc/library/functions.rst:490
msgid "Return a floating point number constructed from a number or string *x*."
msgstr ""
"Donne un nombre a virgule flottante depuis un nombre ou une chaîne *x*."

#: ../Doc/library/functions.rst:492
msgid ""
"If the argument is a string, it should contain a decimal number, optionally "
"preceded by a sign, and optionally embedded in whitespace.  The optional "
"sign may be ``'+'`` or ``'-'``; a ``'+'`` sign has no effect on the value "
"produced.  The argument may also be a string representing a NaN (not-a-"
"number), or a positive or negative infinity.  More precisely, the input must "
"conform to the following grammar after leading and trailing whitespace "
"characters are removed:"
msgstr ""
"Si l'argument est une chaîne, elle devrait contenir un nombre decimal, "
"éventuellement précédé d'un signe, et pouvant être entouré d'espaces. Le "
"signe optionnel peut être ``'+'`` ou ``'-'``. Un signe ``'+'`` n'a pas "
"d'effet sur la valeur produite. L'argument peut aussi être une chaîne "
"représentant un NaN (*Not-a-Number*), l'infini positif, ou l'infini négatif. "
"Plus précisément, l'argument doit se conformer à la grammaire suivante, "
"après que les espaces en début et fin de chaîne aient été retirés :"

#: ../Doc/library/functions.rst:507
msgid ""
"Here ``floatnumber`` is the form of a Python floating-point literal, "
"described in :ref:`floating`.  Case is not significant, so, for example, "
"\"inf\", \"Inf\", \"INFINITY\" and \"iNfINity\" are all acceptable spellings "
"for positive infinity."
msgstr ""
"Ici ``floatnumber`` est un nombre a virgule flottante littéral Python, "
"décrit dans :ref:`floating`. La casse n'y est pas significative, donc, par "
"exemple, \"inf\", \" Inf\", \"INFINITY\", et \" iNfiNity\" sont tous des "
"orthographes valides pour un infini positif."

#: ../Doc/library/functions.rst:512
msgid ""
"Otherwise, if the argument is an integer or a floating point number, a "
"floating point number with the same value (within Python's floating point "
"precision) is returned.  If the argument is outside the range of a Python "
"float, an :exc:`OverflowError` will be raised."
msgstr ""
"Autrement, si l'argument est un entier ou un nombre à virgule flottante, un "
"nombre à virgule flottante de même valeur (en accord avec la précision des "
"nombres à virgule flottante de Python) est donné. Si l'argument est en "
"dehors de l'intervalle d'un nombre a virgule flottante pour Python, :exc:"
"`OverflowError` est levée."

#: ../Doc/library/functions.rst:517
msgid ""
"For a general Python object ``x``, ``float(x)`` delegates to ``x."
"__float__()``."
msgstr ""
"Pour un objet Python ``x``, ``float(x)`` est délégué à ``x.__float__()``."

#: ../Doc/library/functions.rst:520
msgid "If no argument is given, ``0.0`` is returned."
msgstr "Dans argument, ``0.0`` est donné."

#: ../Doc/library/functions.rst:522
msgid "Examples::"
msgstr "Exemples : ::"

#: ../Doc/library/functions.rst:535
msgid "The float type is described in :ref:`typesnumeric`."
msgstr "Le type *float* est décrit dans :ref:`typesnumeric`."

#: ../Doc/library/functions.rst:547
msgid ""
"Convert a *value* to a \"formatted\" representation, as controlled by "
"*format_spec*.  The interpretation of *format_spec* will depend on the type "
"of the *value* argument, however there is a standard formatting syntax that "
"is used by most built-in types: :ref:`formatspec`."
msgstr ""
"Convertit une valeur en sa représentation \"formatée\", tel que décrit par "
"*format_spec*. L'interprétation de *format_spec* dépend du type de la "
"valeur, cependant il existe une syntaxe standard utilisée par la plupart des "
"types natifs : :ref:`formatspec`."

#: ../Doc/library/functions.rst:552
msgid ""
"The default *format_spec* is an empty string which usually gives the same "
"effect as calling :func:`str(value) <str>`."
msgstr ""
"Par défaut, *format_spec* est une chaîne vide qui généralement donne le même "
"effet qu'appeler :func:`str(value) <str>`."

#: ../Doc/library/functions.rst:555
msgid ""
"A call to ``format(value, format_spec)`` is translated to ``type(value)."
"__format__(value, format_spec)`` which bypasses the instance dictionary when "
"searching for the value's :meth:`__format__` method.  A :exc:`TypeError` "
"exception is raised if the method search reaches :mod:`object` and the "
"*format_spec* is non-empty, or if either the *format_spec* or the return "
"value are not strings."
msgstr ""
"Un appel à ``format(value, format_spec)`` est transformé en ``type(value)."
"__format__(value, format_spec)``, qui contourne le dictionnaire de "
"l'instance lors de la recherche de la méthode :meth:`__fornat__`. Une "
"exception :exc:`TypeError` est levée si la recherche de la méthode atteint :"
"mod:`object` et que *format_spec* n'est pas vide, ou si soit *format_spec* "
"soit la le résultat ne sont pas des chaînes."

#: ../Doc/library/functions.rst:562
msgid ""
"``object().__format__(format_spec)`` raises :exc:`TypeError` if "
"*format_spec* is not an empty string."
msgstr ""
"``object().__format__(format_spec)`` lève :exc:`TypeError` si *format_spec* "
"n'est pas une chaîne vide."

#: ../Doc/library/functions.rst:571
msgid ""
"Return a new :class:`frozenset` object, optionally with elements taken from "
"*iterable*.  ``frozenset`` is a built-in class.  See :class:`frozenset` and :"
"ref:`types-set` for documentation about this class."
msgstr ""
"Donne un nouveau :class:`frozenset`, dont les objets sont éventuellement "
"tirés d'*iterable*. ``frozenset`` est une classe native. Voir :class:"
"`frozenset` et :ref:`types-set` pour leurs documentation."

#: ../Doc/library/functions.rst:575
msgid ""
"For other containers see the built-in :class:`set`, :class:`list`, :class:"
"`tuple`, and :class:`dict` classes, as well as the :mod:`collections` module."
msgstr ""
"Pour d'autres conteneurs, voyez les classes natives :class:`set`, :class:"
"`list`, :class:`tuple`, et :class:`dict`, ainsi que le module :mod:"
"`collections`."

#: ../Doc/library/functions.rst:582
msgid ""
"Return the value of the named attribute of *object*.  *name* must be a "
"string. If the string is the name of one of the object's attributes, the "
"result is the value of that attribute.  For example, ``getattr(x, "
"'foobar')`` is equivalent to ``x.foobar``.  If the named attribute does not "
"exist, *default* is returned if provided, otherwise :exc:`AttributeError` is "
"raised."
msgstr ""
"Donne la valeur de l'attribut nommé *name* de l'objet *object*. *name* doit "
"être une chaîne. Si la chaîne est le nom d'un des attributs de l'objet, le "
"résultat est la valeur de cet attribut. Par exemple, ``getattr(x, "
"'foobar')`` est équivalent à ``x.foobar``. Si l'attribut n'existe pas, et "
"que *default* est fourni, il est renvoyé, sinon l'exception :exc:"
"`AttributeError` est levée."

#: ../Doc/library/functions.rst:591
msgid ""
"Return a dictionary representing the current global symbol table. This is "
"always the dictionary of the current module (inside a function or method, "
"this is the module where it is defined, not the module from which it is "
"called)."
msgstr ""
"Donne une représentation de la table de symboles globaux sous forme d'un "
"dictionnaire. C'est toujours le dictionnaire du module courant (dans une "
"fonction ou méthode, c'est le module où elle est définie, et non le module "
"d'où elle est appelée)."

#: ../Doc/library/functions.rst:598
msgid ""
"The arguments are an object and a string.  The result is ``True`` if the "
"string is the name of one of the object's attributes, ``False`` if not. "
"(This is implemented by calling ``getattr(object, name)`` and seeing whether "
"it raises an :exc:`AttributeError` or not.)"
msgstr ""
"Les arguments sont : un objet et une chaîne. Le résultat est ``True`` si la "
"chaîne est le nom d'un des attributs de l'objet, sinon ``False``. "
"(L'implémentation appelle ``getattr(object, name)`` et regarde si une "
"exception :exc:`AttributeError` à été levée.)"

#: ../Doc/library/functions.rst:606
msgid ""
"Return the hash value of the object (if it has one).  Hash values are "
"integers.  They are used to quickly compare dictionary keys during a "
"dictionary lookup.  Numeric values that compare equal have the same hash "
"value (even if they are of different types, as is the case for 1 and 1.0)."
msgstr ""
"Donne la valeur de *hash* d'un objet (s'il en a une). Les valeurs de *hash* "
"sont des entiers. Elles sont utilisées pour comparer rapidement des clefs de "
"dictionnaire lors de leur recherche. Les valeurs numériques égales ont le "
"même *hash* (même si leurs types sont différents, comme pour ``1`` et "
"``1.0``)."

#: ../Doc/library/functions.rst:613
msgid ""
"For object's with custom :meth:`__hash__` methods, note that :func:`hash` "
"truncates the return value based on the bit width of the host machine. See :"
"meth:`__hash__` for details."
msgstr ""
"Pour les objets dont la méthode :meth:`__hash__` est implémentée, notez que :"
"func:`hash` tronque la valeur donnée en fonction du nombre de bits de la "
"machine hôte. Voir :meth:`__hash__` pour plus d'informations."

#: ../Doc/library/functions.rst:619
msgid ""
"Invoke the built-in help system.  (This function is intended for interactive "
"use.)  If no argument is given, the interactive help system starts on the "
"interpreter console.  If the argument is a string, then the string is looked "
"up as the name of a module, function, class, method, keyword, or "
"documentation topic, and a help page is printed on the console.  If the "
"argument is any other kind of object, a help page on the object is generated."
msgstr ""
"Invoque le système d'aide natif. (Cette fonction est destinée à l'usage en "
"mode interactif.) Soi aucun argument n'est fourni, le système d'aide démarre "
"dans l'interpréteur. Si l'argument est une chaîne, un module, une fonction, "
"une classe, une méthode, un mot clef, ou un sujet de documentation pourtant "
"ce nom est recherché, et une page d'aide est affichée sur la console. Si "
"l'argument est d'un autre type, une page d'aide sur cet objet est générée."

#: ../Doc/library/functions.rst:626
msgid ""
"This function is added to the built-in namespace by the :mod:`site` module."
msgstr ""
"Cette fonction est ajoutée à l'espace de noms natif par le module :mod:"
"`site`."

#: ../Doc/library/functions.rst:628
msgid ""
"Changes to :mod:`pydoc` and :mod:`inspect` mean that the reported signatures "
"for callables are now more comprehensive and consistent."
msgstr ""
"Les changements aux modules :mod:`pydoc` et :mod:`inspect` rendent les "
"signatures des appelables plus compréhensible et cohérente."

#: ../Doc/library/functions.rst:635
msgid ""
"Convert an integer number to a lowercase hexadecimal string prefixed with "
"\"0x\", for example:"
msgstr ""
"Convertis un nombre entier en sa représentation hexadécimale, en minuscule, "
"préfixée par \"0x\", par exemple :"

#: ../Doc/library/functions.rst:643
msgid ""
"If x is not a Python :class:`int` object, it has to define an __index__() "
"method that returns an integer."
msgstr ""
"Si ``x`` n'est pas un objet Python :class:`int`, il doit définir une méthode "
"``__index__`` donnant un entier."

#: ../Doc/library/functions.rst:646
msgid ""
"See also :func:`int` for converting a hexadecimal string to an integer using "
"a base of 16."
msgstr ""
"Voir aussi :func:`int` pour convertir une chaîne hexadécimale en un entier "
"en lui spécifiant 16 comme base."

#: ../Doc/library/functions.rst:651
msgid ""
"To obtain a hexadecimal string representation for a float, use the :meth:"
"`float.hex` method."
msgstr ""
"Pour obtenir une représentation hexadécimale sous forme de chaîne d'un "
"nombre à virgule flottante, utilisez la méthode :meth:`float.hex`."

#: ../Doc/library/functions.rst:657
msgid ""
"Return the \"identity\" of an object.  This is an integer which is "
"guaranteed to be unique and constant for this object during its lifetime. "
"Two objects with non-overlapping lifetimes may have the same :func:`id` "
"value."
msgstr ""
"Donne l'\"identité\" d'un objet. C'est un nombre entier garanti unique et "
"constant pour cet objet durant sa durée de vie. Deux objets sont les durées "
"de vie ne se chevauchent pas peuvent partager le même :func:`id`."

#: ../Doc/library/functions.rst:667
msgid ""
"If the *prompt* argument is present, it is written to standard output "
"without a trailing newline.  The function then reads a line from input, "
"converts it to a string (stripping a trailing newline), and returns that.  "
"When EOF is read, :exc:`EOFError` is raised.  Example::"
msgstr ""
"Si l'argument *prompt* est donné, il est écrit sur la sortie standard sans "
"le retour à la ligne final. La fonction lis ensuite une ligne sur l'entrée "
"standard et la convertit en chaîne (supprimant le retour à la ligne final) "
"quelle donne. Lorsque EOF est lu, :exc:`EOFError` est levée. Exemple : ::"

#: ../Doc/library/functions.rst:677
msgid ""
"If the :mod:`readline` module was loaded, then :func:`input` will use it to "
"provide elaborate line editing and history features."
msgstr ""
"Si le module :mod:`readline` est chargé, :func:`input` l'utilisera pour "
"fournir des fonctionnalités d'édition et d'historique élaborées."

#: ../Doc/library/functions.rst:684
msgid ""
"Return an integer object constructed from a number or string *x*, or return "
"``0`` if no arguments are given.  If *x* is a number, return :meth:`x."
"__int__() <object.__int__>`.  For floating point numbers, this truncates "
"towards zero."
msgstr ""
"Donne un entier construit depuis un nombre ou une chaîne *x*, ou ``0`` si "
"aucun argument n'est fourni. Si *x* est un nombre, :meth:`__int__() <object."
"__int__>` est donné. Les nombres à virgule flottante sont tronquées vers "
"zéro."

#: ../Doc/library/functions.rst:689
msgid ""
"If *x* is not a number or if *base* is given, then *x* must be a string, :"
"class:`bytes`, or :class:`bytearray` instance representing an :ref:`integer "
"literal <integers>` in radix *base*.  Optionally, the literal can be "
"preceded by ``+`` or ``-`` (with no space in between) and surrounded by "
"whitespace.  A base-n literal consists of the digits 0 to n-1, with ``a`` to "
"``z`` (or ``A`` to ``Z``) having values 10 to 35.  The default *base* is 10. "
"The allowed values are 0 and 2-36. Base-2, -8, and -16 literals can be "
"optionally prefixed with ``0b``/``0B``, ``0o``/``0O``, or ``0x``/``0X``, as "
"with integer literals in code.  Base 0 means to interpret exactly as a code "
"literal, so that the actual base is 2, 8, 10, or 16, and so that "
"``int('010', 0)`` is not legal, while ``int('010')`` is, as well as "
"``int('010', 8)``."
msgstr ""
"Si *x* n'est pas un nombre ou si *base* est fourni,  alors *x* doit être une "
"chaîne, un :class:`bytes`, ou un :class:`bytearray` représentant un :ref:"
"`entier littéral <integers>` de base *base* Le littéral peut être précédé "
"d'un  ``'+'`` ou d'un ``'-'``, et peut être entouré d'espaces. Un littéral "
"de base *n* est composé des symboles de 0 à n-1 où ``a`` jusqu'à ``z`` (ou "
"``A`` à ``Z``) représentent les valeurs de 10 à 35. La *base* par défaut est "
"10. Les valeurs autorisées pour *base* sont 0 et de 2 à 36. Les littéraux en "
"base 2, 8, et 16 peuvent être préfixés avec ``0b``/``0B``, ``0o``/``0O``, ou "
"``0x``/``0X`` tout comme les littéraux dans le code. Fournir 0 comme *base* "
"demande d'interpréter exactement comme un littéral dans Python, ainsi "
"``int('010', 0)`` n'est pas légal, alors que ``int('010')`` l'est tout comme "
"``int('010', 8)``."

#: ../Doc/library/functions.rst:702
msgid "The integer type is described in :ref:`typesnumeric`."
msgstr "Le type des entiers est décrit dans :ref:`typesnumeric`."

#: ../Doc/library/functions.rst:704
msgid ""
"If *base* is not an instance of :class:`int` and the *base* object has a :"
"meth:`base.__index__ <object.__index__>` method, that method is called to "
"obtain an integer for the base.  Previous versions used :meth:`base.__int__ "
"<object.__int__>` instead of :meth:`base.__index__ <object.__index__>`."
msgstr ""
"Si *base* n'est pas une instance d':class:`int` et que *base* a une méthode :"
"meth:`base.__index__ <object.__index__>`, cette méthode est appelée pour "
"obtenir un entier pour cette base. Les versions précédentes utilisaient :"
"meth:`base.__int__ <object.__int__>` au lieu de :meth:`base.__index__ "
"<object.__index__>`."

#: ../Doc/library/functions.rst:717
msgid ""
"Return true if the *object* argument is an instance of the *classinfo* "
"argument, or of a (direct, indirect or :term:`virtual <abstract base "
"class>`) subclass thereof.  If *object* is not an object of the given type, "
"the function always returns false. If *classinfo* is a tuple of type objects "
"(or recursively, other such tuples), return true if *object* is an instance "
"of any of the types. If *classinfo* is not a type or tuple of types and such "
"tuples, a :exc:`TypeError` exception is raised."
msgstr ""
"Donne ``True`` si *object* est une instance de *classinfo*, ou d'une de ses "
"classes filles, directe, indirecte, ou :term:`virtuelle <abstract base "
"class>`. Si *object* n'est pas un objet du type donné, la fonction donne "
"toujours ``False``. Si *classinfo* est un *tuple* de types (ou "
"récursivement, d'autres *tuples*), donne ``True`` si *object* est une "
"instance de n'importe quel de ces types. Si *classinfo* n'est ni un type ni "
"un *tuple* de types (et récursivement), une exception :exc:`TypeError` est "
"levée."

#: ../Doc/library/functions.rst:729
msgid ""
"Return true if *class* is a subclass (direct, indirect or :term:`virtual "
"<abstract base class>`) of *classinfo*.  A class is considered a subclass of "
"itself. *classinfo* may be a tuple of class objects, in which case every "
"entry in *classinfo* will be checked. In any other case, a :exc:`TypeError` "
"exception is raised."
msgstr ""
"Donne ``True`` si *class* est une classe fille (directe, indirecte, ou :term:"
"`virtual <abstract base class>`) de *classinfo*. Une classe est considérée "
"sous-classe d'elle même. *classinfo* peut être un tuple de classes, dans ce "
"cas la vérification sera faite pour chaque classe de *classinfo*. Dans tous "
"les autres cas, :exc:`TypeError` est levée."

#: ../Doc/library/functions.rst:738
msgid ""
"Return an :term:`iterator` object.  The first argument is interpreted very "
"differently depending on the presence of the second argument. Without a "
"second argument, *object* must be a collection object which supports the "
"iteration protocol (the :meth:`__iter__` method), or it must support the "
"sequence protocol (the :meth:`__getitem__` method with integer arguments "
"starting at ``0``).  If it does not support either of those protocols, :exc:"
"`TypeError` is raised. If the second argument, *sentinel*, is given, then "
"*object* must be a callable object.  The iterator created in this case will "
"call *object* with no arguments for each call to its :meth:`~iterator."
"__next__` method; if the value returned is equal to *sentinel*, :exc:"
"`StopIteration` will be raised, otherwise the value will be returned."
msgstr ""
"Donne un objet :term:`iterator`. Le premier argument est interprété très "
"différemment en fonction de la présence du second argument. Sans second "
"argument, *object* doit être une collection d'objets supportant le protocole "
"d'itération (la méthode :meth:`__iter__`), ou supportant le protocole des "
"séquences (la méthode :meth:`getitem`, avec des nombres entiers commençant "
"par ``0`` comme argument). S'il ne supporte aucun de ces protocoles, :exc:"
"`TypeError` est levée. Si le second argument *sentinel* est fourni, *objet* "
"doit être appelable. L'itérateur créé dans ce cas appellera *object* dans "
"argument à chaque appel de :meth:`~iterator.__next__`, si la valeur reçue "
"est égale à *sentinel* :exc:`StopIteration` est levée, autrement la valeur "
"est donnée."

#: ../Doc/library/functions.rst:751
msgid "See also :ref:`typeiter`."
msgstr "Voir aussi :ref:`typeiter`."

#: ../Doc/library/functions.rst:753
msgid ""
"One useful application of the second form of :func:`iter` is to read lines "
"of a file until a certain line is reached.  The following example reads a "
"file until the :meth:`~io.TextIOBase.readline` method returns an empty "
"string::"
msgstr ""
"Une autre application utile de la deuxième forme de :func:`iter` est de lire "
"les lignes d'un fichier jusqu'à ce qu'un certaine ligne soit atteinte. "
"L'exemple suivant lis un fichier jusqu'à ce que :meth:`~io.TextIOBase."
"readline` donne une ligne vide : ::"

#: ../Doc/library/functions.rst:764
msgid ""
"Return the length (the number of items) of an object.  The argument may be a "
"sequence (such as a string, bytes, tuple, list, or range) or a collection "
"(such as a dictionary, set, or frozen set)."
msgstr ""
"Donne la longueur (nombre d'éléments) d'un objet. L'argument peut être une "
"séquence (tel qu'une chaîne, un objet  ``bytes``, ``tuple``, ``list`` ou "
"``range``) ou une collection (tel qu'un ``dict``, ``set`` ou ``frozenset``)."

#: ../Doc/library/functions.rst:773
msgid ""
"Rather than being a function, :class:`list` is actually a mutable sequence "
"type, as documented in :ref:`typesseq-list` and :ref:`typesseq`."
msgstr ""
"Plutôt qu'être une fonction, :class:`list` est en fait un type de séquence "
"variable, tel que documenté dans :ref:`typesseq-list` et :ref:`typesseq`."

#: ../Doc/library/functions.rst:779
msgid ""
"Update and return a dictionary representing the current local symbol table. "
"Free variables are returned by :func:`locals` when it is called in function "
"blocks, but not in class blocks."
msgstr ""
"Met à jour et donne un dictionnaire représentant la table des symboles "
"locaux. Les variables libres sont données par :func:`locals` lorsqu'elle est "
"appelée dans le corps d'une fonction, mais pas dans le corps d'une classe."

#: ../Doc/library/functions.rst:784
msgid ""
"The contents of this dictionary should not be modified; changes may not "
"affect the values of local and free variables used by the interpreter."
msgstr ""
"Le contenu de ce dictionnaire ne devrait pas être modifié, les changements "
"peuvent ne pas affecter les valeurs des variables locales ou libres "
"utilisées par l'interpréteur."

#: ../Doc/library/functions.rst:789
msgid ""
"Return an iterator that applies *function* to every item of *iterable*, "
"yielding the results.  If additional *iterable* arguments are passed, "
"*function* must take that many arguments and is applied to the items from "
"all iterables in parallel.  With multiple iterables, the iterator stops when "
"the shortest iterable is exhausted.  For cases where the function inputs are "
"already arranged into argument tuples, see :func:`itertools.starmap`\\."
msgstr ""
"Donne un itérateur appliquant *function* à chaque élément de *iterable*, et "
"donnant ses résultats au fur et à mesure avec ``yield``. Si d'autres "
"*iterable* sont fournis, *function* doit prendre autant d'arguments, et sera "
"appelée avec les éléments de tous les iterable en parallèle. Avec plusieurs "
"iterables, l'itération s'arrête avec l'itérable le plus court. Pour les cas "
"où les arguments seraient déjà rangés sous forme de tuples, voir :func:"
"`itertools.starmap`."

#: ../Doc/library/functions.rst:800
msgid ""
"Return the largest item in an iterable or the largest of two or more "
"arguments."
msgstr ""
"Donne l'élément le plus grand dans un iterable, ou l'argument le plus grand "
"parmi au moins deux arguments."

#: ../Doc/library/functions.rst:803
msgid ""
"If one positional argument is provided, it should be an :term:`iterable`. "
"The largest item in the iterable is returned.  If two or more positional "
"arguments are provided, the largest of the positional arguments is returned."
msgstr ""
"Si un seul argument positionnel est fourni, il doit être :term:`iterable`. "
"Le plus grand élément de l'itérable est donné. Si au moins deux arguments "
"positionnels sont fournis, l'argument le plus grand sera donné."

#: ../Doc/library/functions.rst:808 ../Doc/library/functions.rst:842
msgid ""
"There are two optional keyword-only arguments. The *key* argument specifies "
"a one-argument ordering function like that used for :meth:`list.sort`. The "
"*default* argument specifies an object to return if the provided iterable is "
"empty. If the iterable is empty and *default* is not provided, a :exc:"
"`ValueError` is raised."
msgstr ""
"Elle accepte deux arguments par mot clef optionnels. L'argument *key* "
"spécifie une fonction à un argument permettant de trier comme pour :meth:"
"`list.sort`. L'argument *default* quant à lui fournit un objet à donner si "
"l'itérable fourni est vide. Si l'itérable est vide et que *default* n'est "
"pas fourni, :exc:`ValueError` est levée."

#: ../Doc/library/functions.rst:814
msgid ""
"If multiple items are maximal, the function returns the first one "
"encountered.  This is consistent with other sort-stability preserving tools "
"such as ``sorted(iterable, key=keyfunc, reverse=True)[0]`` and ``heapq."
"nlargest(1, iterable, key=keyfunc)``."
msgstr ""
"Si plusieurs éléments représentent la plus grande valeur, le premier "
"rencontré est donné. C'est cohérent avec d'autres outils préservant une "
"stabilité lors du tri, tel que ``sorted(iterable, key=keyfunc, reverse=True)"
"[0]`` et ``heapq.nlargest(1, iterable, key=keyfunc)``."

#: ../Doc/library/functions.rst:819 ../Doc/library/functions.rst:853
msgid "The *default* keyword-only argument."
msgstr "L'argument exclusivement par mot clef *default*."

#: ../Doc/library/functions.rst:827
msgid ""
"Return a \"memory view\" object created from the given argument.  See :ref:"
"`typememoryview` for more information."
msgstr ""
"Donne une \"vue mémoire\" (*memory view*) créée depuis l'argument. Voir :ref:"
"`typememoryview` pour plus d'informations."

#: ../Doc/library/functions.rst:834
msgid ""
"Return the smallest item in an iterable or the smallest of two or more "
"arguments."
msgstr ""
"Donne le plus petit élément d'un itérable ou le plus petit d'au moins deux "
"arguments."

#: ../Doc/library/functions.rst:837
msgid ""
"If one positional argument is provided, it should be an :term:`iterable`. "
"The smallest item in the iterable is returned.  If two or more positional "
"arguments are provided, the smallest of the positional arguments is returned."
msgstr ""
"Si un seul argument est fourni, il doit être :term:`iterable`. Le plus petit "
"élément de l'itérable est donné. Si au moins deux arguments positionnels "
"sont fournis le plus petit argument positionnel est donné."

#: ../Doc/library/functions.rst:848
msgid ""
"If multiple items are minimal, the function returns the first one "
"encountered.  This is consistent with other sort-stability preserving tools "
"such as ``sorted(iterable, key=keyfunc)[0]`` and ``heapq.nsmallest(1, "
"iterable, key=keyfunc)``."
msgstr ""
"Si plusieurs éléments sont minimaux, la fonction donne le premier. C'est "
"cohérent avec d'autres outils préservant une stabilité lors du tri, tel que "
"``sorted(iterable, key=keyfunc)[0]`` et ``heapq.nsmallest(1, iterable, "
"key=keyfunc)``."

#: ../Doc/library/functions.rst:859
msgid ""
"Retrieve the next item from the *iterator* by calling its :meth:`~iterator."
"__next__` method.  If *default* is given, it is returned if the iterator is "
"exhausted, otherwise :exc:`StopIteration` is raised."
msgstr ""
"Donne l'élément suivant d'*iterator* en appelant sa méthode :meth:`~iterator."
"__next__`. Si *default* est fourni, il sera donné si l'itérateur est épousé, "
"sinon :exc:`StopIteration` est levée."

#: ../Doc/library/functions.rst:866
msgid ""
"Return a new featureless object.  :class:`object` is a base for all classes. "
"It has the methods that are common to all instances of Python classes.  This "
"function does not accept any arguments."
msgstr ""
"Donne un objet vide. :class:`object` est la classe parente de toute les "
"classes. C'est elle qui porte les méthodes communes à toutes les instances "
"de classes en Python. Cette fonction n'accepte aucun argument."

#: ../Doc/library/functions.rst:872
msgid ""
":class:`object` does *not* have a :attr:`~object.__dict__`, so you can't "
"assign arbitrary attributes to an instance of the :class:`object` class."
msgstr ""
":class:`object` n'a *pas* d'attribut :attr:`~object.__dict__`, vous ne "
"pouvez donc pas assigner d'attributs arbitraire à une instance d':class:"
"`object`."

#: ../Doc/library/functions.rst:878
msgid ""
"Convert an integer number to an octal string.  The result is a valid Python "
"expression.  If *x* is not a Python :class:`int` object, it has to define "
"an :meth:`__index__` method that returns an integer."
msgstr ""
"Convertit un entier en sa représentation octale dans une chaîne. Le résultat "
"est une expression Python valide. Si *x* n'est pas un objet :class:`int` de "
"Python, il doit définir une méthode :meth:`__index__` qui donne un entier."

#: ../Doc/library/functions.rst:888
msgid ""
"Open *file* and return a corresponding :term:`file object`.  If the file "
"cannot be opened, an :exc:`OSError` is raised."
msgstr ""
"Ouvre *file* et donne un :term:`file object` correspondant. Si le fichier ne "
"peut pas être ouvert, une :exc:`OSError` est levée."

#: ../Doc/library/functions.rst:891
msgid ""
"*file* is a :term:`path-like object` giving the pathname (absolute or "
"relative to the current working directory) of the file to be opened or an "
"integer file descriptor of the file to be wrapped.  (If a file descriptor is "
"given, it is closed when the returned I/O object is closed, unless *closefd* "
"is set to ``False``.)"
msgstr ""

#: ../Doc/library/functions.rst:897
msgid ""
"*mode* is an optional string that specifies the mode in which the file is "
"opened.  It defaults to ``'r'`` which means open for reading in text mode. "
"Other common values are ``'w'`` for writing (truncating the file if it "
"already exists), ``'x'`` for exclusive creation and ``'a'`` for appending "
"(which on *some* Unix systems, means that *all* writes append to the end of "
"the file regardless of the current seek position).  In text mode, if "
"*encoding* is not specified the encoding used is platform dependent: "
"``locale.getpreferredencoding(False)`` is called to get the current locale "
"encoding. (For reading and writing raw bytes use binary mode and leave "
"*encoding* unspecified.)  The available modes are:"
msgstr ""
"*mode* est une chaîne optionnelle permettant de spécifier dans quel mode le "
"fichier est ouvert. Par défaut, *mode* vaut ``'r'`` qui signifie \"ouvrir en "
"lecture pour du texte\". ``'w'`` est aussi une valeur classique, permettant "
"d'écrire (vidant le fichier s'il existe), ainsi que ``'x'`` permettant une "
"création exclusive et ``'a'`` pour ajouter à la fin du fichier (qui sur "
"certains systèmes Unix signifie que *toutes* les écritures seront des ajouts "
"en fin de fichier peu importe la position demandée). En mode texte, si "
"*encoding* n'est pas spécifié l'encodage utilisé est dépendant de la "
"plateforme : ``locale.getpreferredencoding(False)`` est appelée pour obtenir "
"l'encodage de la locale actuelle. (Pour lire et écrire des octets bruts, "
"utilisez le mode binaire en laissant *encoding* non spécifié.) Les modes "
"disponibles sont :"

#: ../Doc/library/functions.rst:909
msgid "Character"
msgstr "Caractère"

#: ../Doc/library/functions.rst:909
msgid "Meaning"
msgstr "Signification"

#: ../Doc/library/functions.rst:911
msgid "``'r'``"
msgstr "``'r'``"

#: ../Doc/library/functions.rst:911
msgid "open for reading (default)"
msgstr "ouvre en lecture (par défaut)"

#: ../Doc/library/functions.rst:912
msgid "``'w'``"
msgstr "``'w'``"

#: ../Doc/library/functions.rst:912
msgid "open for writing, truncating the file first"
msgstr "ouvre en écriture, tronquant le fichier"

#: ../Doc/library/functions.rst:913
msgid "``'x'``"
msgstr "``'x'``"

#: ../Doc/library/functions.rst:913
msgid "open for exclusive creation, failing if the file already exists"
msgstr "ouvre pour une création exclusive, échouant si le fichier existe déjà"

#: ../Doc/library/functions.rst:914
msgid "``'a'``"
msgstr "``'a'``"

#: ../Doc/library/functions.rst:914
msgid "open for writing, appending to the end of the file if it exists"
msgstr "ouvre en écriture, ajoutant à la fin du fichier s'il existe"

#: ../Doc/library/functions.rst:915
msgid "``'b'``"
msgstr "``'b'``"

#: ../Doc/library/functions.rst:915
msgid "binary mode"
msgstr "mode binaire"

#: ../Doc/library/functions.rst:916
msgid "``'t'``"
msgstr "``'t'``"

#: ../Doc/library/functions.rst:916
msgid "text mode (default)"
msgstr "mode texte (par défaut)"

#: ../Doc/library/functions.rst:917
msgid "``'+'``"
msgstr "``'+'``"

#: ../Doc/library/functions.rst:917
msgid "open a disk file for updating (reading and writing)"
msgstr "ouvre un fichier pour le modifier (lire et écrire)"

#: ../Doc/library/functions.rst:918
msgid "``'U'``"
msgstr "``'U'``"

#: ../Doc/library/functions.rst:918
msgid ":term:`universal newlines` mode (deprecated)"
msgstr "mode :term:`universal newlines` (déprécié)"

#: ../Doc/library/functions.rst:921
msgid ""
"The default mode is ``'r'`` (open for reading text, synonym of ``'rt'``). "
"For binary read-write access, the mode ``'w+b'`` opens and truncates the "
"file to 0 bytes.  ``'r+b'`` opens the file without truncation."
msgstr ""
"Les mode par défaut est ``'r'`` (ouvrir pour lire du texte, synonyme de "
"``'rt'``). Pour un accès en lecture écriture binaire, le mode ``'w+b'`` "
"ouvre et vide le fichier. ``'r+b'`` ouvre le fichier sans le vider."

#: ../Doc/library/functions.rst:925
msgid ""
"As mentioned in the :ref:`io-overview`, Python distinguishes between binary "
"and text I/O.  Files opened in binary mode (including ``'b'`` in the *mode* "
"argument) return contents as :class:`bytes` objects without any decoding.  "
"In text mode (the default, or when ``'t'`` is included in the *mode* "
"argument), the contents of the file are returned as :class:`str`, the bytes "
"having been first decoded using a platform-dependent encoding or using the "
"specified *encoding* if given."
msgstr ""
"Tel que mentionné dans :ref:`io-overview`, Python fait la différence entre "
"les I/O binaire et texte. Les fichiers ouverts en mode binaire (avec '``b``' "
"dans *mode*) donnent leur contenu sous forme de :class:`bytes` sans "
"décodage. en mode texte (par défaut, ou lorsque ``'t'`` est dans le *mode*), "
"le contenu du fichier est donné sous forme de :class:`str` les octets ayant "
"été décodés au préalable en utilisant un encodage deduit de l'environnement "
"ou *encoding* s'il est donné."

#: ../Doc/library/functions.rst:935
msgid ""
"Python doesn't depend on the underlying operating system's notion of text "
"files; all the processing is done by Python itself, and is therefore "
"platform-independent."
msgstr ""
"Python ne dépend pas de l'éventuelle notion de fichier texte du système sous "
"jacent, tout est effectué par Python lui même, et ainsi indépendant de la "
"plateforme."

#: ../Doc/library/functions.rst:939
msgid ""
"*buffering* is an optional integer used to set the buffering policy.  Pass 0 "
"to switch buffering off (only allowed in binary mode), 1 to select line "
"buffering (only usable in text mode), and an integer > 1 to indicate the "
"size in bytes of a fixed-size chunk buffer.  When no *buffering* argument is "
"given, the default buffering policy works as follows:"
msgstr ""
"*buffering* est un entier optionnel permettant de configurer l'espace "
"tampon. Donnez 0 pour désactiver l'espace tampon (seulement autorisé en mode "
"binaire), 1 pour avoir un *buffer* travaillant ligne par ligne (seulement "
"disponible en mode texte), ou un entier supérieur à 1 pour donner la taille "
"en octets d'un tampon de taille fixe. Sans l'argument *buffering*, les "
"comportements par défaut sont les suivants :"

#: ../Doc/library/functions.rst:945
msgid ""
"Binary files are buffered in fixed-size chunks; the size of the buffer is "
"chosen using a heuristic trying to determine the underlying device's \"block "
"size\" and falling back on :attr:`io.DEFAULT_BUFFER_SIZE`.  On many systems, "
"the buffer will typically be 4096 or 8192 bytes long."
msgstr ""
"Les fichiers binaires sont les dans un tampon de taille fixe, dont la taille "
"est choisie par une heuristique essayant de déterminer la taille des blocs "
"du système sous jacent, ou en utilisant par défaut :attr:`io."
"DEFAULT_BUFFER_SIZE`. Sur de nombreux systèmes, le tampon sera de 4096 ou "
"8192 octets."

#: ../Doc/library/functions.rst:950
msgid ""
"\"Interactive\" text files (files for which :meth:`~io.IOBase.isatty` "
"returns ``True``) use line buffering.  Other text files use the policy "
"described above for binary files."
msgstr ""
"Les fichiers texte \"interactifs\" (fichiers pour lesquels :meth:`io.IOBase."
"isatty` donne ``True``) utilisent un tampon par lignes. Les autres fichiers "
"texte sont traités comme les fichiers binaires."

#: ../Doc/library/functions.rst:954
msgid ""
"*encoding* is the name of the encoding used to decode or encode the file. "
"This should only be used in text mode.  The default encoding is platform "
"dependent (whatever :func:`locale.getpreferredencoding` returns), but any :"
"term:`text encoding` supported by Python can be used.  See the :mod:`codecs` "
"module for the list of supported encodings."
msgstr ""
"*encoding* est le nom de l'encodage utilisé pour encoder ou décoder le "
"fichier. Il doit seulement être utilisé en mode texte. L'encodage par défaut "
"dépend de la plateforme (ce que :func:`locale.getpreferredencoding` donne), "
"mais n'importe quel :term:`text encoding` supporté par Python peut être "
"utilisé. Voir :mod:`codecs` pour une liste des encodages supportés."

#: ../Doc/library/functions.rst:961
msgid ""
"*errors* is an optional string that specifies how encoding and decoding "
"errors are to be handled--this cannot be used in binary mode. A variety of "
"standard error handlers are available (listed under :ref:`error-handlers`), "
"though any error handling name that has been registered with :func:`codecs."
"register_error` is also valid.  The standard names include:"
msgstr ""
"*errors* est une chaîne facultative spécifiant comment les erreurs "
"d'encodage et de décodages sont gérées, ce n'est pas utilisable en mode "
"binaire. Pléthore gestionnaires d'erreurs standards sont disponibles (listés "
"sous :ref:`error-handlers`), aussi, tout nom de gestionnaire d'erreur "
"enregistré avec :func:`codecs.register_error` est aussi un argument valide. "
"Les noms standards sont :"

#: ../Doc/library/functions.rst:969
msgid ""
"``'strict'`` to raise a :exc:`ValueError` exception if there is an encoding "
"error.  The default value of ``None`` has the same effect."
msgstr ""
"``'strict'`` pour lever une :exc:`ValueError` si une erreur d'encodage est "
"rencontrée. La valeur par défaut, ``None``, a le même effet."

#: ../Doc/library/functions.rst:973
msgid ""
"``'ignore'`` ignores errors.  Note that ignoring encoding errors can lead to "
"data loss."
msgstr ""
"``'ignore'`` ignore les erreures. Notez qu'ignorer les erreurs d'encodage "
"peut mener à des pertes de données."

#: ../Doc/library/functions.rst:976
msgid ""
"``'replace'`` causes a replacement marker (such as ``'?'``) to be inserted "
"where there is malformed data."
msgstr ""
"``'replace'`` insère un marqueur de substitution (tel que ``'?'``) en place "
"des données malformées."

#: ../Doc/library/functions.rst:979
msgid ""
"``'surrogateescape'`` will represent any incorrect bytes as code points in "
"the Unicode Private Use Area ranging from U+DC80 to U+DCFF.  These private "
"code points will then be turned back into the same bytes when the "
"``surrogateescape`` error handler is used when writing data.  This is useful "
"for processing files in an unknown encoding."
msgstr ""
"``'surrogateescape'`` représentera chaque octet incorrect par un code "
"caractère de la zone *Private Use Area* d'Unicode, de U+DC80 to U+DCFF. Ces "
"codes caractères privés seront ensuite transformés dans les mêmes octets "
"erronés si le gestionnaire d'erreur ``surrogateescape`` est utilisé lors de "
"l'écriture de la donnée. C'est utile pour traiter des fichiers d'un encodage "
"inconnu."

#: ../Doc/library/functions.rst:986
msgid ""
"``'xmlcharrefreplace'`` is only supported when writing to a file. Characters "
"not supported by the encoding are replaced with the appropriate XML "
"character reference ``&#nnn;``."
msgstr ""
"``'xmlcharrefreplace'`` est seulement supporté à l'écriture vers un fichier. "
"Les caractères non gérés par l'encodage sont remplacés par une référence de "
"caractère XML ``&#nnn;``."

#: ../Doc/library/functions.rst:990
msgid ""
"``'backslashreplace'`` replaces malformed data by Python's backslashed "
"escape sequences."
msgstr ""
"``'backslashreplace'`` remplace les données malformée par des séquences "
"d'échappement Python (utilisant des *backslash*)."

#: ../Doc/library/functions.rst:993
msgid ""
"``'namereplace'`` (also only supported when writing) replaces unsupported "
"characters with ``\\N{...}`` escape sequences."
msgstr ""
"``'namereplace'`` (aussi supporté lors de l'écriture) remplace les "
"caractères non supportés par des séquences d'échappement ``\\N{...}``."

#: ../Doc/library/functions.rst:999
msgid ""
"*newline* controls how :term:`universal newlines` mode works (it only "
"applies to text mode).  It can be ``None``, ``''``, ``'\\n'``, ``'\\r'``, "
"and ``'\\r\\n'``.  It works as follows:"
msgstr ""
"*newline* contrôle comment le mode :term:`universal newlines` fonctionne "
"(seulement en mode texte). Il eut être ``None``, ``''``, ``'\\n'``, "
"``'\\r'``, and ``'\\r\\n'``.  Il fonctionne comme suit :"

#: ../Doc/library/functions.rst:1003
msgid ""
"When reading input from the stream, if *newline* is ``None``, universal "
"newlines mode is enabled.  Lines in the input can end in ``'\\n'``, "
"``'\\r'``, or ``'\\r\\n'``, and these are translated into ``'\\n'`` before "
"being returned to the caller.  If it is ``''``, universal newlines mode is "
"enabled, but line endings are returned to the caller untranslated.  If it "
"has any of the other legal values, input lines are only terminated by the "
"given string, and the line ending is returned to the caller untranslated."
msgstr ""
"Lors de la lecture, si *newline* est ``None``, le mode *universal newlines* "
"est activé. Les lignes lues peuvent terminer par ``'\\n'``, ``'\\r'``, ou "
"``'\\r\\n'``, qui sont remplacés par ``'\\n'``, avant d'être données à "
"l'appelant. S'il vaut ``'*'``, le mode *universal newline* est activé mais "
"les fin de lignes ne sont pas remplacés. S'il a n'importe quel autre valeur "
"autorisée, les lignes sont seulement terminées par la chaîne donnée, qui est "
"rendue tel qu'elle."

#: ../Doc/library/functions.rst:1011
msgid ""
"When writing output to the stream, if *newline* is ``None``, any ``'\\n'`` "
"characters written are translated to the system default line separator, :"
"data:`os.linesep`.  If *newline* is ``''`` or ``'\\n'``, no translation "
"takes place.  If *newline* is any of the other legal values, any ``'\\n'`` "
"characters written are translated to the given string."
msgstr ""
"Lors de l'écriture, si *newline* est ``None``, chaque ``'\\n'`` est remplacé "
"par le séparateur de lignes par défaut du système :data:`os.linesep`.  Si "
"*newline* est ``*`` ou ``'\\n'`` aucun remplacent n'est effectué. Si "
"*newline* est un autre caractère valide, chaque ``'\\n'`` sera remplacé par "
"la chaîne donnée."

#: ../Doc/library/functions.rst:1017
msgid ""
"If *closefd* is ``False`` and a file descriptor rather than a filename was "
"given, the underlying file descriptor will be kept open when the file is "
"closed.  If a filename is given *closefd* must be ``True`` (the default) "
"otherwise an error will be raised."
msgstr ""
"Si *closefd* est ``False`` et qu'un descripteur de fichier est fourni plutôt "
"qu'un nom de fichier, le descripteur de fichier sera laissé ouvert lorsque "
"le fichier sera fermé. Si un nom de fichier est donné, *closefd* doit rester "
"``True`` (la valeur par défaut) sans quoi une erreur est levée."

#: ../Doc/library/functions.rst:1022
msgid ""
"A custom opener can be used by passing a callable as *opener*. The "
"underlying file descriptor for the file object is then obtained by calling "
"*opener* with (*file*, *flags*). *opener* must return an open file "
"descriptor (passing :mod:`os.open` as *opener* results in functionality "
"similar to passing ``None``)."
msgstr ""
"Un *opener* personnalisé peut être utilisé en fournissant un appelable comme "
"*opener*. Le descripteur de fichier de cet objet fichier sera alors obtenu "
"en appelant *opener* avec (*file*, *flags*). *opener* doit donner un "
"descripteur de fichier ouvert (fournir :mod:`os.open` en temps qu'*opener* "
"aura le même effet que donner ``None``)."

#: ../Doc/library/functions.rst:1028
msgid "The newly created file is :ref:`non-inheritable <fd_inheritance>`."
msgstr ""
"Il n'est :ref:`pas possible d'hériter du fichier <fd_inheritance>` "
"nouvellement créé."

#: ../Doc/library/functions.rst:1030
msgid ""
"The following example uses the :ref:`dir_fd <dir_fd>` parameter of the :func:"
"`os.open` function to open a file relative to a given directory::"
msgstr ""
"L'exemple suivant utilise le paramètre :ref:`dir_fd <dir_fd>` de la "
"fonction :func:`os.open` pour ouvrir un fichier relatif au dossier courant ::"

#: ../Doc/library/functions.rst:1043
msgid ""
"The type of :term:`file object` returned by the :func:`open` function "
"depends on the mode.  When :func:`open` is used to open a file in a text "
"mode (``'w'``, ``'r'``, ``'wt'``, ``'rt'``, etc.), it returns a subclass of :"
"class:`io.TextIOBase` (specifically :class:`io.TextIOWrapper`).  When used "
"to open a file in a binary mode with buffering, the returned class is a "
"subclass of :class:`io.BufferedIOBase`.  The exact class varies: in read "
"binary mode, it returns an :class:`io.BufferedReader`; in write binary and "
"append binary modes, it returns an :class:`io.BufferedWriter`, and in read/"
"write mode, it returns an :class:`io.BufferedRandom`.  When buffering is "
"disabled, the raw stream, a subclass of :class:`io.RawIOBase`, :class:`io."
"FileIO`, is returned."
msgstr ""
"Le type de :term:`file object` donné par la fonction :func:`open` dépend du "
"mode. Lorsque :func:`open` est utilisé pour ouvrir un fichier en mode texte "
"(``w``, ``r``, ``wt``, ``rt``, etc.), il donne une classe fille de :class:"
"`io.TextIOBase` (spécifiquement : :class:`io.TextIOWrapper`). Lors de "
"l'ouverture d'un fichier en mode binaire avec tampon, la classe donnée sera "
"une fille de :class:`io.BufferedIOBase`. La classe exacte varie : en lecture "
"en mode mode binaire elle donne une :class:`io.BufferedReader`, en écriture "
"et ajout en mode binaire c'est une :class:`io.BufferedWriter`, et en lecture/"
"écriture, c'est une :class:`io.BufferedRandom`. Lorsque le tampon est "
"désactivé, le flux brut, une classe fille de :class:`io.RawIOBase`, :class:"
"`io.FileIO` est donnée."

#: ../Doc/library/functions.rst:1064
msgid ""
"See also the file handling modules, such as, :mod:`fileinput`, :mod:`io` "
"(where :func:`open` is declared), :mod:`os`, :mod:`os.path`, :mod:"
"`tempfile`, and :mod:`shutil`."
msgstr ""
"Consultez aussi les modules de gestion de fichiers tel que :mod:"
"`fileinput`, :mod:`io` (où :func:`open` est déclarée), :mod:`os`, :mod:`os."
"path`, :mod:`tmpfile`, et :mod:`shutil`."

#: ../Doc/library/functions.rst:1071
msgid "The *opener* parameter was added."
msgstr ""

#: ../Doc/library/functions.rst:1072
msgid "The ``'x'`` mode was added."
msgstr ""

#: ../Doc/library/functions.rst:1073
msgid ":exc:`IOError` used to be raised, it is now an alias of :exc:`OSError`."
msgstr ""

#: ../Doc/library/functions.rst:1074
msgid ":exc:`FileExistsError` is now raised if the file opened in exclusive"
msgstr ""

#: ../Doc/library/functions.rst:1075
msgid "creation mode (``'x'``) already exists."
msgstr ""

#: ../Doc/library/functions.rst:1080
msgid "The file is now non-inheritable."
msgstr "Il n'est plus possible d'hériter de *file*."

#: ../Doc/library/functions.rstNone
msgid ""
"Deprecated since version 3.4, will be removed in version 4.0: The 'U' mode."
msgstr ""

#: ../Doc/library/functions.rst:1084
msgid "The ``'U'`` mode."
msgstr "Le mode '``U'``."

#: ../Doc/library/functions.rst:1089
msgid ""
"If the system call is interrupted and the signal handler does not raise an "
"exception, the function now retries the system call instead of raising an :"
"exc:`InterruptedError` exception (see :pep:`475` for the rationale)."
msgstr ""
"Si l'appel système est interrompu et que le gestionnaire de signal ne lève "
"aucune exception, la fonction réessaye l'appel système au lieu de lever une :"
"exc:`InterruptedError` (voir la :pep:`475` à propos du raisonnement)."

#: ../Doc/library/functions.rst:1092
msgid "The ``'namereplace'`` error handler was added."
msgstr ""

#: ../Doc/library/functions.rst:1097
msgid "Support added to accept objects implementing :class:`os.PathLike`."
msgstr ""

#: ../Doc/library/functions.rst:1098
msgid ""
"On Windows, opening a console buffer may return a subclass of :class:`io."
"RawIOBase` other than :class:`io.FileIO`."
msgstr ""

#: ../Doc/library/functions.rst:1103
msgid ""
"Given a string representing one Unicode character, return an integer "
"representing the Unicode code point of that character.  For example, "
"``ord('a')`` returns the integer ``97`` and ``ord('€')`` (Euro sign) returns "
"``8364``.  This is the inverse of :func:`chr`."
msgstr ""

#: ../Doc/library/functions.rst:1111
msgid ""
"Return *x* to the power *y*; if *z* is present, return *x* to the power *y*, "
"modulo *z* (computed more efficiently than ``pow(x, y) % z``). The two-"
"argument form ``pow(x, y)`` is equivalent to using the power operator: "
"``x**y``."
msgstr ""
"Donne *x* puissance *y*, et si *z* est présent, donne *x* puissance *y* "
"modulo *z* (calculé de manière plus efficiente que ``pow(x, y) % z``). La "
"forme à deux arguments est équivalent à ``x**y``."

#: ../Doc/library/functions.rst:1115
msgid ""
"The arguments must have numeric types.  With mixed operand types, the "
"coercion rules for binary arithmetic operators apply.  For :class:`int` "
"operands, the result has the same type as the operands (after coercion) "
"unless the second argument is negative; in that case, all arguments are "
"converted to float and a float result is delivered.  For example, ``10**2`` "
"returns ``100``, but ``10**-2`` returns ``0.01``.  If the second argument is "
"negative, the third argument must be omitted.  If *z* is present, *x* and "
"*y* must be of integer types, and *y* must be non-negative."
msgstr ""
"Les arguments doivent être de types numériques. Avec des opérandes de "
"différents types, les mêmes règles de coercition que celles des opérateurs "
"arithmétiques binaires s'appliquent. Pour des opérandes de type :class:"
"`int`, le résultat sera de même type que les opérandes (après coercition) "
"sauf si le second argument est négatif, dans ce cas, les arguments sont "
"convertis en ``float``, et le résultat sera un ``float`` aussi. Par exemple, "
"``10**2`` donne ``100``, alors que ``10**-2`` donne ``0.01``. Si le second "
"argument est négatif, le troisième doit être omis. Si *z* est fourni, *x* et "
"*y* doivent être des entiers et *y* positif."

#: ../Doc/library/functions.rst:1127
msgid ""
"Print *objects* to the text stream *file*, separated by *sep* and followed "
"by *end*.  *sep*, *end* and *file*, if present, must be given as keyword "
"arguments."
msgstr ""
"Écrit *objects* dans le flux texte *file*, séparés par *sep* et suivis de "
"*end*. *sep*, *end*, et *file*, s'ils sont présents, doivent être données "
"par mot clef."

#: ../Doc/library/functions.rst:1131
msgid ""
"All non-keyword arguments are converted to strings like :func:`str` does and "
"written to the stream, separated by *sep* and followed by *end*.  Both *sep* "
"and *end* must be strings; they can also be ``None``, which means to use the "
"default values.  If no *objects* are given, :func:`print` will just write "
"*end*."
msgstr ""
"Tous les arguments positionnels sont convertis en chaîne comme le fait :func:"
"`str`, puis écrits sur le flux, séparés par *sep* et terminés par *end*. "
"*sep* et *end* doivent être des chaînes, ou ``None`` , indiquant de prendre "
"les valeurs par défaut. Si aucun *objects* n'est donné :func:`print` écris "
"seulement *end*."

#: ../Doc/library/functions.rst:1137
msgid ""
"The *file* argument must be an object with a ``write(string)`` method; if it "
"is not present or ``None``, :data:`sys.stdout` will be used.  Since printed "
"arguments are converted to text strings, :func:`print` cannot be used with "
"binary mode file objects.  For these, use ``file.write(...)`` instead."
msgstr ""
"L'argument *file* doit être un objet avec une méthode ``write(string)``; "
"s'il n'est pas fourni, ou vaut ``None``, :data:`sys.stdout` sera utilisé. "
"Puisque les arguments affichés sont convertis en chaîne, :func:`print` ne "
"peut pas être utilisé avec des fichiers ouverts en mode binaire. Pour ceux "
"ci utilisez plutôt ``file.write(...)``."

#: ../Doc/library/functions.rst:1142
msgid ""
"Whether output is buffered is usually determined by *file*, but if the "
"*flush* keyword argument is true, the stream is forcibly flushed."
msgstr ""
"Que la sortie utilise un buffer ou non est souvent décidé par *file*, mais "
"si l'argument *flush* est vrai, le tampon du flux est vidé explicitement."

#: ../Doc/library/functions.rst:1145
msgid "Added the *flush* keyword argument."
msgstr "Ajout de l'argument par mot clef *flush*."

#: ../Doc/library/functions.rst:1151
msgid "Return a property attribute."
msgstr "Donne un attribut propriété."

#: ../Doc/library/functions.rst:1153
msgid ""
"*fget* is a function for getting an attribute value.  *fset* is a function "
"for setting an attribute value. *fdel* is a function for deleting an "
"attribute value.  And *doc* creates a docstring for the attribute."
msgstr ""
"*fget* est une fonction permettant d'obtenir la valeur d'un attribut. *fset* "
"est une fonction pour en définir la valeur. *fdel* quand à elle permet de "
"supprimer la valeur d'un attribut, et *doc* créé une *docstring* pour "
"l'attribut."

#: ../Doc/library/functions.rst:1157
msgid "A typical use is to define a managed attribute ``x``::"
msgstr "Une utilisation typique : définir un attribut managé ``x`` : ::"

#: ../Doc/library/functions.rst:1174
msgid ""
"If *c* is an instance of *C*, ``c.x`` will invoke the getter, ``c.x = "
"value`` will invoke the setter and ``del c.x`` the deleter."
msgstr ""
"Si *c* est une instance de *C*, ``c.x`` appellera le *getter*, ``c.x = "
"value`` invoquera le *setter*, et ``del x`` le *deleter*."

#: ../Doc/library/functions.rst:1177
msgid ""
"If given, *doc* will be the docstring of the property attribute. Otherwise, "
"the property will copy *fget*'s docstring (if it exists).  This makes it "
"possible to create read-only properties easily using :func:`property` as a :"
"term:`decorator`::"
msgstr ""
"S'il est donné, *doc* sera la *docstring* de l'attribut. Autrement la "
"propriété copiera celle de *fget* (si elle existe). Cela rend possible la "
"création de propriétés en lecture seule en utilisant simplement :func:"
"`property` comme un :term:`decorator` : ::"

#: ../Doc/library/functions.rst:1190
msgid ""
"The ``@property`` decorator turns the :meth:`voltage` method into a \"getter"
"\" for a read-only attribute with the same name, and it sets the docstring "
"for *voltage* to \"Get the current voltage.\""
msgstr ""
"Le décorateur ``@property`` transforme la méthode :meth:`voltage` en un "
"*getter* d'un attribut du même nom, et donne \"Get the current voltage\" "
"comme *docstring* de *voltage*."

#: ../Doc/library/functions.rst:1194
msgid ""
"A property object has :attr:`~property.getter`, :attr:`~property.setter`, "
"and :attr:`~property.deleter` methods usable as decorators that create a "
"copy of the property with the corresponding accessor function set to the "
"decorated function.  This is best explained with an example::"
msgstr ""
"Un objet propriété à les méthodes :attr:`~property.getter`, :attr:`~property."
"setter` et :attr:`~property.deleter` utilisables comme décorateurs créant "
"une copie de la propriété avec les accesseurs correspondants définis par la "
"fonction de décoration. C'est plus clair avec un exemple : ::"

#: ../Doc/library/functions.rst:1216
msgid ""
"This code is exactly equivalent to the first example.  Be sure to give the "
"additional functions the same name as the original property (``x`` in this "
"case.)"
msgstr ""
"Ce code est l'exact équivalent du premier exemple. Soyez attentifs à bien "
"donner aux fonctions additionnelles le même nom que la propriété (``x`` dans "
"ce cas.)"

#: ../Doc/library/functions.rst:1220
msgid ""
"The returned property object also has the attributes ``fget``, ``fset``, and "
"``fdel`` corresponding to the constructor arguments."
msgstr ""
"L'objet propriété donné à aussi les attributs ``fget``, ``fset`` et ``fdel`` "
"correspondant correspondants aux arguments du constructeur."

#: ../Doc/library/functions.rst:1223
msgid "The docstrings of property objects are now writeable."
msgstr "Les *docstrings* des objets propriété peuvent maintenant être écrits."

#: ../Doc/library/functions.rst:1232
msgid ""
"Rather than being a function, :class:`range` is actually an immutable "
"sequence type, as documented in :ref:`typesseq-range` and :ref:`typesseq`."
msgstr ""
"Plutôt qu'être une fonction, :class:`range` est en fait une séquence "
"immuable, tel que documenté dans :ref:`typesseq-range` et :ref:`typesseq`."

#: ../Doc/library/functions.rst:1238
msgid ""
"Return a string containing a printable representation of an object.  For "
"many types, this function makes an attempt to return a string that would "
"yield an object with the same value when passed to :func:`eval`, otherwise "
"the representation is a string enclosed in angle brackets that contains the "
"name of the type of the object together with additional information often "
"including the name and address of the object.  A class can control what this "
"function returns for its instances by defining a :meth:`__repr__` method."
msgstr ""
"Donne une chaîne contenant une représentation affichable de l'objet. Pour de "
"nombreux types, cette fonction essaye de donner une chaîne qui donnera à son "
"tour un objet de mène valeur lorsqu'elle est passée à :func:`eval`, sinon la "
"représentation sera une chaîne entourée de chevrons contenant le nom du type "
"et quelques informations supplémentaires souvent le nom et l'adresse de "
"l'objet. Une classe peut contrôler ce que cette fonction donne pour ses "
"instances en définissant une méthode :meth:`_repr__`."

#: ../Doc/library/functions.rst:1249
msgid ""
"Return a reverse :term:`iterator`.  *seq* must be an object which has a :"
"meth:`__reversed__` method or supports the sequence protocol (the :meth:"
"`__len__` method and the :meth:`__getitem__` method with integer arguments "
"starting at ``0``)."
msgstr ""
"Donne un :term:`iterator` inversé. *seq* doit être un objet ayant une "
"méthode :meth:`__reverse__` ou supportant le protocole séquence (la méthode :"
"meth:`__len__` et la méthode :meth:`__getitem__` avec des arguments entiers "
"commençant à zéro)."

#: ../Doc/library/functions.rst:1257
msgid ""
"Return the floating point value *number* rounded to *ndigits* digits after "
"the decimal point.  If *ndigits* is omitted or is ``None``, it returns the "
"nearest integer to its input.  Delegates to ``number.__round__(ndigits)``."
msgstr ""

#: ../Doc/library/functions.rst:1261
msgid ""
"For the built-in types supporting :func:`round`, values are rounded to the "
"closest multiple of 10 to the power minus *ndigits*; if two multiples are "
"equally close, rounding is done toward the even choice (so, for example, "
"both ``round(0.5)`` and ``round(-0.5)`` are ``0``, and ``round(1.5)`` is "
"``2``).  The return value is an integer if called with one argument, "
"otherwise of the same type as *number*."
msgstr ""
"Pour les types natifs supportant :func:`round`, les valeurs sont arrondies "
"au multiple de 10 puissance moins *ndigits*, si deux multiples sont "
"équidistants, l'arrondi se fait vers la valeur paire (par exemple "
"``round(0.5)`` et ``round(-0.5)`` valent tous les deux ``0``, et "
"``round(1.5)`` vaut ``2``). La valeur rendue est un entier si elle est "
"appelée avec un seul argument, sinon elle sera de même type que *number*."

#: ../Doc/library/functions.rst:1270
msgid ""
"The behavior of :func:`round` for floats can be surprising: for example, "
"``round(2.675, 2)`` gives ``2.67`` instead of the expected ``2.68``. This is "
"not a bug: it's a result of the fact that most decimal fractions can't be "
"represented exactly as a float.  See :ref:`tut-fp-issues` for more "
"information."
msgstr ""
"Le comportement de :func:`round` avec les nombres à virgule flottante peut "
"être surprenant : par exemple ``round(2.675, 2)`` donne ``2.67`` au lieu de "
"``2.68``. Ce n'est pas un bug, mais dû au fait que la plupart des fractions "
"de décimaux ne peuvent pas être représentés exactement en nombre a virgule "
"flottante. Voir :ref:`tut-fp-issues` pour plus d'information."

#: ../Doc/library/functions.rst:1281
msgid ""
"Return a new :class:`set` object, optionally with elements taken from "
"*iterable*.  ``set`` is a built-in class.  See :class:`set` and :ref:`types-"
"set` for documentation about this class."
msgstr ""
"Donne un nouveau :class:`set`, dont les éléments peuvent être extraits "
"d'*iterable*. ``set`` est une classe native. Voir :class:`set` et :ref:"
"`types-set` pour la documentation de cette classe."

#: ../Doc/library/functions.rst:1285
msgid ""
"For other containers see the built-in :class:`frozenset`, :class:`list`, :"
"class:`tuple`, and :class:`dict` classes, as well as the :mod:`collections` "
"module."
msgstr ""
"D'autres conteneurs existent, typiquement : :class:`frozenset`, :class:"
"`list`, :class:`tuple`, et :class:`dict`, ainsi que le module :mod:"
"`collections`."

#: ../Doc/library/functions.rst:1292
msgid ""
"This is the counterpart of :func:`getattr`.  The arguments are an object, a "
"string and an arbitrary value.  The string may name an existing attribute or "
"a new attribute.  The function assigns the value to the attribute, provided "
"the object allows it.  For example, ``setattr(x, 'foobar', 123)`` is "
"equivalent to ``x.foobar = 123``."
msgstr ""
"C'est le complément de :func:`getattr`. Les arguments sont : un objet, une "
"chaîne, et une valeur de type arbitraire. La chaîne peut nommer un attribut "
"existant ou un nouvel attribut. La fonction assigne la valeur à l'attribut, "
"si l'objet l'autorise. Par exemple, ``setattr(x, 'foobar', 123)`` équivaut à "
"``x.foobar = 123``."

#: ../Doc/library/functions.rst:1304
msgid ""
"Return a :term:`slice` object representing the set of indices specified by "
"``range(start, stop, step)``.  The *start* and *step* arguments default to "
"``None``.  Slice objects have read-only data attributes :attr:`~slice."
"start`, :attr:`~slice.stop` and :attr:`~slice.step` which merely return the "
"argument values (or their default).  They have no other explicit "
"functionality; however they are used by Numerical Python and other third "
"party extensions. Slice objects are also generated when extended indexing "
"syntax is used.  For example: ``a[start:stop:step]`` or ``a[start:stop, "
"i]``.  See :func:`itertools.islice` for an alternate version that returns an "
"iterator."
msgstr ""
"Donne un objet :class:`slice` représentant un ensemble d'indices spécifiés "
"par ``range(start, stop, step)``. Les arguments *start* et *step* valent "
"``None`` par défaut. Les objets *slice* (tranches) ont les attributs "
"suivants en lecture seule : :attr:`~slice.start`, :attr:`~slice.stop`, et :"
"attr:`~slice.step` qui valent simplement les trois arguments (ou leurs "
"valeur par défaut). Ils n'ont pas d'autres fonctionnalité explicite, "
"cependant ils sont utilisés par *Numerical Python* et d'autres bibliothèques "
"tierces. Les objets *slice* sont aussi générés par la syntaxe d'indiçage "
"étendue. Par exemple ``a[start:stop:step]`` ou ``a[start:stop, i]``. Voir :"
"func:`itertools.islice` pour une version alternative donnant un itérateur."

#: ../Doc/library/functions.rst:1317
msgid "Return a new sorted list from the items in *iterable*."
msgstr "Donne une nouvelle liste triée depuis les éléments d'*iterable*."

#: ../Doc/library/functions.rst:1319
msgid ""
"Has two optional arguments which must be specified as keyword arguments."
msgstr "A deux arguments optionnels qui doivent être fournis par mot clef."

#: ../Doc/library/functions.rst:1321
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`` (compare the elements directly)."
msgstr ""
"*key* spécifie une fonction d'un argument utilisé pour extraire une clef de "
"comparaison de chaque élément de la liste : ``key=str.lower``. La valeur par "
"défaut est ``None`` (compare les éléments directement)."

#: ../Doc/library/functions.rst:1325
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/functions.rst:1328
msgid ""
"Use :func:`functools.cmp_to_key` to convert an old-style *cmp* function to a "
"*key* function."
msgstr ""
"Utilisez :func:`functools.cmp_to_key` pour convertir l'ancienne notation "
"*cmp* en une fonction *key*."

#: ../Doc/library/functions.rst:1331
msgid ""
"The built-in :func:`sorted` function 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 ""
"La fonction native :func:`sorted` est garantie stable. Un tri est stable "
"s'il garantie de ne pas changer l'ordre relatif des éléments égaux entre "
"eux. C'est util pour trier en plusieurs passes, par exemple par département "
"puis par salaire)."

#: ../Doc/library/functions.rst:1336
msgid ""
"For sorting examples and a brief sorting tutorial, see :ref:`sortinghowto`."
msgstr ""
"Pour des exemple de tris et un bref tutoriel, consultez :ref:`sortinghowto`."

#: ../Doc/library/functions.rst:1340
msgid "Return a static method for *function*."
msgstr "Donne une méthode statique pour *function*."

#: ../Doc/library/functions.rst:1342
msgid ""
"A static method does not receive an implicit first argument. To declare a "
"static method, use this idiom::"
msgstr ""
"Une méthode statique ne reçoit pas de premier argument implicitement. Voilà "
"comment déclarer une méthode statique : ::"

#: ../Doc/library/functions.rst:1349
msgid ""
"The ``@staticmethod`` form is a function :term:`decorator` -- see the "
"description of function definitions in :ref:`function` for details."
msgstr ""
"La forme ``@staticmethod`` est un :term:`decorator` de fonction. Voir la "
"description des définitions de fonction dans :ref:`function` pour plus de "
"détails."

#: ../Doc/library/functions.rst:1352
msgid ""
"It can be called either on the class (such as ``C.f()``) or on an instance "
"(such as ``C().f()``).  The instance is ignored except for its class."
msgstr ""
"Elle peut être appelée soit sur une classe (tel que ``C.f()``) ou sur une "
"instance (tel que ``C().f()``). L'instance est ignorée, sauf pour sa classe."

#: ../Doc/library/functions.rst:1355
msgid ""
"Static methods in Python are similar to those found in Java or C++. Also "
"see :func:`classmethod` for a variant that is useful for creating alternate "
"class constructors."
msgstr ""
"Les méthodes statiques en Python sont similaires à celles trouvées en Java "
"ou en C++. Consultez :func:`classmethod` pour une variante utile pour créer "
"des constructeurs alternatifs."

#: ../Doc/library/functions.rst:1359
msgid ""
"For more information on static methods, consult the documentation on the "
"standard type hierarchy in :ref:`types`."
msgstr ""
"Pour plus d'informations sur les méthodes statiques, consultez la "
"documentation de la hiérarchie des types standards dans :ref:`types`."

#: ../Doc/library/functions.rst:1371
msgid ""
"Return a :class:`str` version of *object*.  See :func:`str` for details."
msgstr ""
"Donne une version sous forme de :class:`str` d'*object*. Voir :func:`str` "
"pour plus de détails."

#: ../Doc/library/functions.rst:1373
msgid ""
"``str`` is the built-in string :term:`class`.  For general information about "
"strings, see :ref:`textseq`."
msgstr ""
"``str`` est la :term:`class` native des chaînes de caractères. Pour des "
"informations générales à propos des chaînes, consultez :ref:`textseq`."

#: ../Doc/library/functions.rst:1379
msgid ""
"Sums *start* and the items of an *iterable* from left to right and returns "
"the total.  *start* defaults to ``0``. The *iterable*'s items are normally "
"numbers, and the start value is not allowed to be a string."
msgstr ""
"Additionne *start* et les éléments d'*iterable* de gauche à droite et en "
"donne le total. *start* vaut ``0`` par défaut. Les éléments d'*iterable* "
"sont normalement des nombres, et la valeur de *start* ne peut pas être une "
"chaîne."

#: ../Doc/library/functions.rst:1383
msgid ""
"For some use cases, there are good alternatives to :func:`sum`. The "
"preferred, fast way to concatenate a sequence of strings is by calling ``''."
"join(sequence)``.  To add floating point values with extended precision, "
"see :func:`math.fsum`\\.  To concatenate a series of iterables, consider "
"using :func:`itertools.chain`."
msgstr ""
"Pour certains cas, il existe de bonnes alternatives à :func:`sum`. La bonne "
"méthode, et rapide, de concaténer une séquence de chaînes est d'appeler ``''."
"join(séquence)``. Pour additionner des nombres à virgule flottante avec une "
"meilleure précision, voir :func:`math.fsum`. Pour concaténer une série "
"d'itérables, utilisez plutôt :func:`itertools.chain`."

#: ../Doc/library/functions.rst:1391
msgid ""
"Return a proxy object that delegates method calls to a parent or sibling "
"class of *type*.  This is useful for accessing inherited methods that have "
"been overridden in a class. The search order is same as that used by :func:"
"`getattr` except that the *type* itself is skipped."
msgstr ""
"Donne un objet mandataire (*proxy object*) déléguant les appels de méthode à "
"une classe parente ou soeur de type *type*. C'est utile pour accéder à des "
"méthodes héritées et substituées dans la classe. L'ordre de recherche est le "
"même que celui utilisé par :func:`getattr` sauf que *type* lui même est "
"sauté."

#: ../Doc/library/functions.rst:1396
msgid ""
"The :attr:`~class.__mro__` attribute of the *type* lists the method "
"resolution search order used by both :func:`getattr` and :func:`super`.  The "
"attribute is dynamic and can change whenever the inheritance hierarchy is "
"updated."
msgstr ""
"L'attribut :attr:`~class.__mro__` de *type* liste l'ordre de recherche de la "
"méthode de résolution utilisée par :func:`getattr` et :func:`super`. "
"L'attribut est dynamique et peut changer lorsque la hiérarchie d'héritage "
"est modifiée."

#: ../Doc/library/functions.rst:1401
msgid ""
"If the second argument is omitted, the super object returned is unbound.  If "
"the second argument is an object, ``isinstance(obj, type)`` must be true.  "
"If the second argument is a type, ``issubclass(type2, type)`` must be true "
"(this is useful for classmethods)."
msgstr ""
"Si le second argument est omis, l'objet *super* obtenu n'est pas lié. Si le "
"second argument est un objet, ``isinstance(obj, type)`` doit être vrai. Si "
"le second argument est un type, ``issubclass(type2, type)`` doit être vrai "
"(c'est utile pour les méthodes de classe)."

#: ../Doc/library/functions.rst:1406
msgid ""
"There are two typical use cases for *super*.  In a class hierarchy with "
"single inheritance, *super* can be used to refer to parent classes without "
"naming them explicitly, thus making the code more maintainable.  This use "
"closely parallels the use of *super* in other programming languages."
msgstr ""
"Il existe deux autres cas d'usage typiques pour *super*. Dans une hiérarchie "
"de classes à héritage simple, *super* peut être utilisé pour obtenir la "
"classe parente sans avoir à la nommer explicitement, rendant le code plus "
"maintenable. Cet usage se rapproche de l'usage de *super* dans d'autres "
"langages de programmation."

#: ../Doc/library/functions.rst:1411
msgid ""
"The second use case is to support cooperative multiple inheritance in a "
"dynamic execution environment.  This use case is unique to Python and is not "
"found in statically compiled languages or languages that only support single "
"inheritance.  This makes it possible to implement \"diamond diagrams\" where "
"multiple base classes implement the same method.  Good design dictates that "
"this method have the same calling signature in every case (because the order "
"of calls is determined at runtime, because that order adapts to changes in "
"the class hierarchy, and because that order can include sibling classes that "
"are unknown prior to runtime)."
msgstr ""
"Le second est la gestion d'héritage multiple coopératif dans un "
"environnement d'exécution dynamique. Cet usage est unique à Python, il ne se "
"retrouve ni dans les langages compilés statiquement, ni dans les langages ne "
"gérant que l'héritage simple. Cela rend possible d'implémenter un héritage "
"en diamant dans lequel plusieurs classes parentes implémentent la même "
"méthode. Une bonne conception implique que chaque méthode doit avoir la même "
"signature lors de leur appels dans tous les cas (parce que l'ordre des "
"appels est déterminée à l'exécution, parce que l'ordre s'adapte aux "
"changements dans la hiérarchie, et parce que l'ordre peut inclure des "
"classes soeur inconnues avant l'exécution)."

#: ../Doc/library/functions.rst:1421
msgid "For both use cases, a typical superclass call looks like this::"
msgstr ""
"Dans tous les cas, un appel typique à une classe parente ressemble à : ::"

#: ../Doc/library/functions.rst:1428
msgid ""
"Note that :func:`super` is implemented as part of the binding process for "
"explicit dotted attribute lookups such as ``super().__getitem__(name)``. It "
"does so by implementing its own :meth:`__getattribute__` method for "
"searching classes in a predictable order that supports cooperative multiple "
"inheritance. Accordingly, :func:`super` is undefined for implicit lookups "
"using statements or operators such as ``super()[name]``."
msgstr ""
"Notez que :func:`super` fait partie de l'implémentation du processus de "
"liaison de recherche d'attributs pointés explicitement tel que ``super()."
"__getitem__(name)``. Il le fait en implémentant sa propre méthode :meth:"
"`__getattribute__` pour rechercher les classes dans un ordre prévisible "
"supportant l'héritage multiple coopératif. En conséquence, :func:`super` "
"n'est pas défini pour les recherches implicites via des instructions ou des "
"opérateurs tel que ``super()[name]``."

#: ../Doc/library/functions.rst:1435
msgid ""
"Also note that, aside from the zero argument form, :func:`super` is not "
"limited to use inside methods.  The two argument form specifies the "
"arguments exactly and makes the appropriate references.  The zero argument "
"form only works inside a class definition, as the compiler fills in the "
"necessary details to correctly retrieve the class being defined, as well as "
"accessing the current instance for ordinary methods."
msgstr ""
"Notez aussi que, en dehors de sa forme sans arguments, la :func:`super` peut "
"être utilisée en dehors des méthodes. La forme à deux arguments est précise "
"et donne tous les arguments exactement, donnant les références appropriées. "
"La forme sans arguments fonctionne seulement à l'intérieur d'une définition "
"de classe, puisque c'est le compilateur qui donne les détails nécessaires à "
"propos de la classe en cours de définition, ainsi qu'accéder à l'instance "
"courante pour les méthodes ordinaires."

#: ../Doc/library/functions.rst:1442
msgid ""
"For practical suggestions on how to design cooperative classes using :func:"
"`super`, see `guide to using super() <https://rhettinger.wordpress."
"com/2011/05/26/super-considered-super/>`_."
msgstr ""
"Pour des suggestions pratiques sur la conception de classes coopératives "
"utilisant :func:`super`, consultez `guide to using super() <http://"
"rhettinger.wordpress.com/2011/05/26/super-considered-super/>`_."

#: ../Doc/library/functions.rst:1451
msgid ""
"Rather than being a function, :class:`tuple` is actually an immutable "
"sequence type, as documented in :ref:`typesseq-tuple` and :ref:`typesseq`."
msgstr ""
"Plutôt qu'être une fonction, :class:`tuple` est en fait un type de séquence "
"immuable, tel que documenté dans :ref:`typesseq-tuple` et :ref:`typesseq`."

#: ../Doc/library/functions.rst:1460
msgid ""
"With one argument, return the type of an *object*.  The return value is a "
"type object and generally the same object as returned by :attr:`object."
"__class__ <instance.__class__>`."
msgstr ""
"Avec un argument, donne le type d'*object*. La valeur donnée est un objet "
"type et généralement la même que la valeur de l'attribut :attr:`object."
"__class__ <instance.__class__>`."

#: ../Doc/library/functions.rst:1464
msgid ""
"The :func:`isinstance` built-in function is recommended for testing the type "
"of an object, because it takes subclasses into account."
msgstr ""
"La fonction native :func:`isinstance` est recommandée pour tester le type "
"d'un objet car elle prend en compte l'héritage."

#: ../Doc/library/functions.rst:1468
msgid ""
"With three arguments, return a new type object.  This is essentially a "
"dynamic form of the :keyword:`class` statement. The *name* string is the "
"class name and becomes the :attr:`~definition.__name__` attribute; the "
"*bases* tuple itemizes the base classes and becomes the :attr:`~class."
"__bases__` attribute; and the *dict* dictionary is the namespace containing "
"definitions for class body and is copied to a standard dictionary to become "
"the :attr:`~object.__dict__` attribute.  For example, the following two "
"statements create identical :class:`type` objects:"
msgstr ""

#: ../Doc/library/functions.rst:1482
msgid "See also :ref:`bltin-type-objects`."
msgstr "Voir aussi :ref:`bltin-type-objects`."

#: ../Doc/library/functions.rst:1484
msgid ""
"Subclasses of :class:`type` which don't override ``type.__new__`` may no "
"longer use the one-argument form to get the type of an object."
msgstr ""

#: ../Doc/library/functions.rst:1490
msgid ""
"Return the :attr:`~object.__dict__` attribute for a module, class, instance, "
"or any other object with a :attr:`~object.__dict__` attribute."
msgstr ""

#: ../Doc/library/functions.rst:1493
msgid ""
"Objects such as modules and instances have an updateable :attr:`~object."
"__dict__` attribute; however, other objects may have write restrictions on "
"their :attr:`~object.__dict__` attributes (for example, classes use a :class:"
"`types.MappingProxyType` to prevent direct dictionary updates)."
msgstr ""

#: ../Doc/library/functions.rst:1498
msgid ""
"Without an argument, :func:`vars` acts like :func:`locals`.  Note, the "
"locals dictionary is only useful for reads since updates to the locals "
"dictionary are ignored."
msgstr ""
"Sans augment, :func:`vars` se comporte comme :func:`locals`. Notez que le "
"dictionnaire des variables locales n'est utile qu'en lecture, car ses "
"écritures sont ignorées."

#: ../Doc/library/functions.rst:1505
msgid "Make an iterator that aggregates elements from each of the iterables."
msgstr "Construit un itérateur agrégeant les éléments de tous les itérables."

#: ../Doc/library/functions.rst:1507
msgid ""
"Returns an iterator of tuples, where the *i*-th tuple contains the *i*-th "
"element from each of the argument sequences or iterables.  The iterator "
"stops when the shortest input iterable is exhausted. With a single iterable "
"argument, it returns an iterator of 1-tuples.  With no arguments, it returns "
"an empty iterator.  Equivalent to::"
msgstr ""
"Donne un itérateur de tuples, où le *i*ème tuple contiens le *i*ème élément "
"de chacune des séquences ou itérables fournis. L'itérateur s'arrête lorsque "
"le plus petit iterable fourni est épuisé. Avec un seul argument iterable, "
"elle donne un itérateur sur des *tuples* d'un élément. Sans arguments, elle "
"donne un itérateur vide. Équivalent à : ::"

#: ../Doc/library/functions.rst:1526
msgid ""
"The left-to-right evaluation order of the iterables is guaranteed. This "
"makes possible an idiom for clustering a data series into n-length groups "
"using ``zip(*[iter(s)]*n)``.  This repeats the *same* iterator ``n`` times "
"so that each output tuple has the result of ``n`` calls to the iterator. "
"This has the effect of dividing the input into n-length chunks."
msgstr ""
"Il est garanti que les itérables soient évalués de gauche a droite. Cela "
"rend possible de grouper une séquence de données en groupes de taille *n* "
"via ``zip(*[iter(s)]*n)``. Cela duplique le *même* itérateur ``n`` fois tel "
"que le tuple obtenu contient le résultat de ``n`` appels à l'itérateur. Cela "
"a pour effet de diviser la séquence en morceaux de taille *n*."

#: ../Doc/library/functions.rst:1532
msgid ""
":func:`zip` should only be used with unequal length inputs when you don't "
"care about trailing, unmatched values from the longer iterables.  If those "
"values are important, use :func:`itertools.zip_longest` instead."
msgstr ""
":func:`zip` ne devrait être utilisée avec des itérables de longueur "
"différente que lorsque les dernières données des itérables les plus longs "
"peuvent être ignorées. Si c'est valeurs sont importantes, utilisez plutôt :"
"func:`itertools.zip_longest`."

#: ../Doc/library/functions.rst:1536
msgid ""
":func:`zip` in conjunction with the ``*`` operator can be used to unzip a "
"list::"
msgstr ""
":func:`zip` peut être utilisée conjointement avec l'opérateur ``*`` pour de-"
"*zip*-per une liste : ::"

#: ../Doc/library/functions.rst:1557
msgid ""
"This is an advanced function that is not needed in everyday Python "
"programming, unlike :func:`importlib.import_module`."
msgstr ""
"C'est une fonction avancée qui n'est pas fréquemment nécessaire, "
"contrairement à :func:`importlib.import_module`."

#: ../Doc/library/functions.rst:1560
msgid ""
"This function is invoked by the :keyword:`import` statement.  It can be "
"replaced (by importing the :mod:`builtins` module and assigning to "
"``builtins.__import__``) in order to change semantics of the :keyword:"
"`import` statement, but doing so is **strongly** discouraged as it is "
"usually simpler to use import hooks (see :pep:`302`) to attain the same "
"goals and does not cause issues with code which assumes the default import "
"implementation is in use.  Direct use of :func:`__import__` is also "
"discouraged in favor of :func:`importlib.import_module`."
msgstr ""
"Cette fonction est invoquée via l'instruction :keyword:`import`. Elle peut "
"être remplacée (en important le module :mod:`builtins` et en y remplaçant "
"``builtins.__import__``) afin de changer la sémantique de l'instruction :"
"keyword:`import`, mais c'est extrêmement déconseillé car il est plus simple "
"d'utiliser des *import hooks* (voir la :pep:`302`) pour le même résultat "
"sans gêner du code s'attendant à trouver l'implémentation par défaut. "
"L'usage direct de :func:`__import__` est aussi déconseillé en faveur de :"
"func:`importlib.import_module`."

#: ../Doc/library/functions.rst:1569
msgid ""
"The function imports the module *name*, potentially using the given "
"*globals* and *locals* to determine how to interpret the name in a package "
"context. The *fromlist* gives the names of objects or submodules that should "
"be imported from the module given by *name*.  The standard implementation "
"does not use its *locals* argument at all, and uses its *globals* only to "
"determine the package context of the :keyword:`import` statement."
msgstr ""
"La fonction importe le module *name*, utilisant potentiellement *globals* et "
"*locals* pour déterminer comment interpréter le nom dans le contexte d'un "
"paquet. *fromlist* donne le nom des objets ou sous-modules qui devraient "
"être importés du module *name*. L'implémentation standard n'utilise pas "
"l'argument *locals* et n'utilise *globals* que pour déterminer le contexte "
"du paquet de l'instruction :keyword:`import`."

#: ../Doc/library/functions.rst:1576
msgid ""
"*level* specifies whether to use absolute or relative imports. ``0`` (the "
"default) means only perform absolute imports.  Positive values for *level* "
"indicate the number of parent directories to search relative to the "
"directory of the module calling :func:`__import__` (see :pep:`328` for the "
"details)."
msgstr ""
"*level* permet de choisir entre import absolu ou relatif. ``0`` (par défaut) "
"inplique de n'effectuer que des imports absolus. Une valeur positive indique "
"le nombre de dossiers parents relatifvement au dossier du module appelant :"
"func:`__import__` (voir la :pep:`328`)."

#: ../Doc/library/functions.rst:1582
msgid ""
"When the *name* variable is of the form ``package.module``, normally, the "
"top-level package (the name up till the first dot) is returned, *not* the "
"module named by *name*.  However, when a non-empty *fromlist* argument is "
"given, the module named by *name* is returned."
msgstr ""
"Lorsque la variable *name* est de la forme ``package.module``, normalement, "
"le paquet le plus haut (le nom jusqu'au premier point) est donné, et *pas* "
"le module nommé par *name*. Cependant, lorsqu'un argument *fromlist* est "
"fourni, le module nommé par *name* est donné."

#: ../Doc/library/functions.rst:1587
msgid ""
"For example, the statement ``import spam`` results in bytecode resembling "
"the following code::"
msgstr ""
"Par exemple, l'instruction ``import spam`` donne un bytecode ressemblant ai "
"code suivant : ::"

#: ../Doc/library/functions.rst:1592
msgid "The statement ``import spam.ham`` results in this call::"
msgstr "L'instruction ``import ham.ham`` appelle : ::"

#: ../Doc/library/functions.rst:1596
msgid ""
"Note how :func:`__import__` returns the toplevel module here because this is "
"the object that is bound to a name by the :keyword:`import` statement."
msgstr ""
"Notez comment :func:`__import__` donne le module le plus haut ici parce que "
"c'est l'objet lié à un nom par l'nstruction :keyword:`import`."

#: ../Doc/library/functions.rst:1599
msgid ""
"On the other hand, the statement ``from spam.ham import eggs, sausage as "
"saus`` results in ::"
msgstr ""
"En revanche, l'instruction ``from spam.ham import eggs, saucage as saus`` "
"donne : ::"

#: ../Doc/library/functions.rst:1606
msgid ""
"Here, the ``spam.ham`` module is returned from :func:`__import__`.  From "
"this object, the names to import are retrieved and assigned to their "
"respective names."
msgstr ""
"Ici le module ``spam.ham`` est donné par :func:`__import__`. De cet objet, "
"les noms à importer sont récupérés et assignés à leurs noms respectifs."

#: ../Doc/library/functions.rst:1610
msgid ""
"If you simply want to import a module (potentially within a package) by "
"name, use :func:`importlib.import_module`."
msgstr ""
"Si vous voulez simplement importer un module (potentiellement dans un "
"paquet) par son nom, utilisez :func:`importlib.import_module`."

#: ../Doc/library/functions.rst:1613
msgid ""
"Negative values for *level* are no longer supported (which also changes the "
"default value to 0)."
msgstr ""
"Des valeurs négatives pour *level* ne sont plus gérées (ce qui change la "
"valeur par défaut pour 0)."

#: ../Doc/library/functions.rst:1619
msgid "Footnotes"
msgstr "Notes"

#: ../Doc/library/functions.rst:1620
msgid ""
"Note that the parser only accepts the Unix-style end of line convention. If "
"you are reading the code from a file, make sure to use newline conversion "
"mode to convert Windows or Mac-style newlines."
msgstr ""
"Notez que le psrseur n'accepte que des fin de lignes de style Unix. Si vous "
"lisez le code depuis un fichier, assurez-vous d'utiliser la conversion de "
"retours à la ligne pour convertir les fin de lignes Windows et Mac."