python-docs-fr/glossary.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2016, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-01-04 15:51+0100\n"
"PO-Revision-Date: 2017-12-01 08:51+0100\n"
"Last-Translator: Julien Palard <julien@palard.fr>\n"
"Language-Team: \n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.0.4\n"

#: ../Doc/glossary.rst:5
msgid "Glossary"
msgstr "Glossaire"

#: ../Doc/glossary.rst:10
msgid "``>>>``"
msgstr "``>>>``"

#: ../Doc/glossary.rst:12
msgid ""
"The default Python prompt of the interactive shell.  Often seen for code "
"examples which can be executed interactively in the interpreter."
msgstr ""
"L'invite de commande utilisée par défaut dans l'interpréteur interactif. On "
"la voit souvent dans des exemples de code qui peuvent être exécutés "
"interactivement dans l'interpréteur."

#: ../Doc/glossary.rst:14
msgid "``...``"
msgstr "``...``"

#: ../Doc/glossary.rst:16
msgid ""
"The default Python prompt of the interactive shell when entering code for an "
"indented code block or within a pair of matching left and right delimiters "
"(parentheses, square brackets or curly braces)."
msgstr ""
"L'invite de commande utilisée par défaut dans l'interpréteur interactif "
"lorsqu'on entre un bloc de code indenté ou entre deux délimiteurs "
"(parenthèses, crochets ou accolades)."

#: ../Doc/glossary.rst:19
msgid "2to3"
msgstr "3to3"

#: ../Doc/glossary.rst:21
msgid ""
"A tool that tries to convert Python 2.x code to Python 3.x code by handling "
"most of the incompatibilities which can be detected by parsing the source "
"and traversing the parse tree."
msgstr ""
"Un outil qui essaie de convertir du code pour Python 2.x en code pour Python "
"3.x en gérant la plupart des incompatibilités qui peuvent être détectées en "
"analysant la source et parcourant son arbre syntaxique."

#: ../Doc/glossary.rst:25
msgid ""
"2to3 is available in the standard library as :mod:`lib2to3`; a standalone "
"entry point is provided as :file:`Tools/scripts/2to3`.  See :ref:`2to3-"
"reference`."
msgstr ""
"2to3 est disponible dans la bibliothèque standard sous le nom de :mod:"
"`lib2to3`; un point d’entrée indépendant est fourni via :file:`Tools/"
"scripts/2to3`. Cf. :ref:`2to3-reference`."

#: ../Doc/glossary.rst:28
msgid "abstract base class"
msgstr "classe de base abstraite"

#: ../Doc/glossary.rst:30
msgid ""
"Abstract base classes complement :term:`duck-typing` by providing a way to "
"define interfaces when other techniques like :func:`hasattr` would be clumsy "
"or subtly wrong (for example with :ref:`magic methods <special-lookup>`).  "
"ABCs introduce virtual subclasses, which are classes that don't inherit from "
"a class but are still recognized by :func:`isinstance` and :func:"
"`issubclass`; see the :mod:`abc` module documentation.  Python comes with "
"many built-in ABCs for data structures (in the :mod:`collections.abc` "
"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` "
"module), import finders and loaders (in the :mod:`importlib.abc` module).  "
"You can create your own ABCs with the :mod:`abc` module."
msgstr ""
"Les classes de base abstraites (ABC, suivant l'abréviation anglaise "
"*Abstract Base Class*) complètent le :term:`duck-typing` en fournissant un "
"moyen de définir des interfaces pour les cas où d'autres techniques comme :"
"func:`hasattr` seraient inélégantes, ou subitement fausse (par exemple avec "
"les :ref:`méthodes magiques <special-lookup>`). Les ABC introduisent des "
"sous-classes virtuelles, qui n'héritent pas d'une classe mais qui sont quand "
"même reconnues par :func:`isinstance` ou :func:`issubclass` (Voir la "
"documentation du module :mod:`abc`). Python contient de nombreuses ABC pour "
"les structures de données (dans le module :mod:`collections.abc`), les "
"nombres (dans le module :mod:`numbers`), les flux (dans le module :mod:"
"`io`), et les chercheurs / chargeurs d'import (dans le module :mod:"
"`importlib.abc`). Vous pouvez créer vos propres ABC avec le module :mod:"
"`abc`."

#: ../Doc/glossary.rst:41
msgid "argument"
msgstr "argument"

#: ../Doc/glossary.rst:43
msgid ""
"A value passed to a :term:`function` (or :term:`method`) when calling the "
"function.  There are two kinds of argument:"
msgstr ""
"Une valeur, donnée à une :term:`fonction` ou à une :term:`méthode` lors de "
"son appel. Il existe deux types d'arguments :"

#: ../Doc/glossary.rst:46
msgid ""
":dfn:`keyword argument`: an argument preceded by an identifier (e.g. "
"``name=``) in a function call or passed as a value in a dictionary preceded "
"by ``**``.  For example, ``3`` and ``5`` are both keyword arguments in the "
"following calls to :func:`complex`::"
msgstr ""
":dfn:`argument nommé`: un argument précédé d'un identifiant (comme "
"``name=``) ou un dictionnaire précédé de ``**``, lors d'un appel de "
"fonction. Par exemple, ``3`` et ``5`` sont tous les deux des arguments "
"nommés dans l'appel à :func:`complex` ici : ::"

#: ../Doc/glossary.rst:54
msgid ""
":dfn:`positional argument`: an argument that is not a keyword argument. "
"Positional arguments can appear at the beginning of an argument list and/or "
"be passed as elements of an :term:`iterable` preceded by ``*``. For example, "
"``3`` and ``5`` are both positional arguments in the following calls::"
msgstr ""
":dfn:`argument positionnel` : Un argument qui n'est pas nommé. Les arguments "
"positionnels apparaissent au début de la liste des arguments, ou donnés sous "
"forme d'un :term:`itérable` précédé par ``*``. Par exemple, ``3`` et ``5`` "
"sont tous les deux des arguments positionnels dans les appels suivants : ::"

#: ../Doc/glossary.rst:63
msgid ""
"Arguments are assigned to the named local variables in a function body. See "
"the :ref:`calls` section for the rules governing this assignment. "
"Syntactically, any expression can be used to represent an argument; the "
"evaluated value is assigned to the local variable."
msgstr ""
"Les arguments se retrouvent dans le corps de la fonction appelée parmi les "
"variables locales. Voir la section :ref:`calls` à propos des règles dictant "
"cet affectation. Syntaxiquement, toute expression est acceptée comme "
"argument, et c'est la valeur résultante de l'expression qui sera affectée à "
"la variable locale."

#: ../Doc/glossary.rst:68
msgid ""
"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the "
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
"and :pep:`362`."
msgstr ""
"Voir aussi :term:`parameter` dans le glossaire, la FAQ a aussi une question "
"à propos de :ref:`la différence entre argument et paramètre <faq-argument-vs-"
"parameter>` et la :pep:`362`."

#: ../Doc/glossary.rst:71
msgid "asynchronous context manager"
msgstr "gestionnaire de contexte asynchrone"

#: ../Doc/glossary.rst:73
msgid ""
"An object which controls the environment seen in an :keyword:`async with` "
"statement by defining :meth:`__aenter__` and :meth:`__aexit__` methods.  "
"Introduced by :pep:`492`."
msgstr ""
"(*asynchronous context manager*) Un objet contrôlant l'environnement à "
"l'intérieur d'une instruction :keyword:`with` en définissant les méthodes :"
"meth:`__aenter__` et :meth:`__aexit__`. Introduit dans la :pep:`492`."

#: ../Doc/glossary.rst:76
msgid "asynchronous generator"
msgstr "générateur asynchrone"

#: ../Doc/glossary.rst:78
msgid ""
"A function which returns an :term:`asynchronous generator iterator`.  It "
"looks like a coroutine function defined with :keyword:`async def` except "
"that it contains :keyword:`yield` expressions for producing a series of "
"values usable in an :keyword:`async for` loop."
msgstr ""
"Une fonction qui renvoie un :term:`asynchronous generator iterator`.  Cela "
"ressemble à une coroutine définie par :keyword:`async def` mais contenant "
"une ou des expressions :keyword:`yield` produisant ainsi uns série de "
"valeurs utilisables dans une boucle :keyword:`async for`."

#: ../Doc/glossary.rst:83
msgid ""
"Usually refers to a asynchronous generator function, but may refer to an "
"*asynchronous generator iterator* in some contexts.  In cases where the "
"intended meaning isn't clear, using the full terms avoids ambiguity."
msgstr ""
"Fait généralement allusion à une fonction générateur asynchrone, mais peut "
"faire allusion à un *itérateur de générateur asynchrone* dans certains "
"contextes. Dans les cas où le sens voulu n'est pas clair, utiliser les "
"termes complets évite l'ambiguité."

#: ../Doc/glossary.rst:87
msgid ""
"An asynchronous generator function may contain :keyword:`await` expressions "
"as well as :keyword:`async for`, and :keyword:`async with` statements."
msgstr ""
"Un générateur asynchrone peut contenir des expressions :keyword:`await` "
"ainsi que des instructions :keyword:`async for`, et :keyword:`async with`."

#: ../Doc/glossary.rst:90
msgid "asynchronous generator iterator"
msgstr "itérateur de générateur asynchrone"

#: ../Doc/glossary.rst:92
msgid "An object created by a :term:`asynchronous generator` function."
msgstr "Un objet crée par une fonction :term:`asynchronous generator`."

#: ../Doc/glossary.rst:94
msgid ""
"This is an :term:`asynchronous iterator` which when called using the :meth:"
"`__anext__` method returns an awaitable object which will execute that the "
"body of the asynchronous generator function until the next :keyword:`yield` "
"expression."
msgstr ""
"C'est un :term:`asynchronous iterator` qui, lorsqu'il est appelé via la "
"méthode :meth:`__anext__` renvoie un objet *awaitable* qui exécutera le "
"corps de la fonction du générateur asynchrone jusqu'au prochain :keyword:"
"`yield`."

#: ../Doc/glossary.rst:99
msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"location execution state (including local variables and pending try-"
"statements).  When the *asynchronous generator iterator* effectively resumes "
"with another awaitable returned by :meth:`__anext__`, it picks-up where it "
"left-off.  See :pep:`492` and :pep:`525`."
msgstr ""
"Chaque :keyword:`yield` suspend temporairement l'exécution, se rappelant de "
"l'endroit et de l'état de l'exécution (incluant les variables locales et les "
"*try* en cours). Lorsque l'itérateur de générateur asynchrone reprend avec "
"un nouvel *awaitable* renvoyé par :meth:`__anext__`, il repart de là où il "
"en était.  Voir :pep:`492` et :pep:`525`."

#: ../Doc/glossary.rst:104
msgid "asynchronous iterable"
msgstr "itérable asynchrone"

#: ../Doc/glossary.rst:106
msgid ""
"An object, that can be used in an :keyword:`async for` statement. Must "
"return an :term:`asynchronous iterator` from its :meth:`__aiter__` method.  "
"Introduced by :pep:`492`."
msgstr ""
"Un objet qui peut être utilisé dans une instruction :keyword:`async for`. Sa "
"méthode :meth:`__aiter__` doit renvoyer un :term:`asynchronous iterator`. "
"Introduit dans la :pep:`492`."

#: ../Doc/glossary.rst:109
msgid "asynchronous iterator"
msgstr "itérateur asynchrone"

#: ../Doc/glossary.rst:111
msgid ""
"An object that implements :meth:`__aiter__` and :meth:`__anext__` methods.  "
"``__anext__`` must return an :term:`awaitable` object. :keyword:`async for` "
"resolves awaitable returned from asynchronous iterator's :meth:`__anext__` "
"method until it raises :exc:`StopAsyncIteration` exception.  Introduced by :"
"pep:`492`."
msgstr ""
"Un objet qui implémente les méthodes :meth:`__aiter__` et :meth:`__anext__`. "
"``__anext__`` doit renvoyer un objet :term:`awaitable`. :keyword:`async for` "
"résoud le awaitable renvoyé par la méthode :meth:`__anext__` de l'itérateur "
"asynchrone jusqu'à ce qu'il lève une exception :exc:`StopAsyncIteration`.  "
"Introduit dans la :pep:`492`."

#: ../Doc/glossary.rst:116
msgid "attribute"
msgstr "attribut"

#: ../Doc/glossary.rst:118
msgid ""
"A value associated with an object which is referenced by name using dotted "
"expressions.  For example, if an object *o* has an attribute *a* it would be "
"referenced as *o.a*."
msgstr ""
"Une valeur associée à un objet et désignée par son nom via une notation "
"utilisant des points. Par exemple, si un objet *o* a un attribut *a*, il "
"sera référencé par *o.a*."

#: ../Doc/glossary.rst:121
msgid "awaitable"
msgstr "awaitable"

#: ../Doc/glossary.rst:123
msgid ""
"An object that can be used in an :keyword:`await` expression.  Can be a :"
"term:`coroutine` or an object with an :meth:`__await__` method. See also :"
"pep:`492`."
msgstr ""
"Un objet pouvant être utilisé dans une expression :keyword:`await`. Peut "
"être une :term:`coroutine` ou un objet avec une méthode :meth:`__await__`. "
"Voir aussi :pep:`492`."

#: ../Doc/glossary.rst:126
msgid "BDFL"
msgstr "BDFL"

#: ../Doc/glossary.rst:128
msgid ""
"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://www.python."
"org/~guido/>`_, Python's creator."
msgstr ""
"Bienveillant dictateur à vie (de *Benevolent Dictator For Life*), alias "
"`Guido van Rossum <https://www.python.org/~guido/>`_, le créateur de Python."

#: ../Doc/glossary.rst:130
msgid "binary file"
msgstr "fichier binaire"

