functions.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-03-22 22:16+0100\n"
"PO-Revision-Date: 2023-03-22 22:49+0100\n"
"Last-Translator: Antoine Wecxsteen\n"
"Language-Team: French <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 2.3\n"

#: library/functions.rst:11
msgid "Built-in Functions"
msgstr "Fonctions natives"

#: 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."

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: library/functions.rst:21
msgid "|func-bytes|_"
msgstr "|func-bytes|_"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: library/functions.rst:45
msgid ""
"Return the absolute value of a number.  The argument may be an integer, a "
"floating point number, or an object implementing :meth:`__abs__`. If the "
"argument is a complex number, its magnitude is returned."
msgstr ""
"Renvoie la valeur absolue d'un nombre. L'argument peut être un nombre "
"entier, un nombre à virgule flottante, ou tout objet définissant :meth:"
"`__abs__`. Si l'argument est un nombre complexe, son module est renvoyé."

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

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

#: library/functions.rst:76
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 ""
"Renvoie, tout comme :func:`repr`, une chaîne contenant une représentation "
"affichable d'un objet, en transformant les caractères non ASCII renvoyé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."

#: library/functions.rst:84
msgid ""
"Convert an integer number to a binary string prefixed with \"0b\". 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. Some examples:"
msgstr ""
"Convertit un nombre entier en binaire dans une chaîne avec le préfixe "
"``0b``. 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. Voici quelques exemples :"

#: library/functions.rst:94
msgid ""
"If prefix \"0b\" is desired or not, you can use either of the following ways."
msgstr ""
"Pour contrôler l'affichage du préfixe ``0b``, vous pouvez utiliser les "
"moyens suivants."

#: library/functions.rst:757 library/functions.rst:1053
msgid "See also :func:`format` for more information."
msgstr "Voir aussi :func:`format` pour plus d'informations."

#: library/functions.rst:106
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 ""
"Renvoie 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 renvoie ``False``, "
"sinon, elle renvoie ``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`)."

#: library/functions.rst:625 library/functions.rst:841
msgid "*x* is now a positional-only parameter."
msgstr "*x* est désormais un argument exclusivement optionnel."

#: library/functions.rst:120
msgid ""
"This function drops you into the debugger at the call site.  Specifically, "
"it calls :func:`sys.breakpointhook`, passing ``args`` and ``kws`` straight "
"through.  By default, ``sys.breakpointhook()`` calls :func:`pdb.set_trace()` "
"expecting no arguments.  In this case, it is purely a convenience function "
"so you don't have to explicitly import :mod:`pdb` or type as much code to "
"enter the debugger.  However, :func:`sys.breakpointhook` can be set to some "
"other function and :func:`breakpoint` will automatically call that, allowing "
"you to drop into the debugger of choice."
msgstr ""
"Cette fonction vous place dans le débogueur lorsqu'elle est appelée. Plus "
"précisément, elle appelle :func:`sys.breakpointhook`, en lui passant les "
"arguments ``args`` et ``kws``. Par défaut, ``sys.breakpointhook()`` appelle :"
"func:`pdb.set_trace()` qui n'attend aucun argument. Dans ce cas, c'est "
"purement une fonction de commodité donc vous n'avez pas à importer "
"explicitement :mod:`pdb` ou à taper plus de code pour entrer dans le "
"débogueur. Cependant, il est possible d'affecter une autre fonction à :func:"
"`sys.breakpointhook`, que :func:`breakpoint` appellera automatiquement, vous "
"permettant ainsi de basculer dans le débogueur de votre choix."

#: library/functions.rst:130
msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.breakpoint`` with "
"argument ``breakpointhook``."
msgstr ""
"Lève un :ref:`auditing event <auditing>` ``builtins.breakpoint`` avec "
"l'argument ``breakpointhook``."

#: library/functions.rst:138
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 ""
"Renvoie un nouveau tableau d'octets. La classe :class:`bytearray` est une "
"séquence muable de nombres 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`."

#: library/functions.rst:143
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 le "
"tableau de plusieurs façons :"

#: library/functions.rst:146
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 le paramètre *encoding* pour "
"l'encodage (et éventuellement *errors*). La fonction :func:`bytearray` "
"convertit ensuite la chaîne en octets via la méthode :meth:`str.encode` ;"

#: library/functions.rst:150
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*, le tableau a cette taille et est initialisé d'octets "
"*null* ;"

#: library/functions.rst:153
msgid ""
"If it is an object conforming to the :ref:`buffer interface "
"<bufferobjects>`, a read-only buffer of the object will be used to "
"initialize the bytes array."
msgstr ""
"si c'est un objet conforme à :ref:`l'interface tampon <bufferobjects>`, un "
"tampon en lecture seule de l'objet est utilisé pour initialiser le tableau ;"

#: library/functions.rst:156
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 sont utilisés pour initialiser le contenu "
"du tableau."

#: library/functions.rst:159
msgid "Without an argument, an array of size 0 is created."
msgstr "Sans argument, un tableau vide est créé."

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

#: library/functions.rst:168
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 ""
"Renvoie un nouvel objet *bytes*, qui est une séquence immuable de nombres "
"entiers dans l'intervalle ``0 <= x < 256``. Un :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."

#: library/functions.rst:173
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`."

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

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

#: library/functions.rst:182
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 ""
"Renvoie :const:`True` si l'argument *object* semble être appelable, sinon :"
"const:`False`. Lorsqu'elle renvoie ``True``, il est toujours possible qu'un "
"appel échoue. Cependant, lorsqu'elle renvoie ``False``, il n'est jamais "
"possible d'appeler *object*. Notez qu'une classe est toujours appelable "
"(appeler une classe donne une nouvelle instance) ; une instance n'est "
"appelable que si sa classe définit une méthode :meth:`__call__`."

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

#: library/functions.rst:195
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 ""
"Renvoie la chaîne représentant un caractère dont le code de caractère "
"Unicode est le nombre entier *i*. Par exemple, ``chr(97)`` renvoie la chaîne "
"de caractères ``'a'``, tandis que ``chr(8364)`` renvoie ``'€'``. Il s'agit "
"de l'inverse de :func:`ord`."

#: library/functions.rst:199
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` est levée si *i* "
"est en dehors de l'intervalle."

#: library/functions.rst:205
msgid "Transform a method into a class method."
msgstr "Transforme une méthode en méthode de classe."

#: library/functions.rst:207
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 argument, "
"tout comme une méthode d'instance reçoit l'instance. Voici comment déclarer "
"une méthode de classe ::"

#: library/functions.rst:215
msgid ""
"The ``@classmethod`` form is a function :term:`decorator` -- see :ref:"
"`function` for details."
msgstr ""
"La forme ``@classmethod`` est un :term:`décorateur <decorator>` de fonction "
"— consultez :ref:`function` pour plus de détails."

#: library/functions.rst:218
msgid ""
"A class method 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."

#: library/functions.rst:223
msgid ""
"Class methods are different than C++ or Java static methods. If you want "
"those, see :func:`staticmethod` in this section. For more information on "
"class methods, see :ref:`types`."
msgstr ""
"Les méthodes de classe sont différentes des méthodes statiques du C++ ou du "
"Java. Si ce sont elles dont vous avez besoin, regardez du côté de :func:"
"`staticmethod` dans cette section. Voir aussi :ref:`types`."

#: library/functions.rst:227
msgid ""
"Class methods can now wrap other :term:`descriptors <descriptor>` such as :"
"func:`property`."
msgstr ""
"les méthodes de classe peuvent encapsuler d'autres :term:`descripteurs "
"<descriptor>` comme :func:`property`."

#: library/functions.rst:233
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 être une chaîne, "
"une chaîne d'octets, ou un objet AST. Consultez la documentation du module :"
"mod:`ast` pour des informations sur la manipulation d'objets AST."

#: library/functions.rst:238
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 désigner le fichier depuis lequel le code a été "
"lu. Donnez quelque chose de reconnaissable lorsqu'il n'a pas été lu depuis "
"un fichier (typiquement ``\"<string>\"``)."

#: library/functions.rst:242
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'`` s'il ne contient qu'une instruction interactive "
"(dans ce dernier cas, les résultats d'expressions donnant autre chose que "
"``None`` sont affichés)."