#: ../Doc/glossary.rst:132
msgid ""
"A :term:`file object` able to read and write :term:`bytes-like objects "
"<bytes-like object>`. Examples of binary files are files opened in binary "
"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys."
"stdout.buffer`, and instances of :class:`io.BytesIO` and :class:`gzip."
"GzipFile`."
msgstr ""
"Un :term:`file object` capable de lire et d'écrire des :term:`bytes-like "
"objects <bytes-like object>`. Voici quelques exemples de fichiers binaires "
"ouverts en mode binaire (``'rb'``, ``'wb'``, ou ``'rb+'``), :data:`sys.stdin."
"buffer`, :data:`sys.stdout.buffer`, les instances de :class:`io.BytesIO`, et "
"de :class:`gzip.GzipFile`."

#: ../Doc/glossary.rst:140
msgid "A :term:`text file` reads and writes :class:`str` objects."
msgstr "Un :term:`fichier texte` lis et écris des objets :class:`str`."

#: ../Doc/glossary.rst:141
msgid "bytes-like object"
msgstr "Objet bytes-compatible"

#: ../Doc/glossary.rst:143
msgid ""
"An object that supports the :ref:`bufferobjects` and can export a C-:term:"
"`contiguous` buffer. This includes all :class:`bytes`, :class:`bytearray`, "
"and :class:`array.array` objects, as well as many common :class:`memoryview` "
"objects.  Bytes-like objects can be used for various operations that work "
"with binary data; these include compression, saving to a binary file, and "
"sending over a socket."
msgstr ""
"Un objet gèrant les :ref:`bufferobjects` et peut exporter un buffer C-:term:"
"`contiguous`. Cela inclu les objets :class:`bytes`, :class:`bytearray`, et :"
"class:`array.array`, ainsi que beaucoup d'objets :class:`memoryview`. Les "
"objets bytes-compatibles peuvent être utilisés pour diverses opérations sur "
"des données binaires, comme la compression, la sauvegard dans un fichier "
"binaire, ou l'envoi sur une socket."

#: ../Doc/glossary.rst:150
msgid ""
"Some operations need the binary data to be mutable.  The documentation often "
"refers to these as \"read-write bytes-like objects\".  Example mutable "
"buffer objects include :class:`bytearray` and a :class:`memoryview` of a :"
"class:`bytearray`. Other operations require the binary data to be stored in "
"immutable objects (\"read-only bytes-like objects\"); examples of these "
"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object."
msgstr ""
"Certaines opérations nécessitent de travailler sur des données binaires "
"variables. La documentation parle de ceux-ci comme des \"read-write bytes-"
"like objects\". Par exemple, :class:`bytearray`, et une :class:`memoryview` "
"d'un :class:`bytearray` en sont. D'autres opérations nécessitent de "
"travailler sur des données binaires stockées dans des objets immuables (*"
"\"read-only bytes-like objects\"*), par exemples :class:`bytes` et :class:"
"`memoryview` d'un objet :class:`byte`."

#: ../Doc/glossary.rst:158
msgid "bytecode"
msgstr "bytecode"

#: ../Doc/glossary.rst:160
msgid ""
"Python source code is compiled into bytecode, the internal representation of "
"a Python program in the CPython interpreter.  The bytecode is also cached in "
"``.pyc`` files so that executing the same file is faster the second time "
"(recompilation from source to bytecode can be avoided).  This \"intermediate "
"language\" is said to run on a :term:`virtual machine` that executes the "
"machine code corresponding to each bytecode. Do note that bytecodes are not "
"expected to work between different Python virtual machines, nor to be stable "
"between Python releases."
msgstr ""
"Le code source, en Python, est compilé en un bytecode, la représentation "
"interne à CPython d'un programme Python. Le bytecode est stocké dans un "
"fichier nommé ``.pyc`` de manière à ce qu'une seconde exécution soit plus "
"rapide (en évitant ainsi de recommencer la compilation en bytecode). On dit "
"que ce *langage intermédiaire* est exécuté sur une :term:`virtual machine` "
"qui exécute des instructions machine pour chaque instruction du bytecode. "
"Notez que le bytecode n'a pas vocation à fonctionner entre différentes "
"machines virtuelle Python, encore moins entre différentes version de Python."

#: ../Doc/glossary.rst:170
msgid ""
"A list of bytecode instructions can be found in the documentation for :ref:"
"`the dis module <bytecodes>`."
msgstr ""
"Une liste des instructions du bytecode se trouve dans la documentation du :"
"ref:`module dis <bytecodes>`."

#: ../Doc/glossary.rst:172
msgid "class"
msgstr "classe"

#: ../Doc/glossary.rst:174
msgid ""
"A template for creating user-defined objects. Class definitions normally "
"contain method definitions which operate on instances of the class."
msgstr ""
"Un modèle pour créer des objets définis par l'utilisateur. Les définitions "
"de classes (*class*) contiennent normalement des définitions de méthodes qui "
"agissent sur les instances de classe."

#: ../Doc/glossary.rst:177
msgid "coercion"
msgstr "coercition"

#: ../Doc/glossary.rst:179
msgid ""
"The implicit conversion of an instance of one type to another during an "
"operation which involves two arguments of the same type.  For example, "
"``int(3.15)`` converts the floating point number to the integer ``3``, but "
"in ``3+4.5``, each argument is of a different type (one int, one float), and "
"both must be converted to the same type before they can be added or it will "
"raise a ``TypeError``.  Without coercion, all arguments of even compatible "
"types would have to be normalized to the same value by the programmer, e.g., "
"``float(3)+4.5`` rather than just ``3+4.5``."
msgstr ""
"La conversion implicite d'une instance d'un type vers un autre lors d'une "
"opération impliquant deux opérandes de même type. Par exemple ``int(3.15)`` "
"convertis explicitement le nombre à virgule flottante en nombre entier (ici, "
"``3``), mais dans l'opération ``3 + 4.5``, les deux opérandes ont un type "
"différent, alors qu'elles doivent avoir le même type pour être additionnées, "
"sans quoi une exception ``TypeError`` serait levée. Sans coercition, toutes "
"les opérandes, même de types compatibles, devraient être converties (on "
"parle aussi de *cast*) explicitement par le développeur, par exemple : "
"``float(3) + 4.5`` au lieu du simple ``3 + 4.5``."

#: ../Doc/glossary.rst:187
msgid "complex number"
msgstr "nombre complexe"

#: ../Doc/glossary.rst:189
msgid ""
"An extension of the familiar real number system in which all numbers are "
"expressed as a sum of a real part and an imaginary part.  Imaginary numbers "
"are real multiples of the imaginary unit (the square root of ``-1``), often "
"written ``i`` in mathematics or ``j`` in engineering.  Python has built-in "
"support for complex numbers, which are written with this latter notation; "
"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``.  To get "
"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`.  "
"Use of complex numbers is a fairly advanced mathematical feature.  If you're "
"not aware of a need for them, it's almost certain you can safely ignore them."
msgstr ""
"Une extension du système numéral réel familier dans laquelle tous les "
"nombres sont exprimés sous la forme d'une somme d'un réel et d'un "
"imaginaire. Les nombres imaginaures sont de réels multiples d'une unité "
"imaginaire (la racine carrée de ``-1``), souvent écrite ``i`` en "
"mathématiques ou ``j`` en ingénierie. Python supporte nativement les nombres "
"complexes, écrits avec cette dernière notation; la partie imaginaire est "
"écrite avec un suffixe ``j``, exemple, ``3+1j``. Pour utiliser les "
"équivalents complexes à :mod:`math`, utilisez :mod:`cmath`. L'utilisation "
"des nombres complexes est une caractéristiques des mathématiques avancées. "
"Si vous n'en avez pas l'utilité, vous pouvez les ignorer en toute "
"tranquilité."

#: ../Doc/glossary.rst:199
msgid "context manager"
msgstr "gestionnaire de contexte"

#: ../Doc/glossary.rst:201
msgid ""
"An object which controls the environment seen in a :keyword:`with` statement "
"by defining :meth:`__enter__` and :meth:`__exit__` methods. See :pep:`343`."
msgstr ""
"Un objet contrôlant l'environnement a l'intérieur d'une instruction :keyword:"
"`with` en définissant les méthodes :meth:`__enter__` et :meth:`__exit__`. "
"Consultez la :pep:`343`."

#: ../Doc/glossary.rst:204
msgid "contiguous"
msgstr "contigu"

#: ../Doc/glossary.rst:208
msgid ""
"A buffer is considered contiguous exactly if it is either *C-contiguous* or "
"*Fortran contiguous*.  Zero-dimensional buffers are C and Fortran "
"contiguous.  In one-dimensional arrays, the items must be laid out in memory "
"next to each other, in order of increasing indexes starting from zero.  In "
"multidimensional C-contiguous arrays, the last index varies the fastest when "
"visiting items in order of memory address.  However, in Fortran contiguous "
"arrays, the first index varies the fastest."
msgstr ""
"Un buffer est considéré contigu s’il est soit *C-contigu* soit *Fortran-"
"contigu*. Les tableaux de dimension zéro sont C-contigus et Fortran-"
"contigus. Pour un tableau à une dimension, ses éléments doivent être placés "
"en mémoire l’un à côté de l’autre, dans l’ordre croissant de leur indice, "
"commençant à zéro. Pour qu’un tableau multidimensionnel soit C-contigu, le "
"dernier indice doit être celui qui varie le plus rapidement lors du parcours "
"de ses éléments dans l’ordre de leur adresse mémoire. A l'inverse, dans les "
"tableaux Fortran-contigu, c’est le premier indice qui doit varier le plus "
"rapidement."

#: ../Doc/glossary.rst:216
msgid "coroutine"
msgstr "coroutine"

#: ../Doc/glossary.rst:218
msgid ""
"Coroutines is a more generalized form of subroutines. Subroutines are "
"entered at one point and exited at another point.  Coroutines can be "
"entered, exited, and resumed at many different points.  They can be "
"implemented with the :keyword:`async def` statement.  See also :pep:`492`."
msgstr ""
"Les coroutines sont une forme généralisées des fonctions. Les fonctions sont "
"accédées en un point et sortent en un point. Les coroutines peuvent être "
"accédées, quittées, reprises en plusieurs points. Elles peuvent être "
"implémentées via l'instruction :keyword:`async def`. Voir aussi :pep:`492`."

#: ../Doc/glossary.rst:223
msgid "coroutine function"
msgstr "fonction coroutine"

#: ../Doc/glossary.rst:225
msgid ""
"A function which returns a :term:`coroutine` object.  A coroutine function "
"may be defined with the :keyword:`async def` statement, and may contain :"
"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords.  "
"These were introduced by :pep:`492`."
msgstr ""
"Une fonction qui donne un objet :term:`coroutine`. Une fonction coroutine "
"peut être définie par l'instruction :keyword:`async def`, et peuvent "
"contenir les mots clefs :keyword:`await`, :keyword:`async for`, et :keyword:"
"`async with`. Elles sont introduites par la :pep:`492`."

#: ../Doc/glossary.rst:230
msgid "CPython"
msgstr "CPython"

#: ../Doc/glossary.rst:232
msgid ""
"The canonical implementation of the Python programming language, as "
"distributed on `python.org <https://www.python.org>`_.  The term \"CPython\" "
"is used when necessary to distinguish this implementation from others such "
"as Jython or IronPython."
msgstr ""
"L'implémentation canonique du langage de programmation Python, tel que "
"distribué sur `python.org <https://www.python.org>`_. Le terme \"CPython\" "
"est utilisé dans certains contextes lorsqu'il est nécessaire de distinguer "
"cette implémentation des autres comme Jython ou IronPython."

#: ../Doc/glossary.rst:236
msgid "decorator"
msgstr "décorateur"

#: ../Doc/glossary.rst:238
msgid ""
"A function returning another function, usually applied as a function "
"transformation using the ``@wrapper`` syntax.  Common examples for "
"decorators are :func:`classmethod` and :func:`staticmethod`."
msgstr ""
"Une fonction renvoyant une autre fonction, utilisé habituellement dans une "
"transformation de fonction via la syntaxe ``@wrapper``. Les exemples "
"habituels pour les décorateurs (*decorators*) sont :func:`classmethod` et :"
"func:`staticmethod`."

#: ../Doc/glossary.rst:242
msgid ""
"The decorator syntax is merely syntactic sugar, the following two function "
"definitions are semantically equivalent::"
msgstr ""
"La syntaxe des décorateurs est simplement du sucre syntaxique, les "
"définitions des deux fonctions suivantes sont sémantiquement équivalentes :"

#: ../Doc/glossary.rst:253
msgid ""
"The same concept exists for classes, but is less commonly used there.  See "
"the documentation for :ref:`function definitions <function>` and :ref:`class "
"definitions <class>` for more about decorators."
msgstr ""
"Quoique moins fréquemment utilisé, le même concept existe pour les classes. "
"Consultez la documentation :ref:`définitions de fonctions <function>` et :"
"ref:`définitions de classes <class>` pour en savoir plus sur les décorateurs."

#: ../Doc/glossary.rst:256
msgid "descriptor"
msgstr "descripteur"

#: ../Doc/glossary.rst:258
msgid ""
"Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or :"
"meth:`__delete__`.  When a class attribute is a descriptor, its special "
"binding behavior is triggered upon attribute lookup.  Normally, using *a.b* "
"to get, set or delete an attribute looks up the object named *b* in the "
"class dictionary for *a*, but if *b* is a descriptor, the respective "
"descriptor method gets called.  Understanding descriptors is a key to a deep "
"understanding of Python because they are the basis for many features "
"including functions, methods, properties, class methods, static methods, and "
"reference to super classes."
msgstr ""
"N'importe quel objet définissant les méthodes :meth:`__get__`, :meth:"
"`__set__`, ou :meth:`__delete__`. Lorsque l'attribut d'une classe est un "
"descripteur, son comportement spécial est déclenché lors de la recherche des "
"attributs. En utilisant *a.b* pour obtenir, affecter, ou effacer un "
"attribut, il recherche l'objet nommé *b* dans la dictionnaire de la classe "
"pour *a*, mais si *b* est un descripteur, la méthode de ce descripteur est "
"alors appelée. Comprendre les descripteurs est la clé d'une compréhension "
"approfondie de Python, ils sont la base de nombre de ses caractéristiques "
"notamment les fonctions, méthodes, propriétés, méthodes de classe, méthodes "
"statiques, et les références aux classes mères."

#: ../Doc/glossary.rst:268
msgid ""
"For more information about descriptors' methods, see :ref:`descriptors`."
msgstr ""
"Pour plus d'informations sur les méthodes des descripteurs, consultez :ref:"
"`descriptors`."

#: ../Doc/glossary.rst:269
msgid "dictionary"
msgstr "dictionnaire"

#: ../Doc/glossary.rst:271
msgid ""
"An associative array, where arbitrary keys are mapped to values.  The keys "
"can be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a "
"hash in Perl."
msgstr ""
"Une structure de donnée associant des clefs et des valeurs. Les clefs "
"peuvent être n'importe quel objet comportant les méthodes :meth:`__hash__` "
"et :meth:`__eq__`. Elle s'appelle \"*hash*\" en Perl."

#: ../Doc/glossary.rst:274
msgid "dictionary view"
msgstr "vue de dictionnaire"

#: ../Doc/glossary.rst:276
msgid ""
"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:"
"`dict.items` are called dictionary views. They provide a dynamic view on the "
"dictionary’s entries, which means that when the dictionary changes, the view "
"reflects these changes. To force the dictionary view to become a full list "
"use ``list(dictview)``.  See :ref:`dict-views`."
msgstr ""
"Les objets donnés par les méthodes :meth:`dict.keys`, :meth:`dict.values`, "
"et :meth:`dict.items` sont des vues de dictionnaire. Ce sont des vues, "
"dynamiques, des entrées du dictionnaire, ce qui signifie que lorsque le "
"dictionnaire change, la vue change. Pour transformer une vue en vrai liste, "
"utilisez ``list(dictview)``. Voir :ref:`dict-views`."

#: ../Doc/glossary.rst:282
msgid "docstring"
msgstr "docstring"

#: ../Doc/glossary.rst:284
msgid ""
"A string literal which appears as the first expression in a class, function "
"or module.  While ignored when the suite is executed, it is recognized by "
"the compiler and put into the :attr:`__doc__` attribute of the enclosing "
"class, function or module.  Since it is available via introspection, it is "
"the canonical place for documentation of the object."
msgstr ""
"Une chaîne littérale étant la première expression d'une classe, fonction, ou "
"module. Bien qu'ignoré à l'exécution, elles sont reconnues par le "
"compilateur, et placées dans l'attribut :attr:`__doc__` de sa classe, "
"fonction, ou module respectif. Puisque cette chaîne est disponible par "
"introspection, c'est l'endroit idéal pour documenter l'objet."

#: ../Doc/glossary.rst:290
msgid "duck-typing"
msgstr "duck-typing"

#: ../Doc/glossary.rst:292
msgid ""
"A programming style which does not look at an object's type to determine if "
"it has the right interface; instead, the method or attribute is simply "
"called or used (\"If it looks like a duck and quacks like a duck, it must be "
"a duck.\")  By emphasizing interfaces rather than specific types, well-"
"designed code improves its flexibility by allowing polymorphic "
"substitution.  Duck-typing avoids tests using :func:`type` or :func:"
"`isinstance`.  (Note, however, that duck-typing can be complemented with :"
"term:`abstract base classes <abstract base class>`.)  Instead, it typically "
"employs :func:`hasattr` tests or :term:`EAFP` programming."
msgstr ""
"Un style de programmation qui ne prend pas en compte le type d'un objet pour "
"déterminer s'il respecte une interface, mais qui qui appelle simplement la "
"méthode ou l'attribut (*Si ça a un bec et que ça cancane, c'est un canard*). "
"En se concentrant sur les interfaces plutôt que les types, du code bien "
"construit améliore sa flexibilité en autorisant des substitutions "
"polymorphiques. Un code orienté *duck-typing* évite de vérifier les types "
"via :func:`type` ou :func:`isinstance`, (notez cependant que le duck-typing "
"peut travailler de pair avec les :term:`classes de base abstraites <classe "
"de base abstraite>`.) À la place, le *duck-typing* utilise plutôt :func:"
"`hasattr` ou la programmation :term:`EAFP`."

#: ../Doc/glossary.rst:301
msgid "EAFP"
msgstr "EAFP"

#: ../Doc/glossary.rst:303
msgid ""
"Easier to ask for forgiveness than permission.  This common Python coding "
"style assumes the existence of valid keys or attributes and catches "
"exceptions if the assumption proves false.  This clean and fast style is "
"characterized by the presence of many :keyword:`try` and :keyword:`except` "
"statements.  The technique contrasts with the :term:`LBYL` style common to "
"many other languages such as C."
msgstr ""
"Il est plus simple de demander pardon que demander la permission (*Easier to "
"Ask for Forgiveness than Permission*). Ce style de développement Python fait "
"l'hypothèse que le code est valide, et attrape les exceptions si cette "
"hypothèse s'avèrait fausse. Ce style, propre et efficace, est caractérisé "
"par la présence de beaucoup de mot clé :keyword:`try` et :keyword:`except`. "
"Cette technique de programmation contraste avec le style :term:`LBYL` "
"présent couramment dans des langages tel que C."

#: ../Doc/glossary.rst:309
msgid "expression"
msgstr "expression"

#: ../Doc/glossary.rst:311
msgid ""
"A piece of syntax which can be evaluated to some value.  In other words, an "
"expression is an accumulation of expression elements like literals, names, "
"attribute access, operators or function calls which all return a value.  In "
"contrast to many other languages, not all language constructs are "
"expressions.  There are also :term:`statement`\\s which cannot be used as "
"expressions, such as :keyword:`if`.  Assignments are also statements, not "
"expressions."
msgstr ""
"Une suite logique de termes et chiffres conformes à la syntaxe Python dont "
"l'évaluation fournit une valeur. En d'autres termes, une expression est une "
"suite d'éléments tels que des noms, opérateurs, littéraux, accès "
"d'attributs, méthodes ou fonctions qui aboutissent à une valeur. "
"Contrairement à beaucoup d'autres langages, les différentes constructions du "
"langage ne sont pas toutes des expressions. Il y a également des :term:"
"`instructions <statement>` qui ne peuvent pas être utilisées comme "
"expressions, tel que :keyword:`if`. Les affectations sont également des "
"instructions et non des expressions."

#: ../Doc/glossary.rst:318
msgid "extension module"
msgstr "module d'extension"

#: ../Doc/glossary.rst:320
msgid ""
"A module written in C or C++, using Python's C API to interact with the core "
"and with user code."
msgstr ""
"Un module écrit en C ou C++, utilisant l'API C de Python pour interagir avec "
"Python et le code de l'utilisateur."

#: ../Doc/glossary.rst:322
msgid "f-string"
msgstr "f-string"

#: ../Doc/glossary.rst:324
msgid ""
"String literals prefixed with ``'f'`` or ``'F'`` are commonly called \"f-"
"strings\" which is short for :ref:`formatted string literals <f-strings>`.  "
"See also :pep:`498`."
msgstr ""
"Les chaînes littérales préfixées de  ``'f'`` ou ``'F'`` sont communément "
"appelées \"f-strings\", le raccourci pour :ref:`formatted string literals <f-"
"strings>`.  Voir la :pep:`498`."

#: ../Doc/glossary.rst:327
msgid "file object"
msgstr "objet fichier"

#: ../Doc/glossary.rst:329
msgid ""
"An object exposing a file-oriented API (with methods such as :meth:`read()` "
"or :meth:`write()`) to an underlying resource.  Depending on the way it was "
"created, a file object can mediate access to a real on-disk file or to "
"another type of storage or communication device (for example standard input/"
"output, in-memory buffers, sockets, pipes, etc.).  File objects are also "
"called :dfn:`file-like objects` or :dfn:`streams`."
msgstr ""
"Un objet exposant une ressource via une API orientée fichier (avec les "
"méthodes :meth:`read()` ou :meth:`write()`). En fonction de la manière dont "
"ils ont été créés, les objets fichiers peuvent exposer un fichier sur le "
"disque, ou un autre type de stockage ou de communication (typiquement "
"l'entrée standard, la sortie standard, un tampon en mémoire, des "
"sockets, ...). Les objets fichiers sont aussi appelés :dfn:`file-like-"
"objects` ou :dfn:`streams`."

#: ../Doc/glossary.rst:337
msgid ""
"There are actually three categories of file objects: raw :term:`binary files "
"<binary file>`, buffered :term:`binary files <binary file>` and :term:`text "
"files <text file>`. Their interfaces are defined in the :mod:`io` module.  "
"The canonical way to create a file object is by using the :func:`open` "
"function."
msgstr ""
"Il existe en réalité trois catégories de fichiers objets : les :term:"
"`fichiers binaires <fichier binaire>` bruts, les :term:`fichiers binaire "
"<fichier binaire>` bufferisés, et les :term:`fichiers texte <fichier "
"texte>`. Leurs interfaces sont définies dans le module :mod:`io`. Le moyen "
"le plus simple et direct de créer un objet fichier est d'utiliser la "
"fonction :func:`open`."

#: ../Doc/glossary.rst:342
msgid "file-like object"
msgstr "objet fichier-compatible"

#: ../Doc/glossary.rst:344
msgid "A synonym for :term:`file object`."
msgstr "Un synonyme de :term:`objet fichier`."

#: ../Doc/glossary.rst:345
msgid "finder"
msgstr "finder"

#: ../Doc/glossary.rst:347
msgid ""
"An object that tries to find the :term:`loader` for a module that is being "
"imported."
msgstr ""
"Un objet qui essaye de trouver un :term:`loader` pour le module étant "
"importé."

#: ../Doc/glossary.rst:350
msgid ""
"Since Python 3.3, there are two types of finder: :term:`meta path finders "
"<meta path finder>` for use with :data:`sys.meta_path`, and :term:`path "
"entry finders <path entry finder>` for use with :data:`sys.path_hooks`."
msgstr ""
"Depuis Python 3.3, il existe deux types de *finder*: :term:`meta path "
"finders <meta path finder>` à utiliser avec :data:`sys.meta_path`, et :term:"
"`path entry finders <path entry finder>` à utiliser avec :data:`sys."
"path_hooks`."

#: ../Doc/glossary.rst:354
msgid "See :pep:`302`, :pep:`420` and :pep:`451` for much more detail."
msgstr "Voir :pep:`302`, :pep:`420` et :pep:`451` pour plus de détails."

#: ../Doc/glossary.rst:355
msgid "floor division"
msgstr "division entière"

#: ../Doc/glossary.rst:357
msgid ""
"Mathematical division that rounds down to nearest integer.  The floor "
"division operator is ``//``.  For example, the expression ``11 // 4`` "
"evaluates to ``2`` in contrast to the ``2.75`` returned by float true "
"division.  Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` "
"rounded *downward*. See :pep:`238`."
msgstr ""
"Division mathématique arrondissant à l'entier le plus petit. L'opérateur de "
"la division entière est ``//``. Par exemple l'expression ``11 // 4`` vaut "
"``2``, contrairement à ``11 / 4`` qui vaut ``2.75``. Notez que ``(-11) // "
"4`` vaut ``-3`` car l'arrondi se fait par le bas. Voir la :pep:`328`."

#: ../Doc/glossary.rst:362
msgid "function"
msgstr "fonction"

#: ../Doc/glossary.rst:364
msgid ""
"A series of statements which returns some value to a caller. It can also be "
"passed zero or more :term:`arguments <argument>` which may be used in the "
"execution of the body. See also :term:`parameter`, :term:`method`, and the :"
"ref:`function` section."
msgstr ""
"Une suite d'instructions qui renvoient une valeur à celui qui l'appelle. On "
"peut aussi lui passer des :term:`arguments <argument>` qui pourront être "
"utilisés dans le corps de la fonction. Voir aussi :term:`paramètre`, :term:"
"`méthode`, et :ref:`function`."

#: ../Doc/glossary.rst:368
msgid "function annotation"
msgstr "annotation de fonction"

#: ../Doc/glossary.rst:370
msgid ""
"An arbitrary metadata value associated with a function parameter or return "
"value. Its syntax is explained in section :ref:`function`.  Annotations may "
"be accessed via the :attr:`__annotations__` special attribute of a function "
"object."
msgstr ""
"Une métadonnée quelconque, associée au paramètre d'une fonction ou sa valeur "
"de retour. Sa syntaxe est documentée dans la section :ref:`function`. Les "
"annotations sont accessibles via l'attribut spécial :attr:`__annotations__` "
"d'une fonction."

#: ../Doc/glossary.rst:375
msgid ""
"Python itself does not assign any particular meaning to function "
"annotations. They are intended to be interpreted by third-party libraries or "
"tools.  See :pep:`3107`, which describes some of their potential uses."
msgstr ""
"Python ne prend pas en compte les annotations. Leur but est d'être "
"interprétées par d'autres bibliothèques ou outils. Voir la :pep:`3207`, qui "
"décrit certains usages."

#: ../Doc/glossary.rst:378
msgid "__future__"
msgstr "__future__"

#: ../Doc/glossary.rst:380
msgid ""
"A pseudo-module which programmers can use to enable new language features "
"which are not compatible with the current interpreter."
msgstr ""
"Un pseudo-module que les développeurs peuvent utiliser pour activer de "
"nouvelles fonctionnalités du langage qui ne sont pas compatibles avec "
"l'interpréteur utilisé."