#: library/functions.rst:248
msgid ""
"The optional arguments *flags* and *dont_inherit* control which :ref:"
"`compiler options <ast-compiler-flags>` should be activated and which :ref:"
"`future features <future>` should be allowed. If neither is present (or both "
"are zero) the code is compiled with the same flags that affect the code that "
"is calling :func:`compile`. If the *flags* argument is given and "
"*dont_inherit* is not (or is zero) then the compiler options and 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 flags (future features and compiler options) "
"in the surrounding code are ignored."
msgstr ""
"Les arguments optionnels *flags* et *dont_inherit* contrôlent quelles :ref:"
"`options de compilation <ast-compiler-flags>` seront activées et quelles :"
"ref:`instructions future <future>` seront autorisées. Si aucun des deux "
"n'est présent (ou que les deux sont à 0), le code est compilé avec les mêmes "
"paramètres que le code appelant :func:`compile`. Si l'argument *flags* est "
"fourni alors que *dont_inherit* ne l'est pas (ou vaut 0), les options de "
"compilation et les instructions *futures* utilisées sont celles définies 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é tel quel — les *flags* "
"(instructions futures et options de compilation) valables pour le code "
"encadrant *compile* sont ignorés."

#: library/functions.rst:259
msgid ""
"Compiler options and future statements are specified by bits which can be "
"bitwise ORed together to specify multiple options. The bitfield required to "
"specify a given future feature can be found as the :attr:`~__future__."
"_Feature.compiler_flag` attribute on the :class:`~__future__._Feature` "
"instance in the :mod:`__future__` module. :ref:`Compiler flags <ast-compiler-"
"flags>` can be found in :mod:`ast` module, with ``PyCF_`` prefix."
msgstr ""
"Les instructions *future* sont contrôlées par des bits, il est ainsi "
"possible d'en activer plusieurs en les combinant avec un *OU* binaire. Les "
"bits requis pour demander une certaine fonctionnalité se trouvent dans "
"l'attribut :attr:`~__future__._Feature.compiler_flag` de la classe :class:"
"`~__future__.Feature` du module :mod:`__future__`. Les :ref:`options du "
"compilateur <ast-compiler-flags>` se trouvent dans le module :mod:`ast`, "
"avec le préfixe ``PyCF_``."

#: library/functions.rst:267
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 niveaux "
"explicites sont : ``0`` (pas d'optimisation, ``__debug__`` est ``True``), "
"``1`` (les ``assert`` sont supprimés, ``__debug__`` est ``False``) ou ``2`` "
"(les *docstrings* sont également supprimées)."

#: library/functions.rst:273
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*."

#: library/functions.rst:276
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`."

#: library/functions.rst:279
msgid ""
"Raises an :ref:`auditing event <auditing>` ``compile`` with arguments "
"``source``, ``filename``."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``compile`` avec les arguments "
"``source`` et ``filename``."

#: library/functions.rst:281
msgid ""
"Raises an :ref:`auditing event <auditing>` ``compile`` with arguments "
"``source`` and ``filename``. This event may also be raised by implicit "
"compilation."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``compile`` avec les arguments "
"``source`` et ``filename``. Cet événement peut également être levé par une "
"compilation implicite."

#: library/functions.rst:287
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'``, celles-ci doivent être terminées par 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`."

#: library/functions.rst:294
msgid ""
"It is possible to crash the Python interpreter with a sufficiently large/"
"complex string when compiling to an AST object due to stack depth "
"limitations in Python's AST compiler."
msgstr ""
"Il est possible de faire planter l'interpréteur Python avec des chaînes "
"suffisamment grandes ou complexes lors de la compilation d'un objet AST. "
"Ceci est dû à limitation de la profondeur de la pile d'appels."

#: library/functions.rst:298
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. Par ailleurs, "
"la chaîne donnée à ``'exec'`` n'a plus besoin de terminer par un retour à la "
"ligne. Ajout du paramètre *optimize*."

#: library/functions.rst:302
msgid ""
"Previously, :exc:`TypeError` was raised when null bytes were encountered in "
"*source*."
msgstr ""
"Précédemment, l'exception :exc:`TypeError` était levée quand un caractère "
"nul était rencontré dans *source*."

#: library/functions.rst:306
msgid ""
"``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` can now be passed in flags to enable "
"support for top-level ``await``, ``async for``, and ``async with``."
msgstr ""
"``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` peut maintenant être passée à *flags* "
"pour permettre une gestion de ``await``, ``async for``, et ``async with`` de "
"haut niveau."

#: library/functions.rst:313
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 ""
"Renvoie 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 sans 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, renvoie "
"``0j``."

#: library/functions.rst:322
msgid ""
"For a general Python object ``x``, ``complex(x)`` delegates to ``x."
"__complex__()``.  If ``__complex__()`` is not defined then it falls back to :"
"meth:`__float__`.  If ``__float__()`` is not defined then it falls back to :"
"meth:`__index__`."
msgstr ""
"Pour un objet Python général ``x``, ``complex(x)`` délègue à ``x."
"__complex__()``. Si ``__complex__()`` n'est pas défini, alors il délègue à :"
"meth:`__float__`. Si ``__float__()`` n'est pas défini, alors il délègue à :"
"meth:`__index__`."

#: library/functions.rst:329
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 correct, mais ``complex('1 + 2j')`` lève une :exc:"
"`ValueError`."

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

#: library/functions.rst:622 library/functions.rst:838
msgid "Grouping digits with underscores as in code literals is allowed."
msgstr ""
"les chiffres peuvent être groupés avec des tirets bas comme dans les "
"expressions littérales."

#: library/functions.rst:339
msgid ""
"Falls back to :meth:`__index__` if :meth:`__complex__` and :meth:`__float__` "
"are not defined."
msgstr ""
"revient à :meth:`__index__` si :meth:`__complex__` et :meth:`__float__` ne "
"sont pas définis."

#: library/functions.rst:346
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``."

#: library/functions.rst:358
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."

#: library/functions.rst:361
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:`tuple`, ainsi que le module :mod:`collections`."

#: library/functions.rst:367
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 argument, elle donne la liste des noms dans l'espace de nommage local. "
"Avec un argument, elle essaye de donner une liste d'attributs valides pour "
"cet objet."

#: library/functions.rst:370
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 a 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`."

#: library/functions.rst:375
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 ""
"Si l'objet ne fournit pas de méthode :meth:`__dir__`, la fonction fait de "
"son mieux en rassemblant les informations de l'attribut :attr:`~object."
"__dict__` de l'objet, si défini, et depuis son type. La liste résultante "
"n'est pas nécessairement complète, et peut être inadaptée quand l'objet a "
"un :func:`__getattr__` personnalisé."

#: library/functions.rst:380
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 :"

#: library/functions.rst:384
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 ;"

#: library/functions.rst:387
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 ;"

#: library/functions.rst:390
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."

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

#: library/functions.rst:413
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 ensemble de noms pertinents "
"plutôt qu'un ensemble exhaustif 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és lorsque l'argument est une classe."

#: library/functions.rst:423
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)``."

#: library/functions.rst:435
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 ""
"Renvoie un objet énumérant. *iterable* doit être une séquence, un :term:"
"`itérateur <iterator>`, ou tout autre objet prenant en charge l'itération. "
"La méthode :meth:`~iterator.__next__` de l'itérateur donné par :func:"
"`enumerate` renvoie un *n*-uplet contenant un compte (démarrant à *start*, 0 "
"par défaut) et les valeurs obtenues de l'itération sur *iterable*."

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

#: library/functions.rst:458
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*."

#: library/functions.rst:462
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 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 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 with the *globals* and *locals* in the "
"environment where :func:`eval` is called.  Note, *eval()* does not have "
"access to the :term:`nested scopes <nested scope>` (non-locals) in the "
"enclosing environment."
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 nommage global et local. Si le "
"dictionnaire *globals* est présent mais ne contient pas de valeur pour la "
"clé ``__builtins__``, une référence au dictionnaire du module :mod:"
"`builtins` y est insérée avant qu'*expression* ne soit évaluée. Cela "
"signifie qu'*expression* a 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 exécutée "
"avec les dictionnaires *globals* et *locals* dans l'environnement où :func:"
"`eval` est appelée. Note, *eval()* n'a pas accès aux :term:`portées "
"imbriquées <nested scope>` (non locales) dans l'environnement englobant."