#: ../Doc/glossary.rst:383
msgid ""
"By importing the :mod:`__future__` module and evaluating its variables, you "
"can see when a new feature was first added to the language and when it "
"becomes the default::"
msgstr ""
"En important le module :mod:`__future__` et en affichant ses variables, vous "
"pouvez voir quand une nouvelle fonctionnalité à été rajoutée dans le "
"langage, et quand elle devient le comportement par défaut : ::"

#: ../Doc/glossary.rst:390
msgid "garbage collection"
msgstr "ramasse-miettes"

#: ../Doc/glossary.rst:392
#, fuzzy
msgid ""
"The process of freeing memory when it is not used anymore.  Python performs "
"garbage collection via reference counting and a cyclic garbage collector "
"that is able to detect and break reference cycles.  The garbage collector "
"can be controlled using the :mod:`gc` module."
msgstr ""
"(*garbage collection*) Le mécanisme permettant de libérer de la mémoire "
"lorsqu'elle n'est plus utilisée. Python utilise un ramasse-miettes par "
"comptage de référence, et un ramasse-miettes cyclique capable de détecter et "
"casser les références circulaires."

#: ../Doc/glossary.rst:398
msgid "generator"
msgstr "générateur"

#: ../Doc/glossary.rst:400
msgid ""
"A function which returns a :term:`generator iterator`.  It looks like a "
"normal function except that it contains :keyword:`yield` expressions for "
"producing a series of values usable in a for-loop or that can be retrieved "
"one at a time with the :func:`next` function."
msgstr ""
"Une fonction qui renvoie un :term:`itérateur de générateur`. Cela ressemble "
"à une fonction normale, en dehors du fait qu'elle contient une ou des "
"expressions :keyword:`yield` pruduisant une série de valeurs utilisable dans "
"une boucle *for*, ou récupérées une à une via la fonction :func:`next`."

#: ../Doc/glossary.rst:405
msgid ""
"Usually refers to a generator function, but may refer to a *generator "
"iterator* in some contexts.  In cases where the intended meaning isn't "
"clear, using the full terms avoids ambiguity."
msgstr ""
"Fait généralement allusion à une fonction générateur, mais peut faire "
"allusion à un *itérateur de générateur* dans certains contextes. Dans les "
"cas où le sens voulu n'est pas clair, utiliser les termes complets évite "
"l'ambiguité."

#: ../Doc/glossary.rst:408
msgid "generator iterator"
msgstr "itérateur de générateur"

#: ../Doc/glossary.rst:410
msgid "An object created by a :term:`generator` function."
msgstr "Un objet crée par une fonction :term:`générateur`."

#: ../Doc/glossary.rst:412
msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"location execution state (including local variables and pending try-"
"statements).  When the *generator iterator* resumes, it picks-up where it "
"left-off (in contrast to functions which start fresh on every invocation)."
msgstr ""
"Chaque :keyword:`yield` suspend temporairement l'exécution, se rappelant de "
"l'endroit et de l'état de l'exécution (incluant les variables locales et les "
"*try* en cours). Lorsque l'itérateur de générateur reprend, il reprend où il "
"en était (contrairement à une fonction qui prendrait un nouveau départ à "
"chaque invocation)."

#: ../Doc/glossary.rst:419
msgid "generator expression"
msgstr "expression génératrice"

#: ../Doc/glossary.rst:421
msgid ""
"An expression that returns an iterator.  It looks like a normal expression "
"followed by a :keyword:`for` expression defining a loop variable, range, and "
"an optional :keyword:`if` expression.  The combined expression generates "
"values for an enclosing function::"
msgstr ""
"Une expression qui donne un itérateur. Cela ressemble à une expression "
"normale, suivie d'une expression :keyword:`for` définissant une variable de "
"boucle, d'un range, et d'une expression, optionnelle, :keyword:`if`. Cette "
"expression combinée génère des valeurs pour la fonction qui l'entoure : ::"

#: ../Doc/glossary.rst:428
msgid "generic function"
msgstr "fonction générique"

#: ../Doc/glossary.rst:430
msgid ""
"A function composed of multiple functions implementing the same operation "
"for different types. Which implementation should be used during a call is "
"determined by the dispatch algorithm."
msgstr ""
"Une fonction composée de plusieurs fonctions implémentant les mêmes "
"opérations pour différents types. L'implémentation à utiliser est déterminé "
"lors de l'appel est déterminée par un algorithme de répartition."

#: ../Doc/glossary.rst:434
msgid ""
"See also the :term:`single dispatch` glossary entry, the :func:`functools."
"singledispatch` decorator, and :pep:`443`."
msgstr ""
"Voir aussi :term:`single dispatch`, le décorateur :func:`functools."
"singledispatch`, et la :pep:`443`."

#: ../Doc/glossary.rst:437
msgid "GIL"
msgstr "GIL"

#: ../Doc/glossary.rst:439
msgid "See :term:`global interpreter lock`."
msgstr "Voir :term:`global interpreter lock`."

#: ../Doc/glossary.rst:440
msgid "global interpreter lock"
msgstr "verrou global de l'interpréteur"

#: ../Doc/glossary.rst:442
msgid ""
"The mechanism used by the :term:`CPython` interpreter to assure that only "
"one thread executes Python :term:`bytecode` at a time. This simplifies the "
"CPython implementation by making the object model (including critical built-"
"in types such as :class:`dict`) implicitly safe against concurrent access.  "
"Locking the entire interpreter makes it easier for the interpreter to be "
"multi-threaded, at the expense of much of the parallelism afforded by multi-"
"processor machines."
msgstr ""
"Le mécanisme utilisé par l'interpréteur :term:`CPython` pour s'assurer qu'un "
"seul fil d'exécution n'execute du :term:`bytecode` à la fois. Cela simplifie "
"l'implémentation de CPython en rendant le modèle objet (incluant des parties "
"critiques comme la classe native :class:`dict`) implicitement protégé des "
"accès concourants. Vérouiller l'interpréteur entier le rend plus facile à "
"rendre multi-thread, en perdant malheureusement la majorité du parallélisme "
"possible sur les machines ayant plusieurs processeurs."

#: ../Doc/glossary.rst:451
msgid ""
"However, some extension modules, either standard or third-party, are "
"designed so as to release the GIL when doing computationally-intensive tasks "
"such as compression or hashing.  Also, the GIL is always released when doing "
"I/O."
msgstr ""
"Cependant, certains modules d'extension, standards ou non, sont construits "
"de manière à libérer le GIL lorsqu'ils effectuent des tâches lourdes tel que "
"la compression ou le hachage. Aussi, le GIL est toujours libéré lors des "
"lectures et écritures."

#: ../Doc/glossary.rst:456
msgid ""
"Past efforts to create a \"free-threaded\" interpreter (one which locks "
"shared data at a much finer granularity) have not been successful because "
"performance suffered in the common single-processor case. It is believed "
"that overcoming this performance issue would make the implementation much "
"more complicated and therefore costlier to maintain."
msgstr ""
"Les tentatives précédentes d'implémenter un interpréteur Python avec une "
"granularité de verrouillage plus fine ont toutes échouées, à cause de leur "
"performances sur un seul processeur. Il est admis que corriger c'est "
"problèmes de performance induits mènerai vers une implémentation compliquée "
"et donc plus coûteuse à maintenir."

#: ../Doc/glossary.rst:461
msgid "hashable"
msgstr "hachable"

#: ../Doc/glossary.rst:463
msgid ""
"An object is *hashable* if it has a hash value which never changes during "
"its lifetime (it needs a :meth:`__hash__` method), and can be compared to "
"other objects (it needs an :meth:`__eq__` method).  Hashable objects which "
"compare equal must have the same hash value."
msgstr ""
"Un objet est *hachable* s'il a une empreinte (*hash*) qui ne change jamais. "
"(et il a besoin d'une méthode :meth:`__hash__`) et peut être comparé à "
"d'autres objets (avec la méthode :meth:`__eq__`). Les objets hachables dont "
"``__eq__`` dit être équivalents, ont aussi la même empreinte."

#: ../Doc/glossary.rst:468
msgid ""
"Hashability makes an object usable as a dictionary key and a set member, "
"because these data structures use the hash value internally."
msgstr ""
"La hachabilité permet à un objet d'être utilisé comme clef de dictionnaire, "
"ou en temps que membre d'un *set*, car ces structures de données utilisent "
"ce *hash*."

#: ../Doc/glossary.rst:471
msgid ""
"All of Python's immutable built-in objects are hashable; mutable containers "
"(such as lists or dictionaries) are not.  Objects which are instances of "
"user-defined classes are hashable by default.  They all compare unequal "
"(except with themselves), and their hash value is derived from their :func:"
"`id`."
msgstr ""
"Tous les types immuables natifs de Python sont hachables, mais les "
"conteneurs muables (comme les listes ou les dictionnaires) ne le sont pas.  "
"Toutes les instances de classes définies par les utilisateurs sont hachables "
"par défaut.  Elles sont toutes considérées différentes (sauf avec elles-"
"mêmes), et leur clef de hachage est tiré de leur :func:`id`."

#: ../Doc/glossary.rst:476
msgid "IDLE"
msgstr "IDLE"

#: ../Doc/glossary.rst:478
msgid ""
"An Integrated Development Environment for Python.  IDLE is a basic editor "
"and interpreter environment which ships with the standard distribution of "
"Python."
msgstr ""
"Un environnement de développement intégré pour Python. IDLE est un éditeur "
"et interpréteur basique livré avec la distribution standard de Python."

#: ../Doc/glossary.rst:481
msgid "immutable"
msgstr "immuable"

#: ../Doc/glossary.rst:483
msgid ""
"An object with a fixed value.  Immutable objects include numbers, strings "
"and tuples.  Such an object cannot be altered.  A new object has to be "
"created if a different value has to be stored.  They play an important role "
"in places where a constant hash value is needed, for example as a key in a "
"dictionary."
msgstr ""
"Un objet dont la valeur ne change pas. Les nombres, les chaînes et les "
"tuples sont immuables. Ils ne peuvent être modifiés. Un nouvel objet doit "
"être créé si une valeur différente doit être stockée. Ils jouent un rôle "
"important aux endroits où une valeur de *hash* constante est requise, "
"typiquement en clef de dictionnaire."

#: ../Doc/glossary.rst:488
msgid "import path"
msgstr "chemin d'import"

#: ../Doc/glossary.rst:490
msgid ""
"A list of locations (or :term:`path entries <path entry>`) that are searched "
"by the :term:`path based finder` for modules to import. During import, this "
"list of locations usually comes from :data:`sys.path`, but for subpackages "
"it may also come from the parent package's ``__path__`` attribute."
msgstr ""
"Une liste de :term:`chemins <chemin>` dans lesquels le :term:`path based "
"finder` cherche les modules à importer. Typiquement lors d'un import cette "
"liste vient de :data:`sys.path`, mais pour les sous paquets, elle peut aussi "
"venir de l'attribut ``__path__`` du paquet parent."

#: ../Doc/glossary.rst:495
msgid "importing"
msgstr "importer"

#: ../Doc/glossary.rst:497
msgid ""
"The process by which Python code in one module is made available to Python "
"code in another module."
msgstr "Le processus rendant le code d'un module disponible dans un autre."

#: ../Doc/glossary.rst:499
msgid "importer"
msgstr "importateur"

#: ../Doc/glossary.rst:501
msgid ""
"An object that both finds and loads a module; both a :term:`finder` and :"
"term:`loader` object."
msgstr ""
"Un objet qui trouve et charge un module, en même temps un :term:`finder` et "
"un :term:`loader`."

#: ../Doc/glossary.rst:503
msgid "interactive"
msgstr "interactif"

#: ../Doc/glossary.rst:505
msgid ""
"Python has an interactive interpreter which means you can enter statements "
"and expressions at the interpreter prompt, immediately execute them and see "
"their results.  Just launch ``python`` with no arguments (possibly by "
"selecting it from your computer's main menu). It is a very powerful way to "
"test out new ideas or inspect modules and packages (remember ``help(x)``)."
msgstr ""
"Python a un interpréteur interactif, ce qui signifie que vous pouvez écrire "
"des expressions et instructions à l'invite de l'interpréteur, qui va les "
"exécuter immédiatement, et vous en présenter le résultat. Démarrez juste "
"``python`` (probablement depuis un menu de votre ordinateur). C'est un moyen "
"puissant pour tester de nouvelles idées ou étudier de nouveaux modules "
"(souvenez vous de ``help(x)``)."

#: ../Doc/glossary.rst:511
msgid "interpreted"
msgstr "interprété"

#: ../Doc/glossary.rst:513
msgid ""
"Python is an interpreted language, as opposed to a compiled one, though the "
"distinction can be blurry because of the presence of the bytecode compiler.  "
"This means that source files can be run directly without explicitly creating "
"an executable which is then run. Interpreted languages typically have a "
"shorter development/debug cycle than compiled ones, though their programs "
"generally also run more slowly.  See also :term:`interactive`."
msgstr ""
"Python est un langage interprété, en opposition aux langages compilés, bien "
"que la frontière soit floue du à la présence d'un compilateur en bytecode. "
"Cela signifie que les fichiers sources peuvent être exécutés directement, "
"sans avoir à compiler un fichier exécutable intermédiaire. Les langages "
"interprétées ont généralement un cycle de développement / débug plus rapide, "
"et ils s'exécutent généralement plus lentement. Voir aussi :term:"
"`interactif`."

#: ../Doc/glossary.rst:520
msgid "interpreter shutdown"
msgstr "arrêt de l'interpréteur"

#: ../Doc/glossary.rst:522
msgid ""
"When asked to shut down, the Python interpreter enters a special phase where "
"it gradually releases all allocated resources, such as modules and various "
"critical internal structures.  It also makes several calls to the :term:"
"`garbage collector <garbage collection>`. This can trigger the execution of "
"code in user-defined destructors or weakref callbacks. Code executed during "
"the shutdown phase can encounter various exceptions as the resources it "
"relies on may not function anymore (common examples are library modules or "
"the warnings machinery)."
msgstr ""
"Lorsqu'on lui demande de s'arrêter, l'interpréteur Python entre dans une "
"phase spéciale où il libère graduellement les ressources allouées, comme les "
"modules ou quelques structures de données internes. Il fait aussi quelques "
"appels au :term:`ramasse-miettes`. Cela peut déclencher l'exécution de code "
"dans des destructeurs ou des fonctions de rappels de *weakrefs*. Le code "
"exécuté lors de l'arrêt peut rencontrer quelques exception puisque les "
"ressources sur lesquels il pourrait s'appuyer pourraient ne plus "
"fonctionner, (typiquement les modules de la bibliothèque ou le mécanisme de "
"*warning*)."

#: ../Doc/glossary.rst:531
msgid ""
"The main reason for interpreter shutdown is that the ``__main__`` module or "
"the script being run has finished executing."
msgstr ""
"La principale raison qu'a l'interpréteur de s'arrêter est lorsque le module "
"``__main__`` ou le script en cours d'exécution à terminé de s'exécuter."

#: ../Doc/glossary.rst:533
msgid "iterable"
msgstr "itérable"

#: ../Doc/glossary.rst:535
msgid ""
"An object capable of returning its members one at a time. Examples of "
"iterables include all sequence types (such as :class:`list`, :class:`str`, "
"and :class:`tuple`) and some non-sequence types like :class:`dict`, :term:"
"`file objects <file object>`, and objects of any classes you define with an :"
"meth:`__iter__` method or with a :meth:`__getitem__` method that implements :"
"term:`Sequence` semantics."
msgstr ""
"Un objet capable de renvoyer ses éléments un à un. Pour lister quelques "
"exemples d'itérables, on pourrait lister tout les types séquence (comme :"
"class:`list`, :class:`str`, et :class:`tuple`), et quelques autres comme :"
"class:`dict`, :term:`objets fichiers <objet fichier>`, ou tout objet de "
"toute classe ayant une méthode :meth:`__iter__` ou :meth:`__getitem__` "
"implémentant la sémantique des :term:`Sequence`."

#: ../Doc/glossary.rst:542
msgid ""
"Iterables can be used in a :keyword:`for` loop and in many other places "
"where a sequence is needed (:func:`zip`, :func:`map`, ...).  When an "
"iterable object is passed as an argument to the built-in function :func:"
"`iter`, it returns an iterator for the object.  This iterator is good for "
"one pass over the set of values.  When using iterables, it is usually not "
"necessary to call :func:`iter` or deal with iterator objects yourself.  The "
"``for`` statement does that automatically for you, creating a temporary "
"unnamed variable to hold the iterator for the duration of the loop.  See "
"also :term:`iterator`, :term:`sequence`, and :term:`generator`."
msgstr ""
"Les itérables peuvent être utilisés dans des boucles :keyword:`for` ou tout "
"autre endroit où une séquence est requise (:func:`zip`, :func:`map`, ...). "
"Lorsqu'un itérable est passé comme argument à la fonction native :func:"
"`iter`, elle donnera un itérateur de cet itérable. Cet itérateur n'est "
"valable que pour une passe sur le jeu de valeurs. Lors de l'utilisation "
"d'itérables, il n'est habituellement pas nécessaire d'appeler :func:`iter` "
"ou de s'occuper d'objet itérateurs. L'instruction ``for`` fait ça "
"automatiquement pour vous, créant une variable temporaire anonyme pour "
"garder l'itérateur durant la boucle. Voir aussi :term:`itérateur`, :term:"
"`séquence`, et :term:`générateur`."

#: ../Doc/glossary.rst:552
msgid "iterator"
msgstr "itérateur"

#: ../Doc/glossary.rst:554
msgid ""
"An object representing a stream of data.  Repeated calls to the iterator's :"
"meth:`~iterator.__next__` method (or passing it to the built-in function :"
"func:`next`) return successive items in the stream.  When no more data are "
"available a :exc:`StopIteration` exception is raised instead.  At this "
"point, the iterator object is exhausted and any further calls to its :meth:"
"`__next__` method just raise :exc:`StopIteration` again.  Iterators are "
"required to have an :meth:`__iter__` method that returns the iterator object "
"itself so every iterator is also iterable and may be used in most places "
"where other iterables are accepted.  One notable exception is code which "
"attempts multiple iteration passes.  A container object (such as a :class:"
"`list`) produces a fresh new iterator each time you pass it to the :func:"
"`iter` function or use it in a :keyword:`for` loop.  Attempting this with an "
"iterator will just return the same exhausted iterator object used in the "
"previous iteration pass, making it appear like an empty container."
msgstr ""
"Un objet représentant un flux de donnée. Des appels successifs à la méthode :"
"meth:`~iterator.__next__` de l'itérateur (ou le donner à la fonction native :"
"func:`next`) donne successivement les objets du flux. Lorsque plus aucune "
"donnée n'est disponible, une exception :exc:`StopIteration` est lancée. À ce "
"point, l'itérateur est épuisé et tous les appels suivants à sa méthode :meth:"
"`__next__` lanceront encore une exception :exc:`StopIteration`. Les "
"itérateurs doivent avoir une méthode :meth:`__iter__` qui renvoie l'objet "
"itérateur lui même, tel que chaque itérateur soit aussi itérable et puisse "
"être utilisé dans la plupart des endroits où d'autres itérables sont "
"attendus. Une exception notable serait un code qui tenterai plusieurs "
"itérations complètes. Un objet conteneur, (tel que :class:`list`) produit un "
"nouvel itérateur neuf à chaque fois qu'il est donné à la fonction :func:"
"`iter` où qu'il est utilisé dans une boucle :keyword:`for`. Faire ceci sur "
"un itérateur donnerai simplement le même objet itérateur épuisé utilisé dans "
"son itération précédente, le faisant ressembler à un conteneur vide."

#: ../Doc/glossary.rst:569
msgid "More information can be found in :ref:`typeiter`."
msgstr "Plus d'informations ici : :ref:`typeiter`."

#: ../Doc/glossary.rst:570
msgid "key function"
msgstr "fonction clef"

#: ../Doc/glossary.rst:572
msgid ""
"A key function or collation function is a callable that returns a value used "
"for sorting or ordering.  For example, :func:`locale.strxfrm` is used to "
"produce a sort key that is aware of locale specific sort conventions."
msgstr ""
"Une fonction clef, est un objet appelable qui renvoie une valeur utilisée "
"pour trier ou organiser. Par exemple la fonction :func:`local.strxfrm` sert "
"à produire une fonction clef de tri prennant en compte les conventions de "
"tri spécifiques aux paramètres régionaux courants."

#: ../Doc/glossary.rst:577
msgid ""
"A number of tools in Python accept key functions to control how elements are "
"ordered or grouped.  They include :func:`min`, :func:`max`, :func:`sorted`, :"
"meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq."
"nlargest`, and :func:`itertools.groupby`."
msgstr ""
"Plusieurs outils dans Python acceptent des fonctions clef pour maîtriser "
"comment les éléments dont triés ou groupés. Typiquement les fonctions :func:"
"`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq.merge`, :"
"func:`heapq.nsmallest`, :func:`heapq.nlargest`, et :func:`itertools.groupby`."

#: ../Doc/glossary.rst:583
msgid ""
"There are several ways to create a key function.  For example. the :meth:"
"`str.lower` method can serve as a key function for case insensitive sorts.  "
"Alternatively, a key function can be built from a :keyword:`lambda` "
"expression such as ``lambda r: (r[0], r[2])``.  Also, the :mod:`operator` "
"module provides three key function constructors: :func:`~operator."
"attrgetter`, :func:`~operator.itemgetter`, and :func:`~operator."
"methodcaller`.  See the :ref:`Sorting HOW TO <sortinghowto>` for examples of "
"how to create and use key functions."
msgstr ""
"Il existe plusieurs moyens de créer une fonction clef. Par exemple, la "
"méthode :meth:`str.lower` peut servir en fonction clef pour effectuer des "
"recherches insensibles à la casse. Aussi, il est possible de créer des "
"fonctions clef avec des expressions :keyword:`lambda`, comme ``lambda r: "
"(r[0], r[2])``. Finalement le module :mod:`operator` fournit des "
"constructeurs de fonctions clef : :func:`~operator.attrgetter`, :func:"
"`~operator.itemgetter`, et :func:`~operator.methodcaller`. Voir :ref:"
"`Comment Trier <sortinghowto>` pour avoir des exemple de création et "
"d'utilisation de fonctions clés."

#: ../Doc/glossary.rst:591
msgid "keyword argument"
msgstr "argument nommé"

#: ../Doc/glossary.rst:593 ../Doc/glossary.rst:837
msgid "See :term:`argument`."
msgstr "Voir :term:`argument`."

#: ../Doc/glossary.rst:594
msgid "lambda"
msgstr "lambda"

#: ../Doc/glossary.rst:596
msgid ""
"An anonymous inline function consisting of a single :term:`expression` which "
"is evaluated when the function is called.  The syntax to create a lambda "
"function is ``lambda [arguments]: expression``"
msgstr ""
"Une fonction anonyme sous forme d'une :term:`expression`, et ne contenant "
"qu'une expression, exécutée lorsqu'elle est appelée. La syntaxe pour créer "
"des fonctions lambda est: ``lambda [arguments]: expression``"

#: ../Doc/glossary.rst:599
msgid "LBYL"
msgstr "LBYL"

#: ../Doc/glossary.rst:601
msgid ""
"Look before you leap.  This coding style explicitly tests for pre-conditions "
"before making calls or lookups.  This style contrasts with the :term:`EAFP` "
"approach and is characterized by the presence of many :keyword:`if` "
"statements."
msgstr ""
"Regarde devant avant de tomber, (*Look before you leap*). Ce style de "
"programmation consiste à vérifier des conditions avant d'effectuer des "
"appels ou des accès. Ce style contraste avec le style :term:`EAFP` et se "
"caractérise par la présence de beaucoup d'instructions :keyword:`if`."

#: ../Doc/glossary.rst:606
msgid ""
"In a multi-threaded environment, the LBYL approach can risk introducing a "
"race condition between \"the looking\" and \"the leaping\".  For example, "
"the code, ``if key in mapping: return mapping[key]`` can fail if another "
"thread removes *key* from *mapping* after the test, but before the lookup. "
"This issue can be solved with locks or by using the EAFP approach."
msgstr ""
"Dans un environnement multi-thread, le style *LBYL* peut engendrer une "
"séquence critique (*race condition*) entre \"regarder\" et \"tomber\". Par "
"exemple, le code ``if key in mapping: return mapping[key]`` peut échouer si "
"un autre fil d'exécution supprime la clef *key* du *mapping* après le test "
"mais avant l'accès. Ce problème peut être résolu avec des verrous (*locks*) "
"ou avec l'approche EAFP."

#: ../Doc/glossary.rst:611
msgid "list"
msgstr "*list*"

#: ../Doc/glossary.rst:613
msgid ""
"A built-in Python :term:`sequence`.  Despite its name it is more akin to an "
"array in other languages than to a linked list since access to elements are "
"O(1)."
msgstr ""
"Un type natif de :term:`sequence` dans Python. En dépit de son nom, une "
"``list`` ressemble plus à un *array* qu'à une liste chaînée puisque les "
"accès se font en O(1)."

#: ../Doc/glossary.rst:616
msgid "list comprehension"
msgstr "liste en compréhension"

#: ../Doc/glossary.rst:618
msgid ""
"A compact way to process all or part of the elements in a sequence and "
"return a list with the results.  ``result = ['{:#04x}'.format(x) for x in "
"range(256) if x % 2 == 0]`` generates a list of strings containing even hex "
"numbers (0x..) in the range from 0 to 255. The :keyword:`if` clause is "
"optional.  If omitted, all elements in ``range(256)`` are processed."
msgstr ""
"Un moyen compacte de manipuler tous ou partie des éléments d'une séquence "
"renvoyant une liste avec les résultats. ``result = ['{:#04x}'.format(x) for "
"x in range(256) if x % 2 == 0]`` génère une liste de chaînes de caractères "
"contenant les nombres paires sous forme hexadécimale (0x...) de 0 à 255. La "
"clause :keyword:`if` est optionnelle. Si elle est omise, tous les éléments "
"du ``range(256)`` seront utilisés."

#: ../Doc/glossary.rst:624
msgid "loader"
msgstr "loader"

#: ../Doc/glossary.rst:626
msgid ""
"An object that loads a module. It must define a method named :meth:"
"`load_module`. A loader is typically returned by a :term:`finder`. See :pep:"
"`302` for details and :class:`importlib.abc.Loader` for an :term:`abstract "
"base class`."
msgstr ""
"Un objet qui charge un module. Il doit définir une méthode nommée :meth:"
"`load_module`. Un *loader* est typiquement donné par un :term:`finder`. "
"Voir :pep:`302` pour les détails et :class:`importlib.ABC.Loader` pour sa :"
"term:`classe de base abstraite`."

#: ../Doc/glossary.rst:630
msgid "mapping"
msgstr "mapping"

#: ../Doc/glossary.rst:632
msgid ""
"A container object that supports arbitrary key lookups and implements the "
"methods specified in the :class:`~collections.abc.Mapping` or :class:"
"`~collections.abc.MutableMapping` :ref:`abstract base classes <collections-"
"abstract-base-classes>`.  Examples include :class:`dict`, :class:"
"`collections.defaultdict`, :class:`collections.OrderedDict` and :class:"
"`collections.Counter`."
msgstr ""
"Un conteneur acceptant de rechercher des éléments par clef et implémente les "
"méthodes des :ref:`classes de base abstraites <collections-abstract-base-"
"classes>` :class:`collections.abc.Mapping` ou :class:`collections.abc."
"MutableMapping`. Les classes suivantes sont des exemples de mapping: :class:"
"`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict`, "
"et :class:`collections.Counter`."