#: library/functions.rst:476
msgid ""
"The return value is the result of the evaluated expression. Syntax errors "
"are reported as exceptions.  Example:"
msgstr ""
"La valeur de retour est le résultat de l'expression évaluée. Les erreurs de "
"syntaxe sont signalées comme des exceptions. Exemple :"

#: library/functions.rst:483
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 (tels que ceux créés par :func:`compile`). Dans ce cas, donnez un objet "
"code plutôt qu'une chaîne. Si l'objet code a été compilé avec l'argument "
"*mode* à ``'exec'``, :func:`eval` donnera ``None``."

#: library/functions.rst:488
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` renvoient "
"respectivement les dictionnaires globaux et locaux, qui peuvent être utiles "
"lors de l'usage de :func:`eval` et :func:`exec`."

#: library/functions.rst:493
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."

#: library/functions.rst:532
msgid ""
"Raises an :ref:`auditing event <auditing>` ``exec`` with argument "
"``code_object``."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``exec`` avec l'argument "
"``code_object``."

#: library/functions.rst:534
msgid ""
"Raises an :ref:`auditing event <auditing>` ``exec`` with the code object as "
"the argument. Code compilation events may also be raised."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``exec`` avec l'objet de code "
"comme argument. Les événements de compilation de code peuvent également être "
"levés."

#: library/functions.rst:505
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 :ref:`file-input` in the Reference Manual). Be aware that the :"
"keyword:`nonlocal`, :keyword:`yield`,  and :keyword:`return` 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 :ref:`Fichier d'entrée <file-input>` dans le manuel de référence du "
"langage). Gardez en tête que les mots clés :keyword:`nonlocal`, :keyword:"
"`yield` et :keyword:`return` ne peuvent pas être utilisés en dehors d'une "
"fonction, même dans du code passé à :func:`exec`. La fonction renvoie "
"``None``."