#: ../Doc/glossary.rst:638
msgid "meta path finder"
msgstr "meta path finder"

#: ../Doc/glossary.rst:640
msgid ""
"A :term:`finder` returned by a search of :data:`sys.meta_path`.  Meta path "
"finders are related to, but different from :term:`path entry finders <path "
"entry finder>`."
msgstr ""
"Un :term:`finder` donné par une recherche dans :data:`sys.meta_path`. Les "
"*meta path finders* ressemblent, mais sont différents de :term:`path entry "
"finders <path entry finder>`."

#: ../Doc/glossary.rst:644
msgid ""
"See :class:`importlib.abc.MetaPathFinder` for the methods that meta path "
"finders implement."
msgstr ""
"Voir :class:`importlib.abc.MetaPathFinder` pour les méthodes que les *meta "
"path finders* doivent implémenter."

#: ../Doc/glossary.rst:646
msgid "metaclass"
msgstr "metaclasse"

#: ../Doc/glossary.rst:648
msgid ""
"The class of a class.  Class definitions create a class name, a class "
"dictionary, and a list of base classes.  The metaclass is responsible for "
"taking those three arguments and creating the class.  Most object oriented "
"programming languages provide a default implementation.  What makes Python "
"special is that it is possible to create custom metaclasses.  Most users "
"never need this tool, but when the need arises, metaclasses can provide "
"powerful, elegant solutions.  They have been used for logging attribute "
"access, adding thread-safety, tracking object creation, implementing "
"singletons, and many other tasks."
msgstr ""
"La classe d'une classe. Les définitions de classe créent un nom pour la "
"classe, un dictionnaire et une liste de classes patentes. La métaclasse a "
"pour rôle de réunir ces trois paramètres pour construire la classe. La "
"plupart des langages orientés objet fournissent une implémentation par "
"défaut. Ce qui rend Python spécial, c'est de proposer de créer des "
"métaclasses personnalisées. La plupart des utilisateurs n'ont pas besoin de "
"cet outil, mais lorsque le besoin survient, les métaclasses sont souvent des "
"solutions élégantes, puissantes, et utiles. Elles ont été utilisées pour "
"journaliser les accès à des propriétés, rendre un objet sûr pour une "
"utilisation en environnement multi-thread, suivre la création d'objets, "
"implémenter des singleton, et bien d'autres tâches."

#: ../Doc/glossary.rst:658
msgid "More information can be found in :ref:`metaclasses`."
msgstr "Plus d'informations à ce sujet : :ref:`metaclasses`."

#: ../Doc/glossary.rst:659
msgid "method"
msgstr "méthode"

#: ../Doc/glossary.rst:661
msgid ""
"A function which is defined inside a class body.  If called as an attribute "
"of an instance of that class, the method will get the instance object as its "
"first :term:`argument` (which is usually called ``self``). See :term:"
"`function` and :term:`nested scope`."
msgstr ""
"Une fonction définie dans une classe. Lorsqu'elle est appelée comme un "
"attribut d'une instance, la méthode reçoit l'instance en premier :term:"
"`argument` (qui par convention est nommé ``self``). Voir :term:`function` "
"et :term:`nested scope`."

#: ../Doc/glossary.rst:665
msgid "method resolution order"
msgstr "ordre de résolution des méthodes"

#: ../Doc/glossary.rst:667
msgid ""
"Method Resolution Order is the order in which base classes are searched for "
"a member during lookup. See `The Python 2.3 Method Resolution Order <https://"
"www.python.org/download/releases/2.3/mro/>`_ for details of the algorithm "
"used by the Python interpreter since the 2.3 release."
msgstr ""
"L'ordre de résolution des méthodes (*MRO* de *Method Resolution Order*) est "
"l'ordre par lequel les membres sont recherchées dans les classes parentes. "
"Voir `The Python 2.3 Method Resolution Order <https://www.python.org/"
"download/releases/2.3/mro/>`_ pour plus de détails sur l'algorithme utilisé "
"par l'interpréteur Python depuis la version 2.3."

#: ../Doc/glossary.rst:671
msgid "module"
msgstr "module"

#: ../Doc/glossary.rst:673
msgid ""
"An object that serves as an organizational unit of Python code.  Modules "
"have a namespace containing arbitrary Python objects.  Modules are loaded "
"into Python by the process of :term:`importing`."
msgstr ""
"L'unité élémentaire de l'organisation du code en Python. Les modules ont un "
"espace de noms pouvant contenir n'importe quel objet Python. Charger des "
"modules est appelé :term:`importer`."

#: ../Doc/glossary.rst:677
msgid "See also :term:`package`."
msgstr "Voir aussi :term:`paquet`."

#: ../Doc/glossary.rst:678
msgid "module spec"
msgstr "module spec"

#: ../Doc/glossary.rst:680
msgid ""
"A namespace containing the import-related information used to load a module. "
"An instance of :class:`importlib.machinery.ModuleSpec`."
msgstr ""
"Un espace de nom contenant les informations, relatives à l'import, utilisés "
"pour charger un module. C'est une instance de la classe :class:`importlib."
"machinery.ModuleSpec`."

#: ../Doc/glossary.rst:682
msgid "MRO"
msgstr "MRO"

#: ../Doc/glossary.rst:684
msgid "See :term:`method resolution order`."
msgstr "Voir :term:`ordre de résolution des méthodes`."

#: ../Doc/glossary.rst:685
msgid "mutable"
msgstr "muable"

#: ../Doc/glossary.rst:687
msgid ""
"Mutable objects can change their value but keep their :func:`id`.  See also :"
"term:`immutable`."
msgstr ""
"Un objet muable peut changer de valeur tout en gardant le même :func:`id`. "
"Voir aussi :term:`immuable`."

#: ../Doc/glossary.rst:689
msgid "named tuple"
msgstr "named tuple"

#: ../Doc/glossary.rst:691
msgid ""
"Any tuple-like class whose indexable elements are also accessible using "
"named attributes (for example, :func:`time.localtime` returns a tuple-like "
"object where the *year* is accessible either with an index such as ``t[0]`` "
"or with a named attribute like ``t.tm_year``)."
msgstr ""
"Une classe qui, comme *tuple* a ses éléments accessibles par leur indice, "
"mais en plus accessibles par leur nom (par exemple, :func:`time.localtime` "
"donne un objet ressemblant à un *tuple*, dont *year* est accessible par son "
"indice : ``t[0]`` ou par son nom : ``t.tm_year``)."

#: ../Doc/glossary.rst:696
msgid ""
"A named tuple can be a built-in type such as :class:`time.struct_time`, or "
"it can be created with a regular class definition.  A full featured named "
"tuple can also be created with the factory function :func:`collections."
"namedtuple`.  The latter approach automatically provides extra features such "
"as a self-documenting representation like ``Employee(name='jones', "
"title='programmer')``."
msgstr ""
"Un *named tuple* peut être un type natif tel que :class:`time.struct_time` "
"ou il peut être construit comme une simple classe. Un *named tuple* complet "
"peut aussi être créé via la fonction :func:`collections.namedtuple`. Cette "
"dernière approche fournit automatiquement des fonctionnalités "
"supplémentaires, tel qu'une représentation lisible comme "
"``Employee(name='jones', title='programmer')``."

#: ../Doc/glossary.rst:702
msgid "namespace"
msgstr "espace de nom"

#: ../Doc/glossary.rst:704
msgid ""
"The place where a variable is stored.  Namespaces are implemented as "
"dictionaries.  There are the local, global and built-in namespaces as well "
"as nested namespaces in objects (in methods).  Namespaces support modularity "
"by preventing naming conflicts.  For instance, the functions :func:`builtins."
"open <.open>` and :func:`os.open` are distinguished by their namespaces.  "
"Namespaces also aid readability and maintainability by making it clear which "
"module implements a function.  For instance, writing :func:`random.seed` or :"
"func:`itertools.islice` makes it clear that those functions are implemented "
"by the :mod:`random` and :mod:`itertools` modules, respectively."
msgstr ""
"L'endroit où une variable est stockée. Les espaces de noms sont en fait des "
"dictionnaires. Il existe des espaces de noms globaux, natifs, ou imbriqués "
"dans les objets (dans les méthodes). Les espaces de noms sont modulaires "
"afin d'éviter les conflits de noms. Par exemple, les fonctions :func:"
"`builtins.open <.open>` et :func:`os.open` sont différenciées par leurs "
"espaces de nom. Les espaces de noms aident aussi à la lisibilité et "
"maintenabilité en rendant clair quel module implémente une fonction. Par "
"exemple, écrire :func:`random.seed` ou :func:`itertools.islice` rend clair "
"que ces fonctions sont implémentées respectivement dans les modules :mod:"
"`random` et :mod:`itertools`."

#: ../Doc/glossary.rst:714
msgid "namespace package"
msgstr "paquet espace de nom"

#: ../Doc/glossary.rst:716
msgid ""
"A :pep:`420` :term:`package` which serves only as a container for "
"subpackages.  Namespace packages may have no physical representation, and "
"specifically are not like a :term:`regular package` because they have no "
"``__init__.py`` file."
msgstr ""
"Un :term:`paquet` tel que défini dans la :pep:`421` qui ne sert qu'à "
"contenir des sous paquets. Les paquets-espace de nom peuvent n'avoir aucune "
"représentation physique, et plus spécifiquement ne sont pas comme un :term:"
"`paquet classique` puisqu'ils n'ont pas de fichier ``__init__.py``."

#: ../Doc/glossary.rst:721
msgid "See also :term:`module`."
msgstr "Voir aussi :term:`module`."

#: ../Doc/glossary.rst:722
msgid "nested scope"
msgstr "portée imbriquée"

#: ../Doc/glossary.rst:724
msgid ""
"The ability to refer to a variable in an enclosing definition.  For "
"instance, a function defined inside another function can refer to variables "
"in the outer function.  Note that nested scopes by default work only for "
"reference and not for assignment.  Local variables both read and write in "
"the innermost scope.  Likewise, global variables read and write to the "
"global namespace.  The :keyword:`nonlocal` allows writing to outer scopes."
msgstr ""
"La possibilité de toucher une variable déclarée dans une définition "
"englobante. Typiquement, une fonction définie à l'intérieur d'une autre "
"fonction aura accès aux variables de cette autre fonction. Souvenez-vous "
"cependant que cela ne fonctionne que pour accéder à des variables, pas pour "
"les assigner. Les variables locales sont lues et assignées dans l'espace de "
"nom le plus proche. Tout comme les variables globales qui sont stockés sur "
"l'espace de noms global, le mot clef :keyword:`nonlocal` permet d'écrire "
"dans l'espace de nom dans lequel est déclaré la variable."

#: ../Doc/glossary.rst:731
msgid "new-style class"
msgstr "nouvelle classe"

#: ../Doc/glossary.rst:733
msgid ""
"Old name for the flavor of classes now used for all class objects.  In "
"earlier Python versions, only new-style classes could use Python's newer, "
"versatile features like :attr:`~object.__slots__`, descriptors, properties, :"
"meth:`__getattribute__`, class methods, and static methods."
msgstr ""
"Ancien nom pour l'implémentation actuelle des classes, pour tous les objets. "
"Dans les anciennes versions de Python, seulement les nouvelles classes "
"pouvaient utiliser les nouvelles fonctionnalités tel que :attr:`~object."
"__slots__`, les descripteurs, les propriétés, :meth:`__getattribute__`, les "
"méthodes de classe, et les méthodes statiques."

#: ../Doc/glossary.rst:737
msgid "object"
msgstr "objet"

#: ../Doc/glossary.rst:739
msgid ""
"Any data with state (attributes or value) and defined behavior (methods).  "
"Also the ultimate base class of any :term:`new-style class`."
msgstr ""
"N'importe quelle donnée comportant des états sous forme d'attributs ou de "
"valeurs, et un comportement (des méthodes). C'est aussi (``object``) "
"l'ancêtre commun à absolument toutes les :term:`nouvelles classes <new-style "
"class>`."

#: ../Doc/glossary.rst:742
msgid "package"
msgstr "paquet"

#: ../Doc/glossary.rst:744
msgid ""
"A Python :term:`module` which can contain submodules or recursively, "
"subpackages.  Technically, a package is a Python module with an ``__path__`` "
"attribute."
msgstr ""
"Un :term:`module` qui peut contenir des sous modules ou des sous paquets. "
"Techniquement, un paquet est un module qui a un attribut ``__path__``."

#: ../Doc/glossary.rst:748
msgid "See also :term:`regular package` and :term:`namespace package`."
msgstr "Voir aussi :term:`paquet classique` et :term:`paquet espace de nom`."

#: ../Doc/glossary.rst:749
msgid "parameter"
msgstr "paramètre"

#: ../Doc/glossary.rst:751
msgid ""
"A named entity in a :term:`function` (or method) definition that specifies "
"an :term:`argument` (or in some cases, arguments) that the function can "
"accept.  There are five kinds of parameter:"
msgstr ""
"Une entité nommée, dans la définition d'une :term:`fonction` (ou méthode, "
"décrivant un :term:`argument` (ou dans certains cas des arguments) que la "
"fonction accepte. Il existe cinq sorte de paramètres :"

#: ../Doc/glossary.rst:755
msgid ""
":dfn:`positional-or-keyword`: specifies an argument that can be passed "
"either :term:`positionally <argument>` or as a :term:`keyword argument "
"<argument>`.  This is the default kind of parameter, for example *foo* and "
"*bar* in the following::"
msgstr ""
":dfn:`positional-or-keyword`: dit d'un argument qui peut être passé soit par "
"sa :term:`position <argument>` soit en temps que :term:`paramètre nommé "
"<argument>`. C'est le type de paramètre par défaut, par exemple, *foo* et "
"*bar* dans l'exemple suivant : ::"

#: ../Doc/glossary.rst:764
msgid ""
":dfn:`positional-only`: specifies an argument that can be supplied only by "
"position.  Python has no syntax for defining positional-only parameters.  "
"However, some built-in functions have positional-only parameters (e.g. :func:"
"`abs`)."
msgstr ""
":dfn:`positional-only`: un argument qui ne peut être donné que par sa "
"position. Python n'a pas de syntaxe pour déclarer de tels paramètre, "
"cependant des fonctions natives, comme :func:`abs` en utilisent."

#: ../Doc/glossary.rst:771
msgid ""
":dfn:`keyword-only`: specifies an argument that can be supplied only by "
"keyword.  Keyword-only parameters can be defined by including a single var-"
"positional parameter or bare ``*`` in the parameter list of the function "
"definition before them, for example *kw_only1* and *kw_only2* in the "
"following::"
msgstr ""
":dfn:`keyword-only`: définit un argument qui ne peut être fournit que par "
"nom. Les paramètres *keyword-only* peuvent être définis en utilisant un seul "
"paramètre *var-positional*, ou en ajoutant une étoire (*) seule dans la "
"liste des paramètres avant avant eux. Comme kw_only1 et kw_only2 ici : ::"

#: ../Doc/glossary.rst:779
msgid ""
":dfn:`var-positional`: specifies that an arbitrary sequence of positional "
"arguments can be provided (in addition to any positional arguments already "
"accepted by other parameters).  Such a parameter can be defined by "
"prepending the parameter name with ``*``, for example *args* in the "
"following::"
msgstr ""
":dfn:`var-positional`: spécifie qu'une séquence d'arguments positionels peut "
"être fourni (en plus de tous les arguments positionels déjà acceptés par "
"d'autres paramètres). Un tel paramètre peut être définit en préfixant son "
"nom par une ``*``, par exemple *args* ici : ::"

#: ../Doc/glossary.rst:787
msgid ""
":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be "
"provided (in addition to any keyword arguments already accepted by other "
"parameters).  Such a parameter can be defined by prepending the parameter "
"name with ``**``, for example *kwargs* in the example above."
msgstr ""
":dfn:`var-keyword`: spécifie qu'une quantité arbitraire d'arguments peuvent "
"être passés par nom (en plus de tous les arguments nommés déjà acceptés par "
"d'autres paramètres). Un tel paramètre est définit en préfixant le nom du "
"paramètre par ``**``, par exemple, *kwargs* ci-dessus."

#: ../Doc/glossary.rst:793
msgid ""
"Parameters can specify both optional and required arguments, as well as "
"default values for some optional arguments."
msgstr ""
"Les paramètres peuvent décrire aussi bien des paramètres optionnels ou "
"obligatoires, aussi que des valeurs par défaut pour les paramètres "
"optionnels."

#: ../Doc/glossary.rst:796
msgid ""
"See also the :term:`argument` glossary entry, the FAQ question on :ref:`the "
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
"the :class:`inspect.Parameter` class, the :ref:`function` section, and :pep:"
"`362`."
msgstr ""
"Voir aussi :term:`argument` dans le glossaire, la question sur :ref:`la "
"différence entre les arguments et les paramètre <faq-argument-vs-parameter>` "
"dans la FAQ, la classe :class:`inspect.Parameter`, la section :ref:"
"`function`, et la :pep:`362`."

#: ../Doc/glossary.rst:800
msgid "path entry"
msgstr "chemin"

#: ../Doc/glossary.rst:802
msgid ""
"A single location on the :term:`import path` which the :term:`path based "
"finder` consults to find modules for importing."
msgstr ""
"Un seul emplacement dans l':term:`import path` que le :term:`path based "
"finder` consulte pour trouver des modules à importer."

#: ../Doc/glossary.rst:804
msgid "path entry finder"
msgstr "path entry finder"

#: ../Doc/glossary.rst:806
msgid ""
"A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. a :"
"term:`path entry hook`) which knows how to locate modules given a :term:"
"`path entry`."
msgstr ""
"Un :term:`finder` donné par un appelable sur un :data:`sys.path_hooks` (çàd "
"un :term:`path entry hook`) qui sait où trouver des modules lorsqu'on lui "
"donne un :term:`path entry`."

#: ../Doc/glossary.rst:810
msgid ""
"See :class:`importlib.abc.PathEntryFinder` for the methods that path entry "
"finders implement."
msgstr ""
"Voir :class:`importlib.abc.PathEntryFinder` pour les méthodes qu'un *path "
"entry finder* doit implémenter."

#: ../Doc/glossary.rst:812
msgid "path entry hook"
msgstr "path entry hook"

#: ../Doc/glossary.rst:814
msgid ""
"A callable on the :data:`sys.path_hook` list which returns a :term:`path "
"entry finder` if it knows how to find modules on a specific :term:`path "
"entry`."
msgstr ""
"Un appelable dans la liste :data:`sys.path_hook` qui donne un :term:`path "
"entry finder` s'il sait où trouver des modules pour un :term:`path entry` "
"donné."

#: ../Doc/glossary.rst:817
msgid "path based finder"
msgstr "path based finder"

#: ../Doc/glossary.rst:819
msgid ""
"One of the default :term:`meta path finders <meta path finder>` which "
"searches an :term:`import path` for modules."
msgstr ""
"L'un des :term:`meta path finders <meta path finder>` par défaut qui cherche "
"des modules dans un :term:`import path`."

#: ../Doc/glossary.rst:821
msgid "path-like object"
msgstr "objet simili-chemin"

#: ../Doc/glossary.rst:823
msgid ""
"An object representing a file system path. A path-like object is either a :"
"class:`str` or :class:`bytes` object representing a path, or an object "
"implementing the :class:`os.PathLike` protocol. An object that supports the :"
"class:`os.PathLike` protocol can be converted to a :class:`str` or :class:"
"`bytes` file system path by calling the :func:`os.fspath` function; :func:"
"`os.fsdecode` and :func:`os.fsencode` can be used to guarantee a :class:"
"`str` or :class:`bytes` result instead, respectively. Introduced by :pep:"
"`519`."
msgstr ""
"Un objet représentant un chemin du système de fichiers. Un objet simili-"
"chemin est soit un  objet :class:`str` ou un objet :class:`bytes` "
"représentant un chemin, ou un objet implémentant le protocol :class:`os."
"PathLike`. Un objet qui supporte le protocol :class:`os.PathLike` peut être "
"converti en un chemin  :class:`str` ou :class:`bytes` du système de fichier "
"en appellant la fonction :func:`os.fspath`. :func:`os.fsdecode` et :func:`os."
"fsencode` peuvent être utilisées, respectivement, pour garantir un résultat "
"de type :class:`str` ou :class:`bytes` à la place. Introduit dans la :pep:"
"`519`."

#: ../Doc/glossary.rst:831
msgid "portion"
msgstr "portion"

#: ../Doc/glossary.rst:833
msgid ""
"A set of files in a single directory (possibly stored in a zip file) that "
"contribute to a namespace package, as defined in :pep:`420`."
msgstr ""
"Un jeu de fichiers dans un seul dossier (pouvant être stockés sous forme de "
"fichier zip) qui contribuent à l'espace de nom d'un paquet, tel que définit "
"dans la :pep:`420`."

#: ../Doc/glossary.rst:835
msgid "positional argument"
msgstr "augment positionnel"

#: ../Doc/glossary.rst:838
msgid "provisional API"
msgstr "API provisoire"

#: ../Doc/glossary.rst:840
msgid ""
"A provisional API is one which has been deliberately excluded from the "
"standard library's backwards compatibility guarantees.  While major changes "
"to such interfaces are not expected, as long as they are marked provisional, "
"backwards incompatible changes (up to and including removal of the "
"interface) may occur if deemed necessary by core developers.  Such changes "
"will not be made gratuitously -- they will occur only if serious fundamental "
"flaws are uncovered that were missed prior to the inclusion of the API."
msgstr ""
"Une API provisoire est une API délibérément exclue des garanties de "
"rétrocompatibilité de la bibliothèque standard. Bien que des changements "
"majeurs de telles interfaces ne sont pas attendus, tant qu'elles sont "
"marquées provisoires, des changement cassant la rétrocompatibilité (jusqu'à "
"sa suppression complète) peuvent survenir s'ils semblent nécessaires. Ces "
"modifications ne seront pas effectuées gratuitement, ils ne surviendront "
"seulement si de sérieux problèmes sont découvert, qui n'avaient pas étés "
"repérés avant l'ajout de l'API."

#: ../Doc/glossary.rst:849
msgid ""
"Even for provisional APIs, backwards incompatible changes are seen as a "
"\"solution of last resort\" - every attempt will still be made to find a "
"backwards compatible resolution to any identified problems."
msgstr ""
"Même pour les API provisoires, les changement cassant la rétrocompatibilité "
"sont des \"solutions de dernier recours\", tout ce qui est possible sera "
"fait pour tenter de résoudre les problème en conservant la "
"rétrocompatibilité."

#: ../Doc/glossary.rst:853
msgid ""
"This process allows the standard library to continue to evolve over time, "
"without locking in problematic design errors for extended periods of time.  "
"See :pep:`411` for more details."
msgstr ""
"Ce processus permet à la bibliothèque standard de continuer à évoluer avec "
"le temps, sans se bloquer longtemps sur des erreurs d'architecture. Voir la :"
"pep:`411` pour plus de détails."

#: ../Doc/glossary.rst:856
msgid "provisional package"
msgstr "paquet provisoire"

#: ../Doc/glossary.rst:858
msgid "See :term:`provisional API`."
msgstr "Voir :term:`provisional API`."

#: ../Doc/glossary.rst:859
msgid "Python 3000"
msgstr "Python 3000"

#: ../Doc/glossary.rst:861
msgid ""
"Nickname for the Python 3.x release line (coined long ago when the release "
"of version 3 was something in the distant future.)  This is also abbreviated "
"\"Py3k\"."
msgstr ""
"Surnom de la série des Python 3.x (très vieux surnom donné à l'époque pour "
"Python 3 n'était qu'un futur lointain). Aussi abrégé \"Py3k\"."

#: ../Doc/glossary.rst:864
msgid "Pythonic"
msgstr "Pythonique"

#: ../Doc/glossary.rst:866
msgid ""
"An idea or piece of code which closely follows the most common idioms of the "
"Python language, rather than implementing code using concepts common to "
"other languages.  For example, a common idiom in Python is to loop over all "
"elements of an iterable using a :keyword:`for` statement.  Many other "
"languages don't have this type of construct, so people unfamiliar with "
"Python sometimes use a numerical counter instead::"
msgstr ""
"Une idée, ou un bout de code, qui suit de près la philosophie de Python, "
"parfois en opposition avec les concepts rencontrés dans d'autres langages. "
"Typiquement, la coutume en Python est de parcourir les éléments d'un "
"itérable en utilisant :keyword:`for`. Beaucoup de langages n'ont pas cette "
"possibilité, donc les gens qui ne sont pas habitués à Python pourraient "
"parfois utiliser un compteur à la place : ::"

#: ../Doc/glossary.rst:876
msgid "As opposed to the cleaner, Pythonic method::"
msgstr ""
"Plutôt qu'utiliser la méthode, plus propre et élégante, donc Pythonique : ::"

#: ../Doc/glossary.rst:880
msgid "qualified name"
msgstr "nom qualifié"

#: ../Doc/glossary.rst:882
msgid ""
"A dotted name showing the \"path\" from a module's global scope to a class, "
"function or method defined in that module, as defined in :pep:`3155`.  For "
"top-level functions and classes, the qualified name is the same as the "
"object's name::"
msgstr ""
"Un nom, comprenant des points, montrant le \"chemin\" de l'espace de nom "
"globale d'un module à une class, fonction, ou méthode définie dans ce "
"module, tel que défini dans la :pep:`3155`. Pour les fonctions et classes de "
"premier niveau, le nom qualifié est le même que le nom de l'objet : ::"

#: ../Doc/glossary.rst:899
msgid ""
"When used to refer to modules, the *fully qualified name* means the entire "
"dotted path to the module, including any parent packages, e.g. ``email.mime."
"text``::"
msgstr ""
"Lorsqu'il est utilisé pour nommer des modules, le *nom qualifié complet* "
"signifie le chemin complet (séparé par des points) vers le module, incluant "
"tous les paquet parents, typiquement: ``email.mime.text`` ::"

#: ../Doc/glossary.rst:906
msgid "reference count"
msgstr "nombre de références"

#: ../Doc/glossary.rst:908
msgid ""
"The number of references to an object.  When the reference count of an "
"object drops to zero, it is deallocated.  Reference counting is generally "
"not visible to Python code, but it is a key element of the :term:`CPython` "
"implementation.  The :mod:`sys` module defines a :func:`~sys.getrefcount` "
"function that programmers can call to return the reference count for a "
"particular object."
msgstr ""
"Le nombre de références à un objet. Lorsque le nombre de références à un "
"objet descend à zéro, l'objet est désalloué. Le comptage de référence n'est "
"généralement pas visible dans le code Python, mais c'est un élément clef de "
"l'implémentation :term:`CPython`. Le module :mod:`sys` défini une fonction :"
"func:`~sys.getrefcount` que les développeurs peuvent utiliser pour obtenir "
"le nombre de référence d'un objet donné."

#: ../Doc/glossary.rst:914
msgid "regular package"
msgstr "paquet classique"

#: ../Doc/glossary.rst:916
msgid ""
"A traditional :term:`package`, such as a directory containing an ``__init__."
"py`` file."
msgstr ""
"Un :term:`paquet` traditionnel, tel qu'un dossier contenant un fichier "
"``__init__.py``."

#: ../Doc/glossary.rst:919
msgid "See also :term:`namespace package`."
msgstr "Voir aussi :term:`paquet espace de nom`."

#: ../Doc/glossary.rst:920
msgid "__slots__"
msgstr "__slots__"