#: library/functions.rst:516
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 (and "
"not a subclass of 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 (et pas une sous-classe de dictionnaire) utilisé pour les "
"variables globales et locales. Si les deux sont fournis, ils sont utilisés "
"respectivement pour les variables globales et locales. *locales* peut être "
"n'importe quel objet de correspondance. 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 "
"est exécuté comme s'il était inclus dans une définition de classe."

#: library/functions.rst:526
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 clé "
"``__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`."

#: library/functions.rst:539
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` renvoient "
"respectivement les dictionnaires globaux et locaux, qui peuvent être utiles "
"en deuxième et troisième argument de :func:`exec`."

#: library/functions.rst:545
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."

#: library/functions.rst:553
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* renvoie ``True``. *iterable* peut aussi bien être une séquence, "
"un conteneur qui prend en charge 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."

#: library/functions.rst:559
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(function, iterable)`` est l'équivalent du générateur "
"``(item for item in iterable if function(item))`` si *function* n'est pas "
"``None``, et de ``(item for item in iterable if item)`` si *function* est "
"``None``."

#: library/functions.rst:564
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 *function* renvoie ``False``."

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

#: library/functions.rst:576
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 doit contenir un nombre décimal, "
"é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* ou *pas un nombre* en français), "
"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ées :"

#: library/functions.rst:591
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."

#: library/functions.rst:596
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."

#: library/functions.rst:601
msgid ""
"For a general Python object ``x``, ``float(x)`` delegates to ``x."
"__float__()``.  If ``__float__()`` is not defined then it falls back to :"
"meth:`__index__`."
msgstr ""
"Pour un objet Python général ``x``, ``float(x)`` est délégué à ``x."
"__float__()``. Si ``__float__()`` n'est pas défini alors il est délégué à :"
"meth:`__index__`."

#: library/functions.rst:605
msgid "If no argument is given, ``0.0`` is returned."
msgstr "Sans argument, ``0.0`` est renvoyé."

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

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

#: library/functions.rst:628
msgid "Falls back to :meth:`__index__` if :meth:`__float__` is not defined."
msgstr "revient à :meth:`__index__` si :meth:`__float__` n'est pas défini."

#: library/functions.rst:638
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 », contrôlée 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`."

#: library/functions.rst:643
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. Dans ce cas, appeler cette "
"fonction a généralement le même effet qu'appeler :func:`str(value) <str>`."

#: library/functions.rst:646
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 *format_spec* ou le "
"résultat ne sont pas des chaînes de caractères."

#: library/functions.rst:653
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."

#: library/functions.rst:662
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 ""
"Renvoie 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 la documentation sur cette classe."

#: library/functions.rst:666
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`."

#: library/functions.rst:673
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 ""
"Renvoie 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, mais "
"que *default* est fourni, celui-ci est renvoyé. Sinon l'exception :exc:"
"`AttributeError` est levée."

#: library/functions.rst:681
msgid ""
"Since :ref:`private name mangling <private-name-mangling>` happens at "
"compilation time, one must manually mangle a private attribute's (attributes "
"with two leading underscores) name in order to retrieve it with :func:"
"`getattr`."
msgstr ""
"étant donné que la :ref:`transformation des noms privés <private-name-"
"mangling>` se produit au moment de la compilation, il faut modifier "
"manuellement le nom d'un attribut privé (attributs avec deux traits de "
"soulignement en tête) afin de le récupérer avec :func:`getattr`."

#: library/functions.rst:689
msgid ""
"Return the dictionary implementing the current module namespace. For code "
"within functions, this is set when the function is defined and remains the "
"same regardless of where the function is called."
msgstr ""
"Renvoie le dictionnaire implémentant l'espace de nommage du module actuel. "
"Pour le code dans les fonctions, il est défini lorsque la fonction est "
"définie et reste le même quel que soit le moment où la fonction est appelée."

#: library/functions.rst:696
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 de caractères. 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` a été levée)."

#: library/functions.rst:704
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 ""
"Renvoie la valeur de hachage d'un objet (s'il en a une). Les valeurs de "
"hachage sont des entiers. Elles sont utilisées pour comparer rapidement des "
"clés de dictionnaire lors de leur recherche. Les valeurs numériques égales "
"ont la même valeur de hachage (même si leurs types sont différents, comme "
"pour ``1`` et ``1.0``)."

#: library/functions.rst:711
msgid ""
"For objects 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'information."

#: library/functions.rst:717
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). Si aucun argument n'est fourni, le système d'aide démarre "
"dans l'interpréteur. Si l'argument est une chaîne, celle-ci est recherchée "
"comme le nom d'un module, d'une fonction, d'une classe, d'une méthode, d'un "
"mot clé, ou d'un sujet de documentation, 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."

#: library/functions.rst:724
msgid ""
"Note that if a slash(/) appears in the parameter list of a function, when "
"invoking :func:`help`, it means that the parameters prior to the slash are "
"positional-only. For more info, see :ref:`the FAQ entry on positional-only "
"parameters <faq-positional-only-arguments>`."
msgstr ""
"Notez que si une barre oblique (/) apparaît dans la liste des paramètres "
"d'une fonction, lorsque vous appelez :func:`help`, cela signifie que les "
"paramètres placés avant la barre oblique sont uniquement positionnels. Pour "
"plus d'informations, voir :ref:`La FAQ sur les arguments positionnels <faq-"
"positional-only-arguments>`."

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

#: library/functions.rst:731
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éhensibles et cohérentes."

#: library/functions.rst:738
msgid ""
"Convert an integer number to a lowercase hexadecimal string prefixed with "
"\"0x\". If *x* is not a Python :class:`int` object, it has to define an :"
"meth:`__index__` method that returns an integer. Some examples:"
msgstr ""
"Convertit un entier en chaîne hexadécimale préfixée de ``0x``. Si *x* n'est "
"pas un :class:`int`, il doit définir une méthode :meth:`__index__` qui "
"renvoie un entier. Quelques exemples :"

#: library/functions.rst:747
msgid ""
"If you want to convert an integer number to an uppercase or lower "
"hexadecimal string with prefix or not, you can use either of the following "
"ways:"
msgstr ""
"Si vous voulez convertir un nombre entier en chaîne hexadécimale, en "
"majuscule ou non, préfixée ou non, vous pouvez utiliser l'une des méthodes "
"suivantes :"

#: library/functions.rst:759
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 affectant 16 à l'argument *base*)."

#: library/functions.rst:764
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`."

#: library/functions.rst:770
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 ""
"Renvoie 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 dont les durées "
"de vie ne se chevauchent pas peuvent partager le même :func:`id`."

#: library/functions.rst:777
msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.id`` with argument "
"``id``."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``builtins.id`` avec l'argument "
"``id``."

#: library/functions.rst:782
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 lit ensuite une ligne sur l'entrée "
"standard et la convertit en chaîne (supprimant le retour à la ligne final) "
"quelle renvoie. Lorsque EOF est lu, :exc:`EOFError` est levée. Exemple ::"

#: library/functions.rst:792
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."

#: library/functions.rst:795
msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.input`` with argument "
"``prompt``."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``builtins.input`` avec "
"l'argument ``prompt``."

#: library/functions.rst:797
msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.input`` with argument "
"``prompt`` before reading input"
msgstr ""
"Lève un :ref:`auditing event <auditing>` ``builtins.input`` avec l'argument "
"``prompt`` avant de lire l'entrée."

#: library/functions.rst:800
#, fuzzy
msgid ""
"Raises an :ref:`auditing event <auditing>` ``builtins.input/result`` with "
"argument ``result``."
msgstr ""
"Lève un :ref:`évènement d'audit <auditing>` ``builtins.input/result`` avec "
"l'argument ``result``."

#: library/functions.rst:802
msgid ""
"Raises an auditing event ``builtins.input/result`` with the result after "
"successfully reading input."
msgstr ""
"Lève un événement d'audit ``builtins.input/result`` avec le résultat après "
"avoir lu avec succès l'entrée."

#: library/functions.rst:809
msgid ""
"Return an integer object constructed from a number or string *x*, or return "
"``0`` if no arguments are given.  If *x* defines :meth:`__int__`, ``int(x)`` "
"returns ``x.__int__()``.  If *x* defines :meth:`__index__`, it returns ``x."
"__index__()``.  If *x* defines :meth:`__trunc__`, it returns ``x."
"__trunc__()``. For floating point numbers, this truncates towards zero."
msgstr ""
"Renvoie un entier construit depuis un nombre ou une chaîne *x*, ou ``0`` si "
"aucun argument n'est fourni. Si *x* définit une méthode :meth:`__int__`, "
"``int(x)`` renvoie ``x.__int__()``. Si *x* définit :meth:`__index__`, "
"``int(x)`` renvoie ``x.__index__()`` Si *x* définit :meth:`__trunc__`, "
"``int(x)`` renvoie ``x.__trunc__()``. Les nombres à virgule flottante sont "
"tronqués vers zéro."

#: library/functions.rst:816
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 ``-`` (sans être séparés par une espace), 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 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, donc la base sera 2, 8, 10, ou 16, ainsi ``int('010', "
"0)`` n'est pas légal, alors que ``int('010')`` l'est tout comme ``int('010', "
"8)``."

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

#: library/functions.rst:831
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__>`."

#: library/functions.rst:844
msgid "Falls back to :meth:`__index__` if :meth:`__int__` is not defined."
msgstr "revient à :meth:`__index__` si :meth:`__int__` n'est pas défini."

#: library/functions.rst:847
msgid ""
":class:`int` string inputs and string representations can be limited to help "
"avoid denial of service attacks. A :exc:`ValueError` is raised when the "
"limit is exceeded while converting a string *x* to an :class:`int` or when "
"converting an :class:`int` into a string would exceed the limit. See the :"
"ref:`integer string conversion length limitation <int_max_str_digits>` "
"documentation."
msgstr ""

#: library/functions.rst:858
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 ""
"Renvoie ``True`` si *object* est une instance de *classinfo*, ou d'une de "
"ses classes filles, directe, indirecte, ou :term:`abstraite <abstract base "
"class>`. Si *object* n'est pas un objet du type donné, la fonction renvoie "
"toujours ``False``. Si *classinfo* est un *n*-uplet de types (ou "
"récursivement, d'autres *n*-uplets), renvoie ``True`` si *object* est une "
"instance de n'importe quel de ces types. Si *classinfo* n'est ni un type ni "
"un *n*-uplet de types (et récursivement), une exception :exc:`TypeError` est "
"levée."

#: library/functions.rst:870
#, fuzzy
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 (or recursively, other "
"such tuples), in which case return ``True`` if *class* is a subclass of any "
"entry in *classinfo*.  In any other case, a :exc:`TypeError` exception is "
"raised."
msgstr ""
"Renvoie ``True`` si *class* est une classe fille (directe, indirecte ou :"
"term:`abstraite <abstract base class>`) de *classinfo*. Une classe est "
"considérée sous-classe d'elle-même. *classinfo* peut être un *n*-uplet 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."

#: library/functions.rst:880
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 ""
"Renvoie un objet :term:`itérateur <iterator>`. La signification du premier "
"argument dépend grandement de la présence du second. Sans cet argument, "
"*object* doit être une collection d'objets prenant en charge le protocole "
"d'itération (la méthode :meth:`__iter__`) ou le protocole des séquences (la "
"méthode :meth:`getitem`, avec des nombres entiers commençant par ``0`` comme "
"argument). S'il ne gère aucun de ces protocoles, :exc:`TypeError` est levée. "
"Si le second argument *sentinel* est fourni, *object* doit être appelable. "
"L'itérateur créé dans ce cas appelle *object* sans argument à chaque appel "
"de :meth:`~iterator.__next__`. Si la valeur reçue est égale à *sentinel* :"
"exc:`StopIteration` est levée, sinon la valeur est renvoyée."

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

#: library/functions.rst:895
msgid ""
"One useful application of the second form of :func:`iter` is to build a "
"block-reader. For example, reading fixed-width blocks from a binary database "
"file until the end of file is reached::"
msgstr ""
"Une autre application utile de la deuxième forme de :func:`iter` est de "
"construire un lecteur par blocs. Par exemple, lire des blocs de taille fixe "
"d'une base de donnée binaire jusqu'à ce que la fin soit atteinte ::"

#: library/functions.rst:907
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 ""
"Renvoie la longueur (nombre d'éléments) d'un objet. L'argument peut être une "
"séquence (telle qu'une chaîne de caractères ou d'octets, un *n*-uplet, une "
"liste ou un intervalle) ou une collection (telle qu'un dictionnaire, un "
"ensemble ou un ensemble figé)."

#: library/functions.rst:913
msgid ""
"``len`` raises :exc:`OverflowError` on lengths larger than :data:`sys."
"maxsize`, such as :class:`range(2 ** 100) <range>`."
msgstr ""

#: library/functions.rst:921
msgid ""
"Rather than being a function, :class:`list` is actually a mutable sequence "
"type, as documented in :ref:`typesseq-list` and :ref:`typesseq`."
msgstr ""
"Contrairement aux apparences, :class:`list` n'est pas une fonction mais un "
"type séquentiel muable, comme décrit dans :ref:`typesseq-list` et :ref:"
"`typesseq`."

#: library/functions.rst:927
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. Note that at the module level, :func:"
"`locals` and :func:`globals` are the same dictionary."
msgstr ""
"Met à jour et renvoie un dictionnaire représentant la table des symboles "
"locaux. Les variables libres sont renvoyées par la fonction :func:`locals` "
"lorsque celle-ci est appelée dans le corps d'une fonction, mais pas dans le "
"corps d'une classe. Notez qu’au niveau d’un module, :func:`locals` et :func:"
"`globals` sont le même dictionnaire."

#: library/functions.rst:933
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 doit pas être modifié ; les changements "
"n'affectent pas les valeurs des variables locales ou libres utilisées par "
"l'interpréteur."

#: library/functions.rst:938
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 ""
"Renvoie 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 itérables en parallèle. Avec plusieurs "
"itérables, l'itération s'arrête avec l'itérable le plus court. Pour les cas "
"où les arguments sont déjà rangés sous forme de *n*-uplets, voir :func:"
"`itertools.starmap`."

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

#: library/functions.rst:952
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:`itérable "
"<iterable>`. Le plus grand élément de l'itérable est renvoyé. Si au moins "
"deux arguments positionnels sont fournis, l'argument le plus grand sera "
"renvoyé."

#: library/functions.rst:994
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 nommés optionnels. L'argument *key* spécifie une "
"fonction à un argument permettant de trier comme pour :meth:`list.sort`. "
"L'argument *default* fournit quant à lui 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."

#: library/functions.rst:963
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 renvoyé. C'est cohérent avec d'autres outils préservant une "
"stabilité lors du tri, tels que ``sorted(iterable, key=keyfunc, reverse=True)"
"[0]`` et ``heapq.nlargest(1, iterable, key=keyfunc)``."

#: library/functions.rst:1005
msgid "The *default* keyword-only argument."
msgstr "L'argument nommé (et seulement donné par son nom) *default*."

#: library/functions.rst:1008
msgid "The *key* can be ``None``."
msgstr "l'argument *key* peut être ``None``."

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

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

#: library/functions.rst:989
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:`itérable <iterable>`. Le "
"plus petit élément de l'itérable est renvoyé. Si au moins deux arguments "
"positionnels sont fournis, le plus petit argument positionnel est renvoyé."

#: library/functions.rst:1000
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 renvoie le premier "
"rencontré. C'est cohérent avec d'autres outils préservant une stabilité lors "
"du tri, tels que ``sorted(iterable, key=keyfunc)[0]`` et ``heapq."
"nsmallest(1, iterable, key=keyfunc)``."

#: library/functions.rst:1014
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 renvoyé si l'itérateur est "
"épuisé, sinon :exc:`StopIteration` est levée."

#: library/functions.rst:1021
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 ""
"Renvoie un objet vide. :class:`object` est la classe parente de toutes les "
"classes. C'est elle qui porte les méthodes communes à toutes les instances "
"de classes en Python. Cette fonction n'accepte aucun argument."

#: library/functions.rst:1027
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 arbitraires à une instance d':class:"
"`object`."

#: library/functions.rst:1033
msgid ""
"Convert an integer number to an octal string prefixed with \"0o\".  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. For example:"
msgstr ""
"Convertit un entier en sa représentation octale dans une chaîne préfixée de "
"``0o``. Le résultat est une expression Python valide. Si *x* n'est pas un "
"objet :class:`int`, il doit définir une méthode :meth:`__index__` qui donne "
"un entier, par exemple :"

#: library/functions.rst:1043
msgid ""
"If you want to convert an integer number to octal string either with prefix "
"\"0o\" or not, you can use either of the following ways."
msgstr ""
"Si vous voulez convertir un nombre entier en chaîne octale, avec ou sans le "
"préfixe ``0o``, vous pouvez utiliser l'une des méthodes suivantes."

#: library/functions.rst:1060
msgid ""
"Open *file* and return a corresponding :term:`file object`.  If the file "
"cannot be opened, an :exc:`OSError` is raised. See :ref:`tut-files` for more "
"examples of how to use this function."
msgstr ""
"Ouvre *file* et donne un :term:`objet fichier <file object>` correspondant. "
"Si le fichier ne peut pas être ouvert, une :exc:`OSError` est levée. Voir :"
"ref:`tut-files` pour plus d'exemple d'utilisation de cette fonction."

#: library/functions.rst:1064
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 ""
"*file* est un :term:`objet simili-chemin <path-like object>` donnant le "
"chemin (absolu ou relatif au répertoire courant) du fichier à ouvrir ou un "
"nombre entier représentant le descripteur de fichier à envelopper (si un "
"descripteur de fichier est donné, il sera fermé en même temps que l'objet "
"d'entrée-sortie renvoyé, sauf si *closefd* est mis à ``False``)."

#: library/functions.rst:1070
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 (en effaçant le contenu du fichier s'il existe), ainsi que ``'x'`` "
"permettant une création exclusive et ``'a'`` pour ajouter à la fin du "
"fichier (ce qui, sur certains systèmes Unix, signifie que *toutes* les "
"écritures seront des ajouts en fin de fichier, sans tenir compte de la "
"position demandée). En mode texte, si *encoding* n'est pas spécifié, "
"l'encodage utilisé dépend de la plate-forme : ``locale."
"getpreferredencoding(False)`` est appelée pour obtenir l'encodage défini par "
"les paramètres régionaux (pour lire et écrire des octets bruts, utilisez le "
"mode binaire sans préciser *encoding* non spécifié). Les modes disponibles "
"sont :"

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

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

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

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

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

#: library/functions.rst:1090
msgid "open for writing, truncating the file first"
msgstr "ouvre en écriture, en effaçant le contenu du fichier"

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

#: library/functions.rst:1091
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à"

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

#: library/functions.rst:1092
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"

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

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

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

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

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

#: library/functions.rst:1095
msgid "open for updating (reading and writing)"
msgstr "ouvre en modification (lecture et écriture)"

#: library/functions.rst:1098
msgid ""
"The default mode is ``'r'`` (open for reading text, synonym of ``'rt'``). "
"Modes ``'w+'`` and ``'w+b'`` open and truncate the file.  Modes ``'r+'`` and "
"``'r+b'`` open the file with no truncation."
msgstr ""
"Le mode par défaut est ``'r'`` (ouverture pour lire du texte, synonyme de "
"``'rt'``). Les modes ``'w+'`` et ``'w+b'`` ouvrent et vident le fichier. Les "
"modes ``'r+'`` et ``'r+b'`` ouvrent le fichier sans le vider."

#: library/functions.rst:1102
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 ""
"Comme mentionné dans :ref:`io-overview`, Python fait la différence entre les "
"entrées-sorties binaires et textes. 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 déduit de "
"l'environnement ou *encoding* s'il est donné."

#: library/functions.rst:1110
msgid ""
"There is an additional mode character permitted, ``'U'``, which no longer "
"has any effect, and is considered deprecated. It previously enabled :term:"
"`universal newlines` in text mode, which became the default behaviour in "
"Python 3.0. Refer to the documentation of the :ref:`newline <open-newline-"
"parameter>` parameter for further details."
msgstr ""
"Il y a un mode « caractères » supplémentaire autorisé, ``’U’``, qui n'a plus "
"d'effet, et est considéré comme obsolète. Auparavant, il activait les :term:"
"`retours à la ligne universels <universal newlines>` en mode texte, qui est "
"devenu le comportement par défaut dans Python 3.0. Référez-vous à la "
"documentation du paramètre :ref:`newline <open-newline-parameter>` pour plus "
"de détails."

#: library/functions.rst:1118
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 la représentation du fichier texte du système sous-"
"jacent. Tout le traitement est effectué par Python lui-même, et est ainsi "
"indépendant de la plate-forme."

#: library/functions.rst:1122
#, fuzzy
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. Note that specifying a buffer "
"size this way applies for binary buffered I/O, but ``TextIOWrapper`` (i.e., "
"files opened with ``mode='r+'``) would have another buffering. To disable "
"buffering in ``TextIOWrapper``, consider using the ``write_through`` flag "
"for :func:`io.TextIOWrapper.reconfigure`. 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. 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 :"

#: library/functions.rst:1132
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 mis 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."

#: library/functions.rst:1137
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` renvoie ``True``) utilisent un tampon par lignes. Les autres "
"fichiers texte sont traités comme les fichiers binaires."

#: library/functions.rst:1141
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:`encodage de texte <text encoding>` pris en charge "
"par Python peut être utilisé. Voir :mod:`codecs` pour une liste des "
"encodages pris en charge."

#: library/functions.rst:1148
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écodage sont gérées, ce n'est pas utilisable en mode "
"binaire. De nombreux 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 :"

#: library/functions.rst:1156
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."

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

#: library/functions.rst:1163
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 mal formées."

#: library/functions.rst:1166
#, fuzzy
msgid ""
"``'surrogateescape'`` will represent any incorrect bytes as low surrogate "
"code units ranging from U+DC80 to U+DCFF. These surrogate code units 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ésente chaque octet incorrect par un code "
"caractère de la zone *Private Use Area* d'Unicode, de *U+DC80* à *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."

#: library/functions.rst:1173
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 pris en charge à l'écriture vers un "
"fichier. Les caractères non gérés par l'encodage sont remplacés par une "
"entité XML de la forme ``&#nnn;``."

#: library/functions.rst:1177
msgid ""
"``'backslashreplace'`` replaces malformed data by Python's backslashed "
"escape sequences."
msgstr ""
"``'backslashreplace'`` remplace les données mal formées par des séquences "
"d'échappement Python (utilisant des barres obliques inverses)."

#: library/functions.rst:1180
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 gérés par des séquences d'échappement ``\\N{...}``."

#: library/functions.rst:1188
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:`retours à la ligne universels "
"<universal newlines>` fonctionne (seulement en mode texte). Il peut être "
"``None``, ``''``, ``'\\n'``, ``'\\r'``, et ``'\\r\\n'``. Il fonctionne comme "
"suit :"

#: library/functions.rst:1192
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 se terminer par ``'\\n'``, ``'\\r'``, ou "
"``'\\r\\n'``, et sont remplacées par ``'\\n'``, avant d'être renvoyées à "
"l'appelant. S'il vaut ``'*'``, le mode *universal newline* est activé mais "
"les fins de ligne ne sont pas remplacées. S'il a n'importe quelle autre "
"valeur autorisée, les lignes sont seulement terminées par la chaîne donnée, "
"qui est rendue telle quelle."

#: library/functions.rst:1200
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 remplacement n'est effectué. Si "
"*newline* est un autre caractère valide, chaque ``'\\n'`` sera remplacé par "
"la chaîne donnée."

#: library/functions.rst:1206
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."

#: library/functions.rst:1211
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 renvoyer un "
"descripteur de fichier ouvert (fournir :mod:`os.open` en tant qu'*opener* "
"aura le même effet que donner ``None``)."

#: library/functions.rst:1217
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éé."

#: library/functions.rst:1219
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 ::"

#: library/functions.rst:1232
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 d'\\ :term:`objet fichier <file object>` renvoyé 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 renvoie 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 renvoyée sera une fille de :class:`io.BufferedIOBase`. La "
"classe exacte varie : en lecture en mode binaire elle renvoie 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 renvoyée."

#: library/functions.rst:1253
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 tels que :mod:"
"`fileinput`, :mod:`io` (où :func:`open` est déclarée), :mod:`os`, :mod:`os."
"path`, :mod:`tmpfile`, et :mod:`shutil`."

#: library/functions.rst:1257
msgid ""
"Raises an :ref:`auditing event <auditing>` ``open`` with arguments ``file``, "
"``mode``, ``flags``."
msgstr ""
"Lève un :ref:`auditing event <auditing>` ``open`` avec les arguments "
"``file``, ``mode``, ``flags``."

#: library/functions.rst:1259
msgid ""
"The ``mode`` and ``flags`` arguments may have been modified or inferred from "
"the original call."
msgstr ""
"Les arguments ``mode`` et ``flags`` peuvent avoir été modifiés ou déduits de "
"l'appel original."

#: library/functions.rst:1265
msgid "The *opener* parameter was added."
msgstr "ajout du paramètre *opener*."

#: library/functions.rst:1266
msgid "The ``'x'`` mode was added."
msgstr "ajout du mode ``'x'``."

#: library/functions.rst:1267
msgid ":exc:`IOError` used to be raised, it is now an alias of :exc:`OSError`."
msgstr ""
":exc:`IOError` était normalement levée, elle est maintenant un alias de :exc:"
"`OSError`."

#: library/functions.rst:1268
msgid ""
":exc:`FileExistsError` is now raised if the file opened in exclusive "
"creation mode (``'x'``) already exists."
msgstr ""
":exc:`FileExistsError` est maintenant levée si le fichier ouvert en mode "
"création exclusive (``'x'``) existe déjà."

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

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

#: library/functions.rst:1283
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` pour la justification)."

#: library/functions.rst:1286
msgid "The ``'namereplace'`` error handler was added."
msgstr "ajout du gestionnaire d'erreurs ``'namereplace'``."

#: library/functions.rst:1291
msgid "Support added to accept objects implementing :class:`os.PathLike`."
msgstr "prise en charge des objets implémentant :class:`os.PathLike`."

#: library/functions.rst:1292
msgid ""
"On Windows, opening a console buffer may return a subclass of :class:`io."
"RawIOBase` other than :class:`io.FileIO`."
msgstr ""
"Sous Windows, ouvrir un *buffer* du terminal peut renvoyer une sous-classe "
"de :class:`io.RawIOBase` autre que :class:`io.FileIO`."

#: library/functions.rst:1297
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 ""
"Renvoie le nombre entier représentant le code Unicode du caractère "
"représenté par la chaîne donnée. Par exemple, ``ord('a')`` renvoie le nombre "
"entier ``97`` et ``ord('€')`` (symbole euro) renvoie ``8364``. Il s'agit de "
"l'inverse de :func:`chr`."

#: library/functions.rst:1305
msgid ""
"Return *base* to the power *exp*; if *mod* is present, return *base* to the "
"power *exp*, modulo *mod* (computed more efficiently than ``pow(base, exp) % "
"mod``). The two-argument form ``pow(base, exp)`` is equivalent to using the "
"power operator: ``base**exp``."
msgstr ""
"Renvoie *base* puissance *exp* et, si *mod* est présent, donne *base* "
"puissance *exp* modulo *mod* (calculé de manière plus efficiente que "
"``pow(base, exp) % mod``). La forme à deux arguments ``pow(base, exp)`` est "
"équivalente à l'opérateur puissance : ``base**exp``."

#: library/functions.rst:1310
#, fuzzy
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, ``pow(10, "
"2)`` returns ``100``, but ``pow(10, -2)`` returns ``0.01``.  For a negative "
"base of type :class:`int` or :class:`float` and a non-integral exponent, a "
"complex result is delivered.  For example, ``pow(-9, 0.5)`` returns a value "
"close to ``3j``."
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``."

#: library/functions.rst:1320
msgid ""
"For :class:`int` operands *base* and *exp*, if *mod* is present, *mod* must "
"also be of integer type and *mod* must be nonzero. If *mod* is present and "
"*exp* is negative, *base* must be relatively prime to *mod*. In that case, "
"``pow(inv_base, -exp, mod)`` is returned, where *inv_base* is an inverse to "
"*base* modulo *mod*."
msgstr ""
"Pour des opérandes *base* et *exp* de type :class:`int`, si *mod* est "
"présent, *mod* doit également être de type entier et *mod* doit être non "
"nul. Si *mod* est présent et que *exp* est négatif, *base* et *mod* doivent "
"être premiers entre eux. Dans ce cas, ``pow(inv_base, -exp, mod)`` est "
"renvoyé, où *inv_base* est un inverse de *base* modulo *mod*."

#: library/functions.rst:1326
msgid "Here's an example of computing an inverse for ``38`` modulo ``97``::"
msgstr "Voici un exemple de calcul d'un inverse de ``38`` modulo ``97`` ::"

#: library/functions.rst:1333
msgid ""
"For :class:`int` operands, the three-argument form of ``pow`` now allows the "
"second argument to be negative, permitting computation of modular inverses."
msgstr ""
"Pour les opérandes :class:`int`, la forme à trois arguments de ``pow`` "
"permet maintenant au deuxième argument d'être négatif, permettant le calcul "
"des inverses modulaires."

#: library/functions.rst:1338
msgid ""
"Allow keyword arguments.  Formerly, only positional arguments were supported."
msgstr ""
"Autorise les arguments par mots-clés. Auparavant, seuls les arguments "
"positionnels étaient autorisés."

#: library/functions.rst:1345
msgid ""
"Print *objects* to the text stream *file*, separated by *sep* and followed "
"by *end*.  *sep*, *end*, *file* and *flush*, 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*. Les arguments *sep*, *end*, *file*, et *flush*, s'ils sont présents, "
"doivent être nommés."

#: library/functions.rst:1349
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*."

#: library/functions.rst:1355
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(...)``."

#: library/functions.rst:1360
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."

#: library/functions.rst:1363
msgid "Added the *flush* keyword argument."
msgstr "ajout de l'argument nommé *flush*."

#: library/functions.rst:1369
msgid "Return a property attribute."
msgstr "Renvoie un attribut propriété."

#: library/functions.rst:1371
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* quant à elle permet de "
"supprimer la valeur d'un attribut, et *doc* créé une *docstring* pour "
"l'attribut."

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

#: library/functions.rst:1392
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`` appelle l'accesseur (*getter* en "
"anglais), ``c.x = value`` invoque le mutateur (*setter*), et ``del x`` le "
"destructeur (*deleter*)."

#: library/functions.rst:1395
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:`décorateur <decorator>` ::"

#: library/functions.rst:1408
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*."

#: library/functions.rst:1412
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é a 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 ::"

#: library/functions.rst:1434
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)."

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

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

#: library/functions.rst:1450
msgid ""
"Rather than being a function, :class:`range` is actually an immutable "
"sequence type, as documented in :ref:`typesseq-range` and :ref:`typesseq`."
msgstr ""
"Contrairement aux apparences, :class:`range` n'est pas une fonction mais un "
"type de séquence immuable, comme décrit dans :ref:`typesseq-range` et :ref:"
"`typesseq`."

#: library/functions.rst:1456
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 ""
"Renvoie une chaîne contenant une représentation affichable de l'objet. Pour "
"de nombreux types, cette fonction essaye de renvoyer une chaîne qui donnera "
"à son tour un objet de même 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 "
"renvoie pour ses instances en définissant une méthode :meth:`__repr__`."

#: library/functions.rst:1467
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 ""
"Renvoie un :term:`itérateur <iterator>` inversé. *seq* doit être un objet "
"ayant une méthode :meth:`__reverse__` ou prenant en charge le protocole "
"séquence (la méthode :meth:`__len__` et la méthode :meth:`__getitem__` avec "
"des arguments entiers commençant à zéro)."

#: library/functions.rst:1475
msgid ""
"Return *number* rounded to *ndigits* precision after the decimal point.  If "
"*ndigits* is omitted or is ``None``, it returns the nearest integer to its "
"input."
msgstr ""
"Renvoie *number* arrondi avec une précision de *ndigits* chiffres après la "
"virgule. Si *ndigits* est omis (ou est ``None``), l'entier le plus proche "
"est renvoyé."

#: library/functions.rst:1479
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``).  Any integer value is valid for *ndigits* (positive, zero, or "
"negative).  The return value is an integer if *ndigits* is omitted or "
"``None``. Otherwise the return value has 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``). *ndigits* accepte tout nombre entier (positif, "
"zéro, ou négatif). La valeur renvoyée est un entier si *ndigits* n'est pas "
"donné, (ou est ``None``). Sinon elle est du même type que *number*."

#: library/functions.rst:1488
msgid ""
"For a general Python object ``number``, ``round`` delegates to ``number."
"__round__``."
msgstr ""
"Pour tout autre objet Python ``number``, ``round`` délègue à ``number."
"__round__``."

#: library/functions.rst:1493
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 bogue, 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."

#: library/functions.rst:1504
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 ""
"Renvoie 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."

#: library/functions.rst:1508
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, comme : :class:`frozenset`, :class:`list`, :"
"class:`tuple`, et :class:`dict`, ainsi que le module :mod:`collections`."

#: library/functions.rst:1515
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``."

#: library/functions.rst:1523
msgid ""
"Since :ref:`private name mangling <private-name-mangling>` happens at "
"compilation time, one must manually mangle a private attribute's (attributes "
"with two leading underscores) name in order to set it with :func:`setattr`."
msgstr ""

#: library/functions.rst:1532
#, fuzzy
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 NumPy and other third party "
"packages. 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 ""
"Renvoie une :term:`tranche <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 « 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 "
"valeurs par défaut). Ils n'ont pas d'autre fonctionnalité explicite, "
"cependant ils sont utilisés par *Numerical Python* et d'autres bibliothèques "
"tierces. Les objets « tranches » sont aussi générés par la notation par "
"indice étendue. Par exemple ``a[start:stop:step]`` ou ``a[start:stop, i]``. "
"Voir :func:`itertools.islice` pour une version alternative renvoyant un "
"itérateur."

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

#: library/functions.rst:1547
msgid ""
"Has two optional arguments which must be specified as keyword arguments."
msgstr "A deux arguments optionnels qui doivent être nommés."

#: library/functions.rst:1549
msgid ""
"*key* specifies a function of one argument that is used to extract a "
"comparison key from each element in *iterable* (for example, ``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 clé de "
"comparaison de chaque élément de l'itérable (par exemple, ``key=str."
"lower``). La valeur par défaut est ``None`` (compare les éléments "
"directement)."

#: library/functions.rst:1553
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."

#: library/functions.rst:1556
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*."

#: library/functions.rst:1559
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 garantit de ne pas changer l'ordre relatif des éléments égaux entre "
"eux. C'est utile pour trier en plusieurs passes (par exemple par département "
"puis par salaire)."

#: library/functions.rst:1564
msgid ""
"The sort algorithm uses only ``<`` comparisons between items.  While "
"defining an :meth:`~object.__lt__` method will suffice for sorting, :PEP:`8` "
"recommends that all six :ref:`rich comparisons <comparisons>` be "
"implemented.  This will help avoid bugs when using the same data with other "
"ordering tools such as :func:`max` that rely on a different underlying "
"method.  Implementing all six comparisons also helps avoid confusion for "
"mixed type comparisons which can call reflected the :meth:`~object.__gt__` "
"method."
msgstr ""

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

#: library/functions.rst:1577
msgid "Transform a method into a static method."
msgstr "Transforme une méthode en méthode statique."

#: library/functions.rst:1579
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 ::"

#: library/functions.rst:1586
msgid ""
"The ``@staticmethod`` form is a function :term:`decorator` -- see :ref:"
"`function` for details."
msgstr ""
"La forme ``@staticmethod`` est un :term:`décorateur <decorator>` de "
"fonction. Consultez :ref:`function` pour plus de détails."

#: library/functions.rst:1589
msgid ""
"A static method can be called either on the class (such as ``C.f()``) or on "
"an instance (such as ``C().f()``)."
msgstr ""
"Une méthode statique peut être appelée sur une classe (par exemple, ``C."
"f()``) comme sur une instance (par exemple, ``C().f()``)."

#: library/functions.rst:1592
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."

#: library/functions.rst:1596
msgid ""
"Like all decorators, it is also possible to call ``staticmethod`` as a "
"regular function and do something with its result.  This is needed in some "
"cases where you need a reference to a function from a class body and you "
"want to avoid the automatic transformation to instance method.  For these "
"cases, use this idiom::"
msgstr ""
"Comme pour tous les décorateurs, il est possible d'appeler ``staticmethod`` "
"comme une simple fonction, et faire quelque chose de son résultat. Ça peut "
"être nécessaire dans le cas où vous voudriez une référence à la fonction "
"depuis le corps d'une classe, et souhaiteriez éviter sa transformation en "
"méthode d'instance. Pour ces cas, faites comme suit ::"

#: library/functions.rst:1605
msgid "For more information on static methods, see :ref:`types`."
msgstr ""
"Pour plus d'informations sur les méthodes statiques, consultez :ref:`types`."

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

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

#: library/functions.rst:1624
msgid ""
"Sums *start* and the items of an *iterable* from left to right and returns "
"the total.  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'un *iterable* de gauche à droite et en "
"donne le total. Les éléments de l'*iterable* sont normalement des nombres, "
"et la valeur de *start* ne peut pas être une chaîne de caractères."

#: library/functions.rst:1628
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`."

#: library/functions.rst:1634
msgid "The *start* parameter can be specified as a keyword argument."
msgstr "le paramètre *start* peut être passé comme un argument nommé."

#: library/functions.rst:1639
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."
msgstr ""
"Renvoie un objet mandataire (*proxy object* en anglais) déléguant les appels "
"de méthode à une classe parente ou sœur de *type*. C'est utile pour accéder "
"aux méthodes héritées qui ont été remplacées dans une classe."

#: library/functions.rst:1643
msgid ""
"The *object-or-type* determines the :term:`method resolution order` to be "
"searched.  The search starts from the class right after the *type*."
msgstr ""
"Le *object-or-type* détermine quel :term:`ordre de résolution des méthodes "
"<method resolution order>` est utilisé pour la recherche. La recherche "
"commence à partir de la classe qui suit immédiatement le *type*."

#: library/functions.rst:1647
msgid ""
"For example, if :attr:`~class.__mro__` of *object-or-type* is ``D -> B -> C -"
"> A -> object`` and the value of *type* is ``B``, then :func:`super` "
"searches ``C -> A -> object``."
msgstr ""
"Par exemple, si :attr:`~class.__mro__` de *object-or-type* est ``D -> B -> C "
"-> A -> object`` et la valeur de *type* est ``B``, alors :func:`super` "
"recherche ``C -> A -> object``."

#: library/functions.rst:1651
msgid ""
"The :attr:`~class.__mro__` attribute of the *object-or-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 *object-or-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."

#: library/functions.rst:1656
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)."

#: library/functions.rst:1661
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."

#: library/functions.rst:1666
#, fuzzy
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 "
"such implementations 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 appel 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 sœurs "
"inconnues avant l'exécution)."

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

#: library/functions.rst:1683
msgid ""
"In addition to method lookups, :func:`super` also works for attribute "
"lookups.  One possible use case for this is calling :term:`descriptors "
"<descriptor>` in a parent or sibling class."
msgstr ""
"En plus de la recherche de méthodes, :func:`super` fonctionne également pour "
"la recherche d'attributs. Un cas d'utilisation possible est l'appel d'un :"
"term:`descripteur <descriptor>` d'une classe parente ou sœur."

#: library/functions.rst:1687
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 comme ``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 tels que ``super()[name]``."

#: library/functions.rst:1694
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, :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."

#: library/functions.rst:1701
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/>`_."

#: library/functions.rst:1710
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, comme documenté dans :ref:`typesseq-tuple` et :ref:`typesseq`."

#: library/functions.rst:1719
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, renvoie le type d'*object*. La valeur renvoyée est un "
"objet type et généralement la même que la valeur de l'attribut :attr:`object."
"__class__ <instance.__class__>`."

#: library/functions.rst:1723
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."

#: library/functions.rst:1727
#, fuzzy
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 contains the base classes and becomes the :attr:`~class."
"__bases__` attribute; if empty, :class:`object`, the ultimate base of all "
"classes, is added.  The *dict* dictionary contains attribute and method "
"definitions for the class body; it may be copied or wrapped before becoming "
"the :attr:`~object.__dict__` attribute. The following two statements create "
"identical :class:`type` objects:"
msgstr ""
"Avec trois arguments, renvoie un nouveau type. C'est essentiellement une "
"forme dynamique de l'instruction :keyword:`class`. La chaîne *name* est le "
"nom de la classe et deviendra l'attribut :attr:`~definition.__name__` ; le "
"*n*-uplet *bases* contient les classes mères et deviendra l'attribut :attr:"
"`~class.__bases__` ; et le dictionnaire *dict* est l'espace de nommage "
"contenant les définitions du corps de la classe, il est copié vers un "
"dictionnaire standard pour devenir l'attribut :attr:`~object.__dict__`. Par "
"exemple, les deux instructions suivantes créent deux instances identiques "
"de :class:`type` :"

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

#: library/functions.rst:1744
msgid ""
"Keyword arguments provided to the three argument form are passed to the "
"appropriate metaclass machinery (usually :meth:`~object.__init_subclass__`) "
"in the same way that keywords in a class definition (besides *metaclass*) "
"would."
msgstr ""

#: library/functions.rst:1749
#, fuzzy
msgid "See also :ref:`class-customization`."
msgstr "Voir aussi :ref:`typeiter`."

#: library/functions.rst:1751
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 ""
"Les sous-classes de :class:`type` qui ne redéfinissent pas ``type.__new__`` "
"ne doivent plus utiliser la forme à un argument pour récupérer le type d'un "
"objet."

#: library/functions.rst:1757
msgid ""
"Return the :attr:`~object.__dict__` attribute for a module, class, instance, "
"or any other object with a :attr:`~object.__dict__` attribute."
msgstr ""
"Renvoie l'attribut :attr:`~object.__dict__` d'un module, d'une classe, d'une "
"instance ou de n'importe quel objet avec un attribut :attr:`~object."
"__dict__`."

#: library/functions.rst:1760
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 ""
"Certains objets, comme les modules et les instances, ont un attribut :attr:"
"`~object.__dict__` modifiable ; cependant, d'autres objets peuvent avoir des "
"restrictions en écriture sur leurs attributs :attr:`~object.__dict__` (par "
"exemple, les classes utilisent un :class:`types.MappingProxyType` pour "
"éviter les modifications directes du dictionnaire)."

#: library/functions.rst:1765
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 argument, :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."

#: library/functions.rst:1769
msgid ""
"A :exc:`TypeError` exception is raised if an object is specified but it "
"doesn't have a :attr:`~object.__dict__` attribute (for example, if its class "
"defines the :attr:`~object.__slots__` attribute)."
msgstr ""

#: library/functions.rst:1775
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."

#: library/functions.rst:1777
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 ""
"Renvoie un itérateur de *n*-uplets, où le *i*\\ :sup:`e` *n*-uplet contient "
"le *i*\\ :sup:`e` élément de chacune des séquences ou itérables fournis. "
"L'itérateur s'arrête lorsque le plus petit itérable fourni est épuisé. Avec "
"un seul argument itérable, elle renvoie un itérateur sur des *n*-uplets d'un "
"élément. Sans argument, elle renvoie un itérateur vide. Équivalent à ::"

#: library/functions.rst:1796
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 à 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 ; "
"par conséquent le *n*-uplet 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*."

#: library/functions.rst:1802
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 doit être utilisée avec des itérables de longueurs "
"différentes que lorsque les dernières données des itérables les plus longs "
"peuvent être ignorées. Si ces valeurs sont importantes, utilisez plutôt :"
"func:`itertools.zip_longest`."

#: library/functions.rst:1806
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 "
"dézipper une liste ::"

#: library/functions.rst:1827
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`."

#: library/functions.rst:1830
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 points d'entrée pour les importations (*import hooks*, "
"voir la :pep:`302`) pour le même résultat sans perturber 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`."

#: library/functions.rst:1839
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`."

#: library/functions.rst:1846
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 importation absolue ou relative. ``0`` (par "
"défaut) force à effectuer uniquement des importations absolues. Une valeur "
"positive indique le nombre de dossiers parents relativement au dossier du "
"module appelant :func:`__import__` (voir la :pep:`328`)."

#: library/functions.rst:1852
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 de plus haut niveau (le nom jusqu'au premier point) est renvoyé, "
"et *pas* le module nommé par *name*. Cependant, lorsqu'un argument "
"*fromlist* est fourni, le module nommé par *name* est renvoyé."

#: library/functions.rst:1857
msgid ""
"For example, the statement ``import spam`` results in bytecode resembling "
"the following code::"
msgstr ""
"Par exemple, l'instruction ``import spam`` renvoie un code intermédiaire "
"(*bytecode* en anglais) ressemblant au code suivant ::"

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

#: library/functions.rst:1866
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__` renvoie ici le module de plus haut niveau "
"parce que c'est l'objet lié à un nom par l'instruction :keyword:`import`."

#: library/functions.rst:1869
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, sausage as saus`` "
"donne ::"

#: library/functions.rst:1876
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 renvoyé par :func:`__import__`. De cet objet, "
"les noms à importer sont récupérés et assignés à leurs noms respectifs."

#: library/functions.rst:1880
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`."

#: library/functions.rst:1883
msgid ""
"Negative values for *level* are no longer supported (which also changes the "
"default value to 0)."
msgstr ""
"les valeurs négatives pour *level* ne sont plus prises en charge (et sa "
"valeur par défaut est 0)."

#: library/functions.rst:1887
msgid ""
"When the command line options :option:`-E` or :option:`-I` are being used, "
"the environment variable :envvar:`PYTHONCASEOK` is now ignored."
msgstr ""
"quand les options :option:`-E` ou :option:`-I` sont précisées dans la ligne "
"de commande, la variable d'environnement :envvar:`PYTHONCASEOK` est ignorée."

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

#: library/functions.rst:1893
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 l'analyseur 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."

#~ msgid ""
#~ "The optional argument *flags* also controls whether the compiled source "
#~ "is allowed to contain top-level ``await``, ``async for`` and ``async "
#~ "with``. When the bit ``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` is set, the "
#~ "return code object has ``CO_COROUTINE`` set in ``co_code``, and can be "
#~ "interactively executed via ``await eval(code_object)``."
#~ msgstr ""
#~ "L'argument optionnel *flags* contrôle également si la source compilée est "
#~ "autorisée à contenir des ``await``, des ``async for`` et des ``async "
#~ "with`` de haut niveau. Lorsque le bit ``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` "
#~ "est activé, l'objet code renvoyé a ``CO_COROUTINE`` activé dans "
#~ "``co_code``, et peut être exécuté de manière interactive via ``await "
#~ "eval(code_object)``."

#~ msgid "For more information on class methods, see :ref:`types`."
#~ msgstr ""
#~ "Pour plus d'informations sur les méthodes de classe, consultez :ref:"
#~ "`types`."