#: ../Doc/glossary.rst:922
msgid ""
"A declaration inside a class that saves memory by pre-declaring space for "
"instance attributes and eliminating instance dictionaries.  Though popular, "
"the technique is somewhat tricky to get right and is best reserved for rare "
"cases where there are large numbers of instances in a memory-critical "
"application."
msgstr ""
"Une déclaration dans une classe qui économise de la mémoire en pré-allouant "
"de l'espace pour les instances des attributs, et le dictionnaire des "
"instances. Bien que populaire, cette technique est difficile à maîtriser et "
"devrait être réservée à de rares cas avec un grand nombre d'instances dans "
"une application où la mémoire est un sujet critique."

#: ../Doc/glossary.rst:927
msgid "sequence"
msgstr "séquence"

#: ../Doc/glossary.rst:929
msgid ""
"An :term:`iterable` which supports efficient element access using integer "
"indices via the :meth:`__getitem__` special method and defines a :meth:"
"`__len__` method that returns the length of the sequence. Some built-in "
"sequence types are :class:`list`, :class:`str`, :class:`tuple`, and :class:"
"`bytes`. Note that :class:`dict` also supports :meth:`__getitem__` and :meth:"
"`__len__`, but is considered a mapping rather than a sequence because the "
"lookups use arbitrary :term:`immutable` keys rather than integers."
msgstr ""
"Un :term:`itérable` qui gère l'accès efficient à ses éléments par un indice "
"sous forme de nombre entier via la méthode spéciale :meth:`__getitem__` et "
"qui défini une méthode :meth:`__len__` qui donne sa taille. Voici quelques "
"séquences natives : :class:`list`, :class:`str`, :class:`tuple`, et :class:"
"`bytes`. Notez que :class:`dict` a aussi une méthode :meth:`__getitem__` et "
"une méthode :meth:`__len__`, mais il est considéré comme un *mapping* plutôt "
"qu'une séquence, car ses accès se font par une clef arbitraire :term:"
"`immuable` plutôt qu'un nombre entier."

#: ../Doc/glossary.rst:938
msgid ""
"The :class:`collections.abc.Sequence` abstract base class defines a much "
"richer interface that goes beyond just :meth:`__getitem__` and :meth:"
"`__len__`, adding :meth:`count`, :meth:`index`, :meth:`__contains__`, and :"
"meth:`__reversed__`. Types that implement this expanded interface can be "
"registered explicitly using :func:`~abc.register`."
msgstr ""
"La class abstraite de base :class:`collections.abc.Sequence` défini une "
"interface plus riche qui va au delà des simples :meth:`__getitem__` et :meth:"
"`__len__`, en ajoutant :meth:`count`, :meth:`index`, :meth:`__contains__`, "
"et :meth:`__reversed__`. Les types qui implémentent cette interface étendue "
"peuvent s'enregistrer explicitement en utilisant :func:`~abc.register`."

#: ../Doc/glossary.rst:945
msgid "single dispatch"
msgstr "distribution simple"

#: ../Doc/glossary.rst:947
msgid ""
"A form of :term:`generic function` dispatch where the implementation is "
"chosen based on the type of a single argument."
msgstr ""
"Une forme de distribution, comme les :term:`fonction génériques <fonction "
"générique>`, où l'implémentation est choisie en fonction du type d'un seul "
"argument."

#: ../Doc/glossary.rst:949
msgid "slice"
msgstr "tranche"

#: ../Doc/glossary.rst:951
msgid ""
"An object usually containing a portion of a :term:`sequence`.  A slice is "
"created using the subscript notation, ``[]`` with colons between numbers "
"when several are given, such as in ``variable_name[1:3:5]``.  The bracket "
"(subscript) notation uses :class:`slice` objects internally."
msgstr ""
"*slice*, un objet contenant habituellement une portion de :term:`séquence`. "
"Une tranche est crée en utilisant la notation ``[]`` avec des ``:`` entre "
"les nombres lorsque plusieurs sont fournis, tel que dans "
"``variable_name[1:3:5]``. Cette notation utilise des objets :class:`slice` "
"en interne."

#: ../Doc/glossary.rst:955
msgid "special method"
msgstr "méthode spéciale"

#: ../Doc/glossary.rst:957
msgid ""
"A method that is called implicitly by Python to execute a certain operation "
"on a type, such as addition.  Such methods have names starting and ending "
"with double underscores.  Special methods are documented in :ref:"
"`specialnames`."
msgstr ""
"*special method*: Une méthode appelée implicitement par Python pour exécuter "
"une opération sur un type, tel qu'une addition. De telles méthodes ont des "
"noms commençant et terminant par des doubles tirets bas. Les méthodes "
"spéciales sont documentées dans :ref:`specialnames`."

#: ../Doc/glossary.rst:961
msgid "statement"
msgstr "instruction"

#: ../Doc/glossary.rst:963
msgid ""
"A statement is part of a suite (a \"block\" of code).  A statement is either "
"an :term:`expression` or one of several constructs with a keyword, such as :"
"keyword:`if`, :keyword:`while` or :keyword:`for`."
msgstr ""
"Une instruction (*statement*) fait partie d'une suite, (un \"bloc\" de "
"code). Une instruction est soit une :term:`expression` soit une ou plusieurs "
"constructions basées sur un mot-clef, tel qu'un :keyword:`if`, :keyword:"
"`while`, ou :keyword:`for`."

#: ../Doc/glossary.rst:966
msgid "struct sequence"
msgstr "struct sequence"

#: ../Doc/glossary.rst:968
msgid ""
"A tuple with named elements. Struct sequences expose an interface similar "
"to :term:`named tuple` in that elements can either be accessed either by "
"index or as an attribute. However, they do not have any of the named tuple "
"methods like :meth:`~collections.somenamedtuple._make` or :meth:"
"`~collections.somenamedtuple._asdict`. Examples of struct sequences include :"
"data:`sys.float_info` and the return value of :func:`os.stat`."
msgstr ""
"Un n-uplet (*tuple*) dont les éléments sont nommés. Les *struct sequences* "
"exposent une interface similaires au :term:`named tuple` par le fait que "
"leurs éléments peuvent être accédés par nom d'attribut ou par indice. "
"Cependant, elles n'ont aucune des méthodes du *named tuple*, comme :meth:"
"`collections.somenamedtuple._make` ou :meth:`~collections.somenamedtuple."
"_asdict`. Par exemple :data:`sys.float_info`, ou les valeurs données par :"
"func:`os.stat` sont des *struct sequence*."

#: ../Doc/glossary.rst:974
msgid "text encoding"
msgstr "encodage de texte"

#: ../Doc/glossary.rst:976
msgid "A codec which encodes Unicode strings to bytes."
msgstr "Un codec qui convertit des chaînes de caractères Unicode en octets."

#: ../Doc/glossary.rst:977
msgid "text file"
msgstr "fichier texte"

#: ../Doc/glossary.rst:979
msgid ""
"A :term:`file object` able to read and write :class:`str` objects. Often, a "
"text file actually accesses a byte-oriented datastream and handles the :term:"
"`text encoding` automatically. Examples of text files are files opened in "
"text mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and "
"instances of :class:`io.StringIO`."
msgstr ""
"Un :term:`file object` capable de lire et d'écrire des objets :class:`str`. "
"Souvent, un fichier texte (*text file*) accède en fait à un flux de donnée "
"en octets, et gère l':term:`text encoding` automatiquement.  Quelques "
"fichiers texte ouverts en mode texte (``'r'`` ou ``'w'``), :data:`sys."
"stdin`, :data:`sys.stdout`, et les instances de :class:`io.StringIO`."

#: ../Doc/glossary.rst:987
msgid "A :term:`binary file` reads and write :class:`bytes` objects."
msgstr "Un :term:`fichier binaire` lit et écrit des objets :class:`bytes`."

#: ../Doc/glossary.rst:988
msgid "triple-quoted string"
msgstr "chaîne entre triple guillemets"

#: ../Doc/glossary.rst:990
msgid ""
"A string which is bound by three instances of either a quotation mark (\") "
"or an apostrophe (').  While they don't provide any functionality not "
"available with single-quoted strings, they are useful for a number of "
"reasons.  They allow you to include unescaped single and double quotes "
"within a string and they can span multiple lines without the use of the "
"continuation character, making them especially useful when writing "
"docstrings."
msgstr ""
"Une chaîne qui est assembée par trois guillemets simples (``'``) ou trois "
"guillemets doubles (``\"``). Bien qu'elles ne fournissent aucune "
"fonctionalité qui ne serait pas disponnible avec les chaînes entre "
"guillemets, elles sont utiles pour moultes raisons. Elles vous autorisent à "
"insérer des guillemets simples et doubles dans une chaîne sans avoir à les "
"protéger, et elles peuvent s'étendre sur plusieurs lignes sans avoir à les "
"terminer par un ``\\``, les rendant ainsi particulièrement utile pour les "
"chaînes de documentation (*docstrings*)."

#: ../Doc/glossary.rst:997
msgid "type"
msgstr "type"

#: ../Doc/glossary.rst:999
msgid ""
"The type of a Python object determines what kind of object it is; every "
"object has a type.  An object's type is accessible as its :attr:`~instance."
"__class__` attribute or can be retrieved with ``type(obj)``."
msgstr ""
"Le type d'un objet Python détermine quel genre d'objet c'est. Tous les "
"objets ont un type. Le type d'un objet peut être obtenu via son attribut :"
"attr:`~instance.__class__` ou via ``type(obj)``."

#: ../Doc/glossary.rst:1003
msgid "universal newlines"
msgstr "retours à la ligne universels"

#: ../Doc/glossary.rst:1005
msgid ""
"A manner of interpreting text streams in which all of the following are "
"recognized as ending a line: the Unix end-of-line convention ``'\\n'``, the "
"Windows convention ``'\\r\\n'``, and the old Macintosh convention "
"``'\\r'``.  See :pep:`278` and :pep:`3116`, as well as :func:`bytes."
"splitlines` for an additional use."
msgstr ""
"Une manière d'interpréter des flux de texte dans lesquels toutes les fin de "
"lignes suivantes sont reconnues: la convention Unix ``'\\n'``, la convention "
"Windows ``'\\r\\n'``, et l'ancienne convention Macintosh ``'\\r'``. Voir la :"
"pep:`278` et la :pep:`3116`, ainsi que la fonction :func:`bytes.splitlines` "
"pour d'autres usages."

#: ../Doc/glossary.rst:1010
msgid "variable annotation"
msgstr "annotation de variable"

#: ../Doc/glossary.rst:1012
msgid ""
"A type metadata value associated with a module global variable or a class "
"attribute. Its syntax is explained in section :ref:`annassign`. Annotations "
"are stored in the :attr:`__annotations__` special attribute of a class or "
"module object and can be accessed using :func:`typing.get_type_hints`."
msgstr ""
"Un type de métadonnées associée à une variable globale de module ou a un "
"attribut de classe. Sa syntaxe est expliquée dans la section :ref:"
"`annassign`. Les annotations sont stockées dans un attribut :attr:"
"`__annotations__` spécial de classe ou de module et est accessible en "
"utilisant :func:`typing.get_type_hints`."

#: ../Doc/glossary.rst:1018
msgid ""
"Python itself does not assign any particular meaning to variable "
"annotations. They are intended to be interpreted by third-party libraries or "
"type checking tools. See :pep:`526`, :pep:`484` which describe some of their "
"potential uses."
msgstr ""
"Python lui-même n'attache aucune signification particulière aux annotations "
"de variables. Elles sont destinées à être interprétées par des bibliothèques "
"tierces ou des outils de contrôle de type. Voir :pep:`526` et :pep:`484` qui "
"décrivent certaines de leurs utilisations potentielles."

#: ../Doc/glossary.rst:1022
msgid "virtual environment"
msgstr "environnement virtuel"

#: ../Doc/glossary.rst:1024
msgid ""
"A cooperatively isolated runtime environment that allows Python users and "
"applications to install and upgrade Python distribution packages without "
"interfering with the behaviour of other Python applications running on the "
"same system."
msgstr ""
"Un environnement isolé, coopérant à son isolement à l'execution, qui permet "
"aux utilisateurs de Python et aux applications d'installer et de mettre à "
"jour des paquets sans interférer avec d'autres applications Python "
"fonctionnant sur le même système."

#: ../Doc/glossary.rst:1029
msgid "See also :mod:`venv`."
msgstr "Voir aussi :mod:`venv`."

#: ../Doc/glossary.rst:1030
msgid "virtual machine"
msgstr "machine virtuelle"

#: ../Doc/glossary.rst:1032
msgid ""
"A computer defined entirely in software.  Python's virtual machine executes "
"the :term:`bytecode` emitted by the bytecode compiler."
msgstr ""
"Un ordinateur défini entièrement par du logiciel. La machine virtuelle "
"(*virtual machine*) de Python exécute le :term:`bytecode` donné par le "
"compilateur de *bytecode*."

#: ../Doc/glossary.rst:1034
msgid "Zen of Python"
msgstr "Le Zen de Python"

#: ../Doc/glossary.rst:1036
msgid ""
"Listing of Python design principles and philosophies that are helpful in "
"understanding and using the language.  The listing can be found by typing "
"\"``import this``\" at the interactive prompt."
msgstr ""
"Liste de principes et de philosophies utiles pour comprendre et utiliser le "
"langage. Cette liste peut être obtenue en tapant \"``import this``\" dans "
"une invite Python interactive."

#~ msgid ">>>"
#~ msgstr ">>>"

#~ msgid "..."
#~ msgstr "..."

#~ msgid ""
#~ "A :term:`file object` able to read and write :term:`bytes-like objects "
#~ "<bytes-like object>`."
#~ msgstr ""
#~ "Un :term:`objet fichier` capable de lire et d'écrire :term:`des objets "
#~ "bytes-compatibles <bytes-like object>`."