glossary.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-17 14:27+0200\n"
"PO-Revision-Date: 2026-10-29 15:28+0100\n"
"Last-Translator: James Adjinwa <jamesadjinwa000@duck.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 3.6\n"

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

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

#: glossary.rst:12
msgid ""
"The default Python prompt of the :term:`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 :term:`interactif <interactive>`. On la voit souvent dans des "
"exemples de code qui peuvent être exécutés interactivement dans "
"l'interpréteur."

#: glossary.rst:15
msgid "``...``"
msgstr "``...``"

#: glossary.rst:17
msgid "Can refer to:"
msgstr "Peut faire référence à :"

#: glossary.rst:19
msgid ""
"The default Python prompt of the :term:`interactive` shell when entering the "
"code for an indented code block, when within a pair of matching left and "
"right delimiters (parentheses, square brackets, curly braces or triple "
"quotes), or after specifying a decorator."
msgstr ""
"L'invite de commande utilisée par défaut dans "
"l'interpréteur :term:`interactif <interactive>` lorsqu'on entre un bloc de "
"code indenté, dans des délimiteurs fonctionnant par paires (parenthèses, "
"crochets, accolades, triple guillemets), ou après un avoir spécifié un "
"décorateur."

#: glossary.rst:26
msgid ""
"The three dots form of the :ref:`Ellipsis <bltin-ellipsis-object>` object."
msgstr ""
"La forme en points de suspension de l'objet :ref:`ellipse <bltin-ellipsis-"
"object>`."

#: glossary.rst:27
msgid "abstract base class"
msgstr "classe abstraite"

#: glossary.rst:29
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 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 subtilement fausses (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 du système "
"d'importation (dans le module :mod:`importlib.abc`). Vous pouvez créer vos "
"propres ABC avec le module :mod:`abc`."

#: glossary.rst:40
msgid "annotate function"
msgstr "fonction annotate"

#: glossary.rst:42
msgid ""
"A callable that can be called to retrieve the :term:`annotations "
"<annotation>` of an object. Annotate functions are usually :term:`functions "
"<function>`, automatically generated as the :attr:`~object.__annotate__` "
"attribute of functions, classes, and modules. Annotate functions are a "
"subset of :term:`evaluate functions <evaluate function>`."
msgstr ""

#: glossary.rst:47
msgid "annotation"
msgstr "annotation"

#: glossary.rst:49
msgid ""
"A label associated with a variable, a class attribute or a function "
"parameter or return value, used by convention as a :term:`type hint`."
msgstr ""
"Étiquette associée à une variable, un attribut de classe, un paramètre de "
"fonction ou une valeur de retour. Elle est utilisée par convention "
"comme :term:`type hint`."

#: glossary.rst:53
#, fuzzy
msgid ""
"Annotations of local variables cannot be accessed at runtime, but "
"annotations of global variables, class attributes, and functions can be "
"retrieved by calling :func:`annotationlib.get_annotations` on modules, "
"classes, and functions, respectively."
msgstr ""
"Les annotations de variables locales ne sont pas accessibles au moment de "
"l'exécution, mais les annotations de variables globales, d'attributs de "
"classe et de fonctions sont stockées dans l'attribut "
"spécial :attr:`__annotations__` des modules, classes et fonctions, "
"respectivement."

#: glossary.rst:58
#, fuzzy
msgid ""
"See :term:`variable annotation`, :term:`function "
"annotation`, :pep:`484`, :pep:`526`, and :pep:`649`, which describe this "
"functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"Voir :term:`annotation de variable<variable annotation>`, :term:`annotation "
"de fonction<function annotation>`, les :pep:`484` et :pep:`526`, qui "
"décrivent cette fonctionnalité. Voir aussi :ref:`annotations-howto` sur les "
"bonnes pratiques concernant les annotations."

#: glossary.rst:62
msgid "argument"
msgstr "argument"

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

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

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

#: glossary.rst:84
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 "
"cette 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."

#: glossary.rst:89
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:`paramètre<parameter>` dans le glossaire, la "
"question :ref:`Différence entre argument et paramètre <faq-argument-vs-"
"parameter>` de la FAQ et la :pep:`362`."

#: glossary.rst:92
msgid "asynchronous context manager"
msgstr "gestionnaire de contexte asynchrone"

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

#: glossary.rst:97
msgid "asynchronous generator"
msgstr "générateur asynchrone"

#: glossary.rst:99
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 ""
"Fonction qui renvoie un :term:`itérateur de générateur asynchrone "
"<asynchronous generator iterator>`. Cela ressemble à une coroutine définie "
"par :keyword:`async def`, sauf qu'elle contient une ou des "
"expressions :keyword:`yield` produisant ainsi uns série de valeurs "
"utilisables dans une boucle :keyword:`async for`."

#: glossary.rst:104
msgid ""
"Usually refers to an 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 ""
"Générateur asynchrone fait généralement référence à une fonction, mais peut "
"faire référence à un *itérateur de générateur asynchrone* dans certains "
"contextes. Dans les cas où le sens voulu n'est pas clair, utiliser "
"l'ensemble des termes lève l’ambiguïté."

#: glossary.rst:108
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`."

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

#: glossary.rst:113
#, fuzzy
msgid "An object created by an :term:`asynchronous generator` function."
msgstr ""
"Objet créé par un :term:`générateur asynchrone <asynchronous generator>`."

#: glossary.rst:115
msgid ""
"This is an :term:`asynchronous iterator` which when called using "
"the :meth:`~object.__anext__` method returns an awaitable object which will "
"execute 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:`~object.__anext__` renvoie un objet *awaitable* qui exécute "
"le corps de la fonction du générateur asynchrone jusqu'au "
"prochain :keyword:`yield`."

#: glossary.rst:120
#, fuzzy
msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"execution state (including local variables and pending try-statements).  "
"When the *asynchronous generator iterator* effectively resumes with another "
"awaitable returned by :meth:`~object.__anext__`, it picks up where it left "
"off.  See :pep:`492` and :pep:`525`."
msgstr ""
"Chaque :keyword:`yield` suspend temporairement l'exécution, en gardant en "
"mémoire l'emplacement et l'état de l'exécution (ce qui inclut les variables "
"locales et les *try* en cours). Lorsque l'exécution de l'itérateur de "
"générateur asynchrone reprend avec un nouvel *awaitable* renvoyé "
"par :meth:`~object.__anext__`, elle repart de là où elle s'était arrêtée. "
"Voir les :pep:`492` et :pep:`525`."

#: glossary.rst:125
msgid "asynchronous iterable"
msgstr "itérable asynchrone"

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

#: glossary.rst:130
msgid "asynchronous iterator"
msgstr "itérateur asynchrone"

#: glossary.rst:132
msgid ""
"An object that implements the :meth:`~object.__aiter__` "
"and :meth:`~object.__anext__` methods.  :meth:`~object.__anext__` must "
"return an :term:`awaitable` object. :keyword:`async for` resolves the "
"awaitables returned by an asynchronous iterator's :meth:`~object.__anext__` "
"method until it raises a :exc:`StopAsyncIteration` exception.  Introduced "
"by :pep:`492`."
msgstr ""
"Objet qui implémente les méthodes :meth:`~object.__aiter__` "
"et :meth:`~object.__anext__`. :meth:`~object.__anext__` doit renvoyer un "
"objet :term:`awaitable`. Tant que la méthode :meth:`~object.__anext__` "
"produit des objets *awaitable*, le :keyword:`async for` appelant les "
"consomme. L'itérateur asynchrone lève une "
"exception :exc:`StopAsyncIteration` pour signifier la fin de l'itération. A "
"été introduit par la :pep:`492`."

#: glossary.rst:137
msgid "atomic operation"
msgstr ""

#: glossary.rst:139
msgid ""
"An operation that appears to execute as a single, indivisible step: no other "
"thread can observe it half-done, and its effects become visible all at "
"once.  Python does not guarantee that high-level statements are atomic (for "
"example, ``x += 1`` performs multiple bytecode operations and is not "
"atomic).  Atomicity is only guaranteed where explicitly documented.  See "
"also :term:`race condition` and :term:`data race`."
msgstr ""

#: glossary.rst:145
msgid "attached thread state"
msgstr ""

#: glossary.rst:148
msgid "A :term:`thread state` that is active for the current OS thread."
msgstr ""

#: glossary.rst:150
msgid ""
"When a :term:`thread state` is attached, the OS thread has access to the "
"full Python C API and can safely invoke the bytecode interpreter."
msgstr ""

#: glossary.rst:154
msgid ""
"Unless a function explicitly notes otherwise, attempting to call the C API "
"without an attached thread state will result in a fatal error or undefined "
"behavior.  A thread state can be attached and detached explicitly by the "
"user through the C API, or implicitly by the runtime, including during "
"blocking C calls and by the bytecode interpreter in between calls."
msgstr ""

#: glossary.rst:161
msgid ""
"On most builds of Python, having an attached thread state implies that the "
"caller holds the :term:`GIL` for the current interpreter, so only one OS "
"thread can have an attached thread state at a given moment. In :term:`free-"
"threaded builds <free-threaded build>` of Python, threads can concurrently "
"hold an attached thread state, allowing for true parallelism of the bytecode "
"interpreter."
msgstr ""

#: glossary.rst:167
msgid "attribute"
msgstr "attribut"

#: glossary.rst:169
msgid ""
"A value associated with an object which is usually referenced by name using "
"dotted expressions. For example, if an object *o* has an attribute *a* it "
"would be referenced as *o.a*."
msgstr ""
"Valeur associée à un objet et habituellement désignée par son nom *via* une "
"notation utilisant des points. Par exemple, si un objet *o* possède un "
"attribut *a*, cet attribut est référencé par *o.a*."

#: glossary.rst:174
msgid ""
"It is possible to give an object an attribute whose name is not an "
"identifier as defined by :ref:`identifiers`, for example "
"using :func:`setattr`, if the object allows it. Such an attribute will not "
"be accessible using a dotted expression, and would instead need to be "
"retrieved with :func:`getattr`."
msgstr ""
"Il est possible de donner à un objet un attribut dont le nom n'est pas un "
"identifiant tel que défini pour les :ref:`identifiers`, par exemple en "
"utilisant :func:`setattr`, si l'objet le permet. Un tel attribut ne sera pas "
"accessible à l'aide d'une expression pointée et on devra y accéder "
"avec :func:`getattr`."

#: glossary.rst:179
msgid "awaitable"
msgstr "attendable (*awaitable*)"

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

#: glossary.rst:184
msgid "BDFL"
msgstr "BDFL"

#: glossary.rst:186
msgid ""
"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://"
"gvanrossum.github.io/>`_, Python's creator."
msgstr ""
"Dictateur bienveillant à vie (*Benevolent Dictator For Life* en anglais). "
"Pseudonyme de `Guido van Rossum <https://gvanrossum.github.io/>`_, le "
"créateur de Python."

#: glossary.rst:188
msgid "binary file"
msgstr "fichier binaire"

#: glossary.rst:190
#, fuzzy
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 "
"<sys.stdin>`, :data:`sys.stdout.buffer <sys.stdout>`, 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>`. Des fichiers binaires sont, par exemple, les "
"fichiers ouverts en mode binaire (``'rb'``, ``'wb'``, ou "
"``'rb+'``), :data:`sys.stdin.buffer`, :data:`sys.stdout.buffer`, les "
"instances de :class:`io.BytesIO` ou de :class:`gzip.GzipFile`."

#: glossary.rst:197
msgid ""
"See also :term:`text file` for a file object able to read and "
"write :class:`str` objects."
msgstr ""
"Consultez :term:`fichier texte`, un objet fichier capable de lire et "
"d'écrire des objets :class:`str`."

#: glossary.rst:199
msgid "borrowed reference"
msgstr "référence empruntée"

#: glossary.rst:201
#, fuzzy
msgid ""
"In Python's C API, a borrowed reference is a reference to an object, where "
"the code using the object does not own the reference. It becomes a dangling "
"pointer if the object is destroyed. For example, a garbage collection can "
"remove the last :term:`strong reference` to the object and so destroy it."
msgstr ""
"Dans l'API C de Python, une référence empruntée est une référence vers un "
"objet qui n'affecte pas son compteur de référence. Elle devient invalide si "
"l'objet est supprimé, par exemple au cours d'un passage du ramasse-miettes "
"qui conduit à la disparition de la dernière :term:`référence forte` vers "
"l'objet."

#: glossary.rst:207
msgid ""
"Calling :c:func:`Py_INCREF` on the :term:`borrowed reference` is recommended "
"to convert it to a :term:`strong reference` in-place, except when the object "
"cannot be destroyed before the last usage of the borrowed reference. "
"The :c:func:`Py_NewRef` function can be used to create a new :term:`strong "
"reference`."
msgstr ""
"Il est recommandé d'appeler :c:func:`Py_INCREF` sur la :term:`référence "
"empruntée`, ce qui la transforme *in situ* en une :term:`référence forte`. "
"Vous pouvez faire une exception si vous êtes certain que l'objet ne peut pas "
"être supprimé avant la dernière utilisation de la référence empruntée. Voir "
"aussi la fonction :c:func:`Py_NewRef`, qui crée une "
"nouvelle :term:`référence forte`."

#: glossary.rst:212
msgid "bytes-like object"
msgstr "objet octet-compatible"

#: glossary.rst:214
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 le :ref:`protocole tampon <bufferobjects>` et pouvant "
"exporter un tampon (*buffer* en anglais) C-:term:`contigu <contiguous>`. "
"Cela inclut les objets :class:`bytes`, :class:`bytearray` "
"et :class:`array.array`, ainsi que beaucoup d'objets :class:`memoryview`. "
"Les objets octets-compatibles peuvent être utilisés pour diverses opérations "
"sur des données binaires, comme la compression, la sauvegarde dans un "
"fichier binaire ou l'envoi sur le réseau."

#: glossary.rst:221
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` ou une :class:`memoryview` "
"d'un :class:`bytearray` en font partie. D'autres opérations nécessitent de "
"travailler sur des données binaires stockées dans des objets immuables "
"(« *objets octets-compatibles en lecture seule* »), par exemple "
"des :class:`bytes` ou des :class:`memoryview` d'un objet :class:`bytes`."

#: glossary.rst:229
msgid "bytecode"
msgstr "code intermédiaire (*bytecode*)"

#: glossary.rst:231
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 code intermédiaire (*bytecode* "
"en anglais), la représentation interne à CPython d'un programme Python. Le "
"code intermédiaire est mis en cache dans un fichier ``.pyc`` de manière à ce "
"qu'une seconde exécution soit plus rapide (la compilation en code "
"intermédiaire a déjà été faite). 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 code intermédiaire. Notez que le code "
"intermédiaire n'a pas vocation à fonctionner sur différentes machines "
"virtuelles Python ou à être stable entre différentes versions de Python."

#: glossary.rst:241
msgid ""
"A list of bytecode instructions can be found in the documentation "
"for :ref:`the dis module <bytecodes>`."
msgstr ""
"La documentation du :ref:`module dis <bytecodes>` fournit une liste des "
"instructions du code intermédiaire."

#: glossary.rst:243
msgid "callable"
msgstr "appelable (*callable*)"

#: glossary.rst:245
msgid ""
"A callable is an object that can be called, possibly with a set of arguments "
"(see :term:`argument`), with the following syntax::"
msgstr ""
"Un appelable est un objet qui peut être appelé, éventuellement avec un "
"ensemble d'arguments (voir  :term:`argument`), avec la syntaxe suivante ::"

#: glossary.rst:250
msgid ""
"A :term:`function`, and by extension a :term:`method`, is a callable. An "
"instance of a class that implements the :meth:`~object.__call__` method is "
"also a callable."
msgstr ""
"Une :term:`fonction <function>`, et par extension une :term:`méthode "
"<method>`, est un appelable. Une instance d'une classe qui implémente la "
"méthode :meth:`~object.__call__` est également un appelable."

#: glossary.rst:253
msgid "callback"
msgstr "fonction de rappel (*callback*)"

#: glossary.rst:255
msgid ""
"A subroutine function which is passed as an argument to be executed at some "
"point in the future."
msgstr ""
"Une fonction (classique, par opposition à une coroutine) passée en argument "
"pour être exécutée plus tard."

#: glossary.rst:257
msgid "class"
msgstr "classe"

#: glossary.rst:259
msgid ""
"A template for creating user-defined objects. Class definitions normally "
"contain method definitions which operate on instances of the class."
msgstr ""
"Modèle pour créer des objets définis par l'utilisateur. Une définition de "
"classe (*class*) contient normalement des définitions de méthodes qui "
"agissent sur les instances de la classe."

#: glossary.rst:262
msgid "class variable"
msgstr "variable de classe"

#: glossary.rst:264
msgid ""
"A variable defined in a class and intended to be modified only at class "
"level (i.e., not in an instance of the class)."
msgstr ""
"Une variable définie dans une classe et destinée à être modifiée uniquement "
"au niveau de la classe (c'est-à-dire, pas dans une instance de la classe)."

#: glossary.rst:266
#, fuzzy
msgid "closure variable"
msgstr "variable de classe"

#: glossary.rst:268
msgid ""
"A :term:`free variable` referenced from a :term:`nested scope` that is "
"defined in an outer scope rather than being resolved at runtime from the "
"globals or builtin namespaces. May be explicitly defined with "
"the :keyword:`nonlocal` keyword to allow write access, or implicitly defined "
"if the variable is only being read."
msgstr ""

#: glossary.rst:273
msgid ""
"For example, in the ``inner`` function in the following code, both ``x`` and "
"``print`` are :term:`free variables <free variable>`, but only ``x`` is a "
"*closure variable*::"
msgstr ""

#: glossary.rst:284
msgid ""
"Due to the :attr:`codeobject.co_freevars` attribute (which, despite its "
"name, only includes the names of closure variables rather than listing all "
"referenced free variables), the more general :term:`free variable` term is "
"sometimes used even when the intended meaning is to refer specifically to "
"closure variables."
msgstr ""

#: glossary.rst:288
msgid "complex number"
msgstr "nombre complexe"

#: glossary.rst:290
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 ""
"Extension des nombres réels familiers, dans laquelle tous les nombres sont "
"exprimés sous la forme d'une somme d'une partie réelle et d'une partie "
"imaginaire. Les nombres imaginaires sont les nombres réels multipliés par "
"l'unité imaginaire (la racine carrée de ``-1``, souvent écrite ``i`` en "
"mathématiques ou ``j`` par les ingénieurs). Python comprend 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 de :mod:`math`, utilisez :mod:`cmath`. "
"Les nombres complexes sont un concept assez avancé en mathématiques. Si vous "
"ne connaissez pas ce concept, vous pouvez tranquillement les ignorer."

#: glossary.rst:300
msgid "concurrency"
msgstr ""

#: glossary.rst:302
msgid ""
"The ability of a computer program to perform multiple tasks at the same "
"time.  Python provides libraries for writing programs that make use of "
"different forms of concurrency.  :mod:`asyncio` is a library for dealing "
"with asynchronous tasks and coroutines.  :mod:`threading` provides access to "
"operating system threads and :mod:`multiprocessing` to operating system "
"processes. Multi-core processors can execute threads and processes on "
"different CPU cores at the same time (see :term:`parallelism`)."
msgstr ""

#: glossary.rst:310
msgid "concurrent modification"
msgstr ""

#: glossary.rst:312
msgid ""
"When multiple threads modify shared data at the same time.  Concurrent "
"modification without proper synchronization can cause :term:`race conditions "
"<race condition>`, and might also trigger a :term:`data race <data race>`, "
"data corruption, or both."
msgstr ""

#: glossary.rst:316
#, fuzzy
msgid "context"
msgstr "gestionnaire de contexte"

#: glossary.rst:318
msgid ""
"This term has different meanings depending on where and how it is used. Some "
"common meanings:"
msgstr ""

#: glossary.rst:321
msgid ""
"The temporary state or environment established by a :term:`context manager` "
"via a :keyword:`with` statement."
msgstr ""

#: glossary.rst:323
msgid ""
"The collection of key­value bindings associated with a "
"particular :class:`contextvars.Context` object and accessed "
"via :class:`~contextvars.ContextVar` objects.  Also see :term:`context "
"variable`."
msgstr ""

#: glossary.rst:327
msgid ""
"A :class:`contextvars.Context` object.  Also see :term:`current context`."
msgstr ""

#: glossary.rst:329
#, fuzzy
msgid "context management protocol"
msgstr "gestionnaire de contexte"

#: glossary.rst:331
msgid ""
"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by "
"the :keyword:`with` statement.  See :pep:`343`."
msgstr ""

#: glossary.rst:333
msgid "context manager"
msgstr "gestionnaire de contexte"

#: glossary.rst:335
msgid ""
"An object which implements the :term:`context management protocol` and "
"controls the environment seen in a :keyword:`with` statement.  "
"See :pep:`343`."
msgstr ""

#: glossary.rst:338
msgid "context variable"
msgstr "variable de contexte"

#: glossary.rst:340
msgid ""
"A variable whose value depends on which context is the :term:`current "
"context`.  Values are accessed via :class:`contextvars.ContextVar` objects.  "
"Context variables are primarily used to isolate state between concurrent "
"asynchronous tasks."
msgstr ""

#: glossary.rst:344
msgid "contiguous"
msgstr "contigu"

#: glossary.rst:348
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 tampon (*buffer* en anglais) est considéré comme contigu s’il est soit *C-"
"contigu* soit *Fortran-contigu*. Les tampons 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, en 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. À l'inverse, dans les tableaux Fortran-contigu, c’est "
"le premier indice qui doit varier le plus rapidement."

#: glossary.rst:356
msgid "coroutine"
msgstr "coroutine"

#: glossary.rst:358
msgid ""
"Coroutines are 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ée des fonctions. On entre dans une "
"fonction en un point et on en sort en un autre point. On peut entrer, sortir "
"et reprendre l'exécution d'une coroutine en plusieurs points. Elles peuvent "
"être implémentées en utilisant l'instruction :keyword:`async def`. Voir "
"aussi la :pep:`492`."

#: glossary.rst:363
msgid "coroutine function"
msgstr "fonction coroutine"

#: glossary.rst:365
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 ""
"Fonction qui renvoie un objet :term:`coroutine`. Une fonction coroutine peut "
"être définie par l'instruction :keyword:`async def` et peut contenir les "
"mots clés :keyword:`await`, :keyword:`async for` ainsi que :keyword:`async "
"with`. A été introduit par la :pep:`492`."

#: glossary.rst:370
msgid "CPython"
msgstr "CPython"

#: glossary.rst:372
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*."

#: glossary.rst:376
msgid "current context"
msgstr ""

#: glossary.rst:378
msgid ""
"The :term:`context` (:class:`contextvars.Context` object) that is currently "
"used by :class:`~contextvars.ContextVar` objects to access (get or set) the "
"values of :term:`context variables <context variable>`.  Each thread has its "
"own current context.  Frameworks for executing asynchronous tasks "
"(see :mod:`asyncio`) associate each task with a context which becomes the "
"current context whenever the task starts or resumes execution."
msgstr ""

#: glossary.rst:384
msgid "cyclic isolate"
msgstr ""

#: glossary.rst:386
msgid ""
"A subgroup of one or more objects that reference each other in a reference "
"cycle, but are not referenced by objects outside the group.  The goal of "
"the :term:`cyclic garbage collector <garbage collection>` is to identify "
"these groups and break the reference cycles so that the memory can be "
"reclaimed."
msgstr ""

#: glossary.rst:390
msgid "data race"
msgstr ""

#: glossary.rst:392
msgid ""
"A situation where multiple threads access the same memory location "
"concurrently, at least one of the accesses is a write, and the threads do "
"not use any synchronization to control their access.  Data races lead "
"to :term:`non-deterministic` behavior and can cause data corruption. Proper "
"use of :term:`locks <lock>` and other :term:`synchronization primitives "
"<synchronization primitive>` prevents data races.  Note that data races can "
"only happen in native code, but that :term:`native code` might be exposed in "
"a Python API.  See also :term:`race condition` and :term:`thread-safe`."
msgstr ""

#: glossary.rst:401
msgid "deadlock"
msgstr ""

#: glossary.rst:403
msgid ""
"A situation in which two or more tasks (threads, processes, or coroutines) "
"wait indefinitely for each other to release resources or complete actions, "
"preventing any from making progress.  For example, if thread A holds lock 1 "
"and waits for lock 2, while thread B holds lock 2 and waits for lock 1, both "
"threads will wait indefinitely.  In Python this often arises from acquiring "
"multiple locks in conflicting orders or from circular join/await "
"dependencies.  Deadlocks can be avoided by always acquiring "
"multiple :term:`locks <lock>` in a consistent order.  See also :term:`lock` "
"and :term:`reentrant`."
msgstr ""

#: glossary.rst:412
msgid "decorator"
msgstr "décorateur"

#: glossary.rst:414
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 ""
"Fonction dont la valeur de retour est une autre fonction. Un décorateur est "
"habituellement utilisé pour transformer une fonction via la syntaxe "
"``@wrapper``, dont les exemples typiques sont : :func:`classmethod` "
"et :func:`staticmethod`."

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

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

#: glossary.rst:432
msgid "descriptor"
msgstr "descripteur"

#: glossary.rst:434
#, fuzzy
msgid ""
"Any object which defines the "
"methods :meth:`~object.__get__`, :meth:`~object.__set__`, "
"or :meth:`~object.__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. Normalement, lorsque vous "
"écrivez *a.b* pour obtenir, affecter ou effacer un attribut, Python "
"recherche l'objet nommé *b* dans le dictionnaire de la classe de *a*. Mais "
"si *b* est un descripteur, c'est la méthode de ce descripteur qui est alors "
"appelée. Comprendre les descripteurs est requis pour avoir 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 classes, méthodes "
"statiques et les références aux classes parentes."

#: glossary.rst:445
msgid ""
"For more information about descriptors' methods, see :ref:`descriptors` or "
"the :ref:`Descriptor How To Guide <descriptorhowto>`."
msgstr ""
"Pour plus d'informations sur les méthodes des descripteurs, "
"consultez :ref:`descriptors` ou le :ref:`guide pour l'utilisation des "
"descripteurs <descriptorhowto>`."

#: glossary.rst:447
msgid "dictionary"
msgstr "dictionnaire"

#: glossary.rst:449
#, fuzzy
msgid ""
"An associative array, where arbitrary keys are mapped to values.  The keys "
"can be any object with :meth:`~object.__hash__` and :meth:`~object.__eq__` "
"methods. Called a hash in Perl."
msgstr ""
"Structure de donnée associant des clés à des valeurs. Les clés peuvent être "
"n'importe quel objet possédant les méthodes :meth:`__hash__` "
"et :meth:`__eq__`. En Perl, les dictionnaires sont appelés \"*hash*\"."

#: glossary.rst:453
msgid "dictionary comprehension"
msgstr "dictionnaire en compréhension (ou dictionnaire en intension)"

#: glossary.rst:455
msgid ""
"A compact way to process all or part of the elements in an iterable and "
"return a dictionary with the results. ``results = {n: n ** 2 for n in "
"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n "
"** 2``. See :ref:`comprehensions`."
msgstr ""
"Écriture concise pour traiter tout ou partie des éléments d'un itérable et "
"renvoyer un dictionnaire contenant les résultats. ``results = {n: n ** 2 for "
"n in range(10)}`` génère un dictionnaire contenant des clés ``n`` liées à "
"leurs valeurs ``n ** 2``. Voir :ref:`compréhensions <comprehensions>`."

#: glossary.rst:459
msgid "dictionary view"
msgstr "vue de dictionnaire"

#: glossary.rst:461
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 ""
"Objets retournés par les méthodes :meth:`dict.keys`, :meth:`dict.values` "
"et :meth:`dict.items`. Ils fournissent des vues dynamiques des entrées du "
"dictionnaire, ce qui signifie que lorsque le dictionnaire change, la vue "
"change. Pour transformer une vue en vraie liste, utilisez "
"``list(dictview)``. Voir :ref:`dict-views`."

#: glossary.rst:467
msgid "docstring"
msgstr "chaîne de documentation (*docstring*)"

#: glossary.rst:469
#, fuzzy
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:`~definition.__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 ""
"Première chaîne littérale qui apparaît dans l'expression d'une classe, "
"fonction, ou module. Bien qu'ignorée à l'exécution, elle est reconnue par le "
"compilateur et placée dans l'attribut :attr:`__doc__` de la classe, de la "
"fonction ou du module. Comme cette chaîne est disponible par introspection, "
"c'est l'endroit idéal pour documenter l'objet."

#: glossary.rst:475
msgid "duck-typing"
msgstr "typage canard (*duck-typing*)"

#: glossary.rst:477
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 ""
"Style de programmation qui ne prend pas en compte le type d'un objet pour "
"déterminer s'il respecte une interface, mais qui appelle simplement la "
"méthode ou l'attribut (*Si ça a un bec et que ça cancane, ça doit être un "
"canard*, *duck* signifie canard en anglais). En se concentrant sur les "
"interfaces plutôt que les types, du code bien construit améliore sa "
"flexibilité en autorisant des substitutions polymorphiques. Le *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 abstraites <abstract base class>`. À la place, le "
"*duck-typing* utilise plutôt :func:`hasattr` ou la "
"programmation :term:`EAFP`."

#: glossary.rst:486
#, fuzzy
msgid "dunder"
msgstr "chercheur"

#: glossary.rst:488
msgid ""
"An informal short-hand for \"double underscore\", used when talking about "
"a :term:`special method`. For example, ``__init__`` is often pronounced "
"\"dunder init\"."
msgstr ""

#: glossary.rst:491
msgid "EAFP"
msgstr "EAFP"

#: glossary.rst:493
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* en anglais). Ce style de développement "
"Python fait l'hypothèse que le code est valide et traite les exceptions si "
"cette hypothèse s'avère fausse. Ce style, propre et efficace, est "
"caractérisé par la présence de beaucoup de mots clés :keyword:`try` "
"et :keyword:`except`. Cette technique de programmation contraste avec le "
"style :term:`LBYL` utilisé couramment dans les langages tels que C."

#: glossary.rst:499
#, fuzzy
msgid "evaluate function"
msgstr "fonction clé"

#: glossary.rst:501
msgid ""
"A function that can be called to evaluate a lazily evaluated attribute of an "
"object, such as the value of type aliases created with the :keyword:`type` "
"statement."
msgstr ""

#: glossary.rst:504
msgid "expression"
msgstr "expression"

#: glossary.rst:506
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:`while`.  Assignments are also statements, not "
"expressions."
msgstr ""
"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. On trouve également "
"des :term:`instructions <statement>` qui ne peuvent pas être utilisées comme "
"expressions, tel que :keyword:`while`. Les affectations sont également des "
"instructions et non des expressions."

#: glossary.rst:513
msgid "extension module"
msgstr "module d'extension"

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

#: glossary.rst:517
msgid "f-string"
msgstr "f-string"

#: glossary.rst:518
#, fuzzy
msgid "f-strings"
msgstr "f-string"

#: glossary.rst:520
#, fuzzy
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 ""
"Chaîne littérale préfixée de ``'f'`` ou ``'F'``. Les \"f-strings\" sont un "
"raccourci pour :ref:`formatted string literals <f-strings>`. Voir "
"la :pep:`498`."

#: glossary.rst:523
msgid "file object"
msgstr "objet fichier"

#: glossary.rst:525
#, fuzzy
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 ""
"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 "
"il a été créé, un objet fichier peut interfacer l'accès à 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, un connecteur "
"réseau…). Les objets fichiers sont aussi appelés :dfn:`file-like-objects` "
"ou :dfn:`streams`."

#: glossary.rst:533
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 "
"binaires <fichier binaire>` avec tampon (*buffer*) et les :term:`fichiers "
"textes <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`."

#: glossary.rst:538
msgid "file-like object"
msgstr "objet fichier-compatible"

#: glossary.rst:540
msgid "A synonym for :term:`file object`."
msgstr "Synonyme de :term:`objet fichier`."

#: glossary.rst:541
msgid "filesystem encoding and error handler"
msgstr "encodage du système de fichiers et gestionnaire d'erreurs associé"

#: glossary.rst:543
msgid ""
"Encoding and error handler used by Python to decode bytes from the operating "
"system and encode Unicode to the operating system."
msgstr ""
"Encodage et gestionnaire d'erreurs utilisés par Python pour décoder les "
"octets fournis par le système d'exploitation et encoder les chaînes de "
"caractères Unicode afin de les passer au système."

#: glossary.rst:546
msgid ""
"The filesystem encoding must guarantee to successfully decode all bytes "
"below 128. If the file system encoding fails to provide this guarantee, API "
"functions can raise :exc:`UnicodeError`."
msgstr ""
"L'encodage du système de fichiers doit impérativement pouvoir décoder tous "
"les octets jusqu'à 128. Si ce n'est pas le cas, certaines fonctions de l'API "
"lèvent :exc:`UnicodeError`."

#: glossary.rst:550
msgid ""
"The :func:`sys.getfilesystemencoding` "
"and :func:`sys.getfilesystemencodeerrors` functions can be used to get the "
"filesystem encoding and error handler."
msgstr ""
"Cet encodage et son gestionnaire d'erreur peuvent être obtenus à l'aide des "
"fonctions :func:`sys.getfilesystemencoding` "
"et :func:`sys.getfilesystemencodeerrors`."

#: glossary.rst:554
msgid ""
"The :term:`filesystem encoding and error handler` are configured at Python "
"startup by the :c:func:`PyConfig_Read` function: "
"see :c:member:`~PyConfig.filesystem_encoding` "
"and :c:member:`~PyConfig.filesystem_errors` members of :c:type:`PyConfig`."
msgstr ""
"L':term:`encodage du système de fichiers et gestionnaire d'erreurs associé "
"<filesystem encoding and error handler>` sont configurés au démarrage de "
"Python par la fonction :c:func:`PyConfig_Read` : "
"regardez :c:member:`~PyConfig.filesystem_encoding` "
"et :c:member:`~PyConfig.filesystem_errors` dans les membres "
"de :c:type:`PyConfig`."

#: glossary.rst:559
msgid "See also the :term:`locale encoding`."
msgstr "Voir aussi :term:`encodage régional<locale encoding>`."

#: glossary.rst:560
msgid "finder"
msgstr "chercheur"

#: glossary.rst:562
msgid ""
"An object that tries to find the :term:`loader` for a module that is being "
"imported."
msgstr ""
"Objet qui essaie de trouver un :term:`chargeur <loader>` pour le module en "
"cours d'importation."

#: glossary.rst:565
#, fuzzy
msgid ""
"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 chercheurs : "
"les :term:`chercheurs dans les méta-chemins <meta path finder>` à utiliser "
"avec :data:`sys.meta_path` ; les :term:`chercheurs d'entrée dans path <path "
"entry finder>` à utiliser avec :data:`sys.path_hooks`."

#: glossary.rst:569
#, fuzzy
msgid ""
"See :ref:`finders-and-loaders` and :mod:`importlib` for much more detail."
msgstr "Voir les :pep:`302`, :pep:`420` et :pep:`451` pour plus de détails."

#: glossary.rst:570
msgid "floor division"
msgstr "division entière"

#: glossary.rst:572
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 inférieur. 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 à l'entier inférieur. Voir "
"la :pep:`328`."

#: glossary.rst:577
msgid "free threading"
msgstr ""

#: glossary.rst:579
msgid ""
"A threading model where multiple threads can run Python bytecode "
"simultaneously within the same interpreter.  This is in contrast to "
"the :term:`global interpreter lock` which allows only one thread to execute "
"Python bytecode at a time.  See :pep:`703`."
msgstr ""

#: glossary.rst:583
msgid "free-threaded build"
msgstr ""

#: glossary.rst:586
msgid ""
"A build of :term:`CPython` that supports :term:`free threading`, configured "
"using the :option:`--disable-gil` option before compilation."
msgstr ""

#: glossary.rst:589
msgid "See :ref:`freethreading-python-howto`."
msgstr ""

#: glossary.rst:590
#, fuzzy
msgid "free variable"
msgstr "variable de contexte"

#: glossary.rst:592
msgid ""
"Formally, as defined in the :ref:`language execution model <bind_names>`, a "
"free variable is any variable used in a namespace which is not a local "
"variable in that namespace. See :term:`closure variable` for an example. "
"Pragmatically, due to the name of the :attr:`codeobject.co_freevars` "
"attribute, the term is also sometimes used as a synonym for :term:`closure "
"variable`."
msgstr ""

#: glossary.rst:597
msgid "function"
msgstr "fonction"

#: glossary.rst:599
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 ""
"Suite d'instructions qui renvoie une valeur à son appelant. On peut 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`."

#: glossary.rst:603
msgid "function annotation"
msgstr "annotation de fonction"

#: glossary.rst:605
msgid "An :term:`annotation` of a function parameter or return value."
msgstr ":term:`annotation` d'un paramètre de fonction ou valeur de retour."

#: glossary.rst:607
msgid ""
"Function annotations are usually used for :term:`type hints <type hint>`: "
"for example, this function is expected to take two :class:`int` arguments "
"and is also expected to have an :class:`int` return value::"
msgstr ""
"Les annotations de fonctions sont généralement utilisées pour "
"des :term:`indications de types <type hint>` : par exemple, cette fonction "
"devrait prendre deux arguments :class:`int` et devrait également avoir une "
"valeur de retour de type :class:`int` ::"

#: glossary.rst:615
msgid "Function annotation syntax is explained in section :ref:`function`."
msgstr ""
"L'annotation syntaxique de la fonction est expliquée dans la "
"section :ref:`function`."

#: glossary.rst:617
msgid ""
"See :term:`variable annotation` and :pep:`484`, which describe this "
"functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"Voir :term:`annotation de variable<variable annotation>` et la :pep:`484`, "
"qui décrivent cette fonctionnalité. Voir aussi :ref:`annotations-howto` sur "
"les bonnes pratiques concernant les annotations."

#: glossary.rst:621
msgid "__future__"
msgstr "__future__"

#: glossary.rst:623
msgid ""
"A :ref:`future statement <future>`, ``from __future__ import <feature>``, "
"directs the compiler to compile the current module using syntax or semantics "
"that will become standard in a future release of Python. "
"The :mod:`__future__` module documents the possible values of *feature*.  By "
"importing this module and evaluating its variables, you can see when a new "
"feature was first added to the language and when it will (or did) become the "
"default::"
msgstr ""
"Une :ref:`importation depuis le futur <future>` s'écrit ``from __future__ "
"import <fonctionnalité>``. Lorsqu'une importation du futur est active dans "
"un module, Python compile ce module avec une certaine modification de la "
"syntaxe ou du comportement qui est vouée à devenir standard dans une version "
"ultérieure. Le module :mod:`__future__` documente les possibilités pour "
"*fonctionnalité*. L'importation a aussi l'effet normal d'importer une "
"variable du module. Cette variable contient des informations utiles sur la "
"fonctionnalité en question, notamment la version de Python dans laquelle "
"elle a été ajoutée, et celle dans laquelle elle deviendra standard ::"

#: glossary.rst:634
msgid "garbage collection"
msgstr "ramasse-miettes"

#: glossary.rst:636
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* en anglais) 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. Le ramasse-miettes peut être contrôlé "
"en utilisant le module :mod:`gc`."

#: glossary.rst:642
msgid "generator"
msgstr "générateur"

#: glossary.rst:644
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 ""
"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` produisant une série de valeurs utilisable dans "
"une boucle *for* ou récupérées une à une via la fonction :func:`next`."

#: glossary.rst:649
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 référence à une fonction génératrice mais peut faire "
"référence à 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 lève "
"l’ambiguïté."

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

#: glossary.rst:654
msgid "An object created by a :term:`generator` function."
msgstr "Objet créé par une fonction :term:`générateur`."

#: glossary.rst:656
#, fuzzy
msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"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, en se rappelant "
"l'endroit et l'état de l'exécution (y compris les variables locales et les "
"*try* en cours). Lorsque l'itérateur de générateur reprend, il repart là où "
"il en était (contrairement à une fonction qui prendrait un nouveau départ à "
"chaque invocation)."

#: glossary.rst:663
msgid "generator expression"
msgstr "expression génératrice"

#: glossary.rst:665
#, fuzzy
msgid ""
"An :term:`expression` that returns an :term:`iterator`.  It looks like a "
"normal expression followed by a :keyword:`!for` clause defining a loop "
"variable, range, and an optional :keyword:`!if` clause.  The combined "
"expression generates values for an enclosing function::"
msgstr ""
"Expression qui donne un itérateur. Elle ressemble à une expression normale, "
"suivie d'une clause :keyword:`!for` définissant une variable de boucle, un "
"intervalle et une clause :keyword:`!if` optionnelle. Toute cette expression "
"génère des valeurs pour la fonction qui l'entoure ::"

#: glossary.rst:672
msgid "generic function"
msgstr "fonction générique"

#: glossary.rst:674
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 ""
"Fonction composée de plusieurs fonctions implémentant les mêmes opérations "
"pour différents types. L'implémentation à utiliser est déterminée lors de "
"l'appel par l'algorithme de répartition."

#: glossary.rst:678
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`."

#: glossary.rst:680
msgid "generic type"
msgstr "type générique"

#: glossary.rst:682
msgid ""
"A :term:`type` that can be parameterized; typically a :ref:`container "
"class<sequence-types>` such as :class:`list` or :class:`dict`. Used "
"for :term:`type hints <type hint>` and :term:`annotations <annotation>`."
msgstr ""
"Un :term:`type` qui peut être paramétré ; généralement un :ref:`conteneur "
"<sequence-types>` comme :class:`list` ou :class:`dict`. Utilisé pour "
"les :term:`indications de type <type hint>` et les :term:`annotations "
"<annotation>`."

#: glossary.rst:687
msgid ""
"For more details, see :ref:`generic alias types<types-"
"genericalias>`, :pep:`483`, :pep:`484`, :pep:`585`, and the :mod:`typing` "
"module."
msgstr ""
"Pour plus de détails, voir :ref:`types alias génériques <types-"
"genericalias>` et le module :mod:`typing`.  On trouvera l'historique de "
"cette fonctionnalité dans les :pep:`483`, :pep:`484` et :pep:`585`."

#: glossary.rst:689
msgid "GIL"
msgstr "GIL"

#: glossary.rst:691
msgid "See :term:`global interpreter lock`."
msgstr "Voir :term:`global interpreter lock`."

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

#: glossary.rst:694
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 ""
"(*global interpreter lock* en anglais) Mécanisme utilisé par "
"l'interpréteur :term:`CPython` pour s'assurer qu'un seul fil d'exécution "
"(*thread* en anglais) n'exécute le :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é contre les accès concourants. Verrouiller l'interpréteur entier rend "
"plus facile l'implémentation de multiples fils d'exécution (*multi-thread* "
"en anglais), au détriment malheureusement de beaucoup du parallélisme "
"possible sur les machines ayant plusieurs processeurs."

#: glossary.rst:703
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 conçus de "
"manière à libérer le GIL lorsqu'ils effectuent des tâches lourdes tel que la "
"compression ou le hachage. De la même manière, le GIL est toujours libéré "
"lors des entrées-sorties."

#: glossary.rst:708
msgid ""
"As of Python 3.13, the GIL can be disabled using the :option:`--disable-gil` "
"build configuration. After building Python with this option, code must be "
"run with :option:`-X gil=0 <-X>` or after setting the :envvar:`PYTHON_GIL=0 "
"<PYTHON_GIL>` environment variable. This feature enables improved "
"performance for multi-threaded applications and makes it easier to use multi-"
"core CPUs efficiently. For more details, see :pep:`703`."
msgstr ""

#: glossary.rst:715
msgid ""
"In prior versions of Python's C API, a function might declare that it "
"requires the GIL to be held in order to use it. This refers to having "
"an :term:`attached thread state`."
msgstr ""

#: glossary.rst:718
msgid "global state"
msgstr ""

#: glossary.rst:720
msgid ""
"Data that is accessible throughout a program, such as module-level "
"variables, class variables, or C static variables in :term:`extension "
"modules <extension module>`.  In multi-threaded programs, global state "
"shared between threads typically requires synchronization to "
"avoid :term:`race conditions <race condition>` and :term:`data races <data "
"race>`."
msgstr ""

#: glossary.rst:726
msgid "hash-based pyc"
msgstr "*pyc* utilisant le hachage"

#: glossary.rst:728
msgid ""
"A bytecode cache file that uses the hash rather than the last-modified time "
"of the corresponding source file to determine its validity. See :ref:`pyc-"
"invalidation`."
msgstr ""
"Un fichier de cache de code intermédiaire (*bytecode* en anglais) qui "
"utilise le hachage plutôt que l'heure de dernière modification du fichier "
"source correspondant pour déterminer sa validité. Voir :ref:`pyc-"
"invalidation`."

#: glossary.rst:731
msgid "hashable"
msgstr "hachable"

#: glossary.rst:733
#, fuzzy
msgid ""
"An object is *hashable* if it has a hash value which never changes during "
"its lifetime (it needs a :meth:`~object.__hash__` method), and can be "
"compared to other objects (it needs an :meth:`~object.__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 "
"(il doit donc implémenter une méthode :meth:`__hash__`) et s'il peut être "
"comparé à d'autres objets (avec la méthode :meth:`__eq__`). Les objets "
"hachables dont la comparaison par ``__eq__`` est vraie doivent avoir la même "
"empreinte."

#: glossary.rst:739
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 clé de dictionnaire ou "
"en tant que membre d'un ensemble (type *set*), car ces structures de données "
"utilisent ce *hash*."

#: glossary.rst:742
msgid ""
"Most of Python's immutable built-in objects are hashable; mutable containers "
"(such as lists or dictionaries) are not; immutable containers (such as "
"tuples and frozensets) are only hashable if their elements are hashable.  "
"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 ""
"La plupart des types immuables natifs de Python sont hachables, mais les "
"conteneurs mutables (comme les listes ou les dictionnaires) ne le sont pas ; "
"les conteneurs immuables (comme les n-uplets ou les ensembles figés) ne sont "
"hachables que si leurs éléments sont hachables. 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 valeur de hachage "
"est calculée à partir de leur :func:`id`."

#: glossary.rst:749
msgid "IDLE"
msgstr "IDLE"

#: glossary.rst:751
msgid ""
"An Integrated Development and Learning Environment for Python. :ref:`idle` "
"is a basic editor and interpreter environment which ships with the standard "
"distribution of Python."
msgstr ""
"Environnement d'apprentissage et de développement intégré pour "
"Python. :ref:`IDLE <idle>` est un éditeur basique et un interpréteur livré "
"avec la distribution standard de Python."

#: glossary.rst:754
msgid "immortal"
msgstr ""

#: glossary.rst:756
msgid ""
"*Immortal objects* are a CPython implementation detail introduced "
"in :pep:`683`."
msgstr ""

#: glossary.rst:759
msgid ""
"If an object is immortal, its :term:`reference count` is never modified, and "
"therefore it is never deallocated while the interpreter is running. For "
"example, :const:`True` and :const:`None` are immortal in CPython."
msgstr ""

#: glossary.rst:763
msgid ""
"Immortal objects can be identified via :func:`sys._is_immortal`, or "
"via :c:func:`PyUnstable_IsImmortal` in the C API."
msgstr ""

#: glossary.rst:765
msgid "immutable"
msgstr "immuable"

#: glossary.rst:767
#, fuzzy
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.  Immutable objects are inherently :term:`thread-safe` because "
"their state cannot be modified after creation, eliminating concerns about "
"improperly synchronized :term:`concurrent modification`."
msgstr ""
"Objet dont la valeur ne change pas. Les nombres, les chaînes et les *n*-"
"uplets 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 quand une valeur de *hash* constante est requise, typiquement en "
"clé de dictionnaire."

#: glossary.rst:774
msgid "import path"
msgstr "chemin des importations"

#: glossary.rst:776
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 ""
"Liste de :term:`entrées <path entry>` dans lesquelles le :term:`chercheur "
"basé sur les chemins <path based finder>` cherche les modules à importer. "
"Typiquement, lors d'une importation, cette liste vient de :data:`sys.path` ; "
"pour les sous-paquets, elle peut aussi venir de l'attribut ``__path__`` du "
"paquet parent."

#: glossary.rst:781
msgid "importing"
msgstr "importation"

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

#: glossary.rst:785
msgid "importer"
msgstr "importateur"

#: glossary.rst:787
msgid ""
"An object that both finds and loads a module; both a :term:`finder` "
"and :term:`loader` object."
msgstr ""
"Objet qui trouve et charge un module, en même temps un :term:`chercheur "
"<finder>` et un :term:`chargeur <loader>`."

#: glossary.rst:789
#, fuzzy
msgid "index"
msgstr "chercheur"

#: glossary.rst:791
msgid ""
"A numeric value that represents the position of an element in "
"a :term:`sequence`."
msgstr ""

#: glossary.rst:794
msgid ""
"In Python, indexing starts at zero. For example, ``things[0]`` names the "
"*first* element of ``things``; ``things[1]`` names the second one."
msgstr ""

#: glossary.rst:798
msgid ""
"In some contexts, Python allows negative indexes for counting from the end "
"of a sequence, and indexing using :term:`slices <slice>`."
msgstr ""

#: glossary.rst:801
#, fuzzy
msgid "See also :term:`subscript`."
msgstr "Voir aussi :term:`module`."

#: glossary.rst:802
msgid "interactive"
msgstr "interactif"

#: glossary.rst:804
#, fuzzy
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)``). "
"For more on interactive mode, see :ref:`tut-interac`."
msgstr ""
"Python a un interpréteur :term:`interactif <interactive>`, ce qui signifie "
"que vous pouvez écrire des expressions et des instructions à l'invite de "
"l'interpréteur. L'interpréteur Python va les exécuter immédiatement et vous "
"en présenter le résultat. Démarrez juste ``python`` (probablement depuis le "
"menu principal de votre ordinateur). C'est un moyen puissant pour tester de "
"nouvelles idées ou étudier de nouveaux modules (souvenez-vous de "
"``help(x)``)."

#: glossary.rst:811
msgid "interpreted"
msgstr "interprété"

#: glossary.rst:813
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 en raison de la présence d'un compilateur en "
"code intermédiaire. 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és ont généralement un cycle de "
"développement / débogage plus court que les langages compilés. Cependant, "
"ils s'exécutent généralement plus lentement. Voir aussi :term:`interactif "
"<interactive>`."

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

#: glossary.rst:822
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 des exceptions puisque les "
"ressources auxquelles il fait appel sont susceptibles de ne plus "
"fonctionner, (typiquement les modules des bibliothèques ou le mécanisme de "
"*warning*)."

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

#: glossary.rst:833
msgid "iterable"
msgstr "itérable"

#: glossary.rst:835
#, fuzzy
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:`~object.__iter__` method or with "
"a :meth:`~object.__getitem__` method that implements :term:`sequence` "
"semantics."
msgstr ""
"Objet capable de renvoyer ses éléments un à un. Par exemple, tous les types "
"de séquences (comme :class:`list`, :class:`str`, et :class:`tuple`), "
"quelques autres types comme :class:`dict`, les :term:`objets fichiers <file "
"object>` ou tout objet d'une classe ayant une méthode :meth:`__iter__` "
"ou :meth:`__getitem__` qui implémente la sémantique d'une :term:`séquence "
"<sequence>`."

#: glossary.rst:843
#, fuzzy
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 :keyword:`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` et à "
"beaucoup d'autres endroits où une séquence est requise "
"(:func:`zip`, :func:`map`…). Lorsqu'un itérable est passé comme argument à "
"la fonction native :func:`iter`, celle-ci fournit en retour un itérateur sur "
"cet itérable. Cet itérateur n'est valable que pour une seule 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 soi-même des objets "
"itérateurs. L'instruction ``for`` le fait 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`."

#: glossary.rst:853
msgid "iterator"
msgstr "itérateur"

#: glossary.rst:855
#, fuzzy
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:`~iterator.__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 ""
"Objet représentant un flux de donnée. Des appels successifs à la "
"méthode :meth:`~iterator.__next__` de l'itérateur (ou le passer à la "
"fonction native :func:`next`) donne successivement les objets du flux. "
"Lorsque plus aucune donnée n'est disponible, une "
"exception :exc:`StopIteration` est levée. À ce point, l'itérateur est épuisé "
"et tous les appels suivants à sa méthode :meth:`__next__` lèveront encore "
"une exception :exc:`StopIteration`. Les itérateurs doivent avoir une "
"méthode :meth:`__iter__` qui renvoie l'objet itérateur lui-même, de façon à "
"ce 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 est un code qui tente plusieurs itérations complètes. Un objet "
"conteneur, (tel que :class:`list`) produit un nouvel itérateur neuf à chaque "
"fois qu'il est passé à la fonction :func:`iter` ou s'il est utilisé dans une "
"boucle :keyword:`for`. Faire ceci sur un itérateur donnerait simplement le "
"même objet itérateur épuisé utilisé dans son itération précédente, le "
"faisant ressembler à un conteneur vide."

#: glossary.rst:870
msgid "More information can be found in :ref:`typeiter`."
msgstr "Vous trouverez davantage d'informations dans :ref:`typeiter`."

#: glossary.rst:874
#, fuzzy
msgid ""
"CPython does not consistently apply the requirement that an iterator "
"define :meth:`~iterator.__iter__`. And also please note that :term:`free-"
"threaded <free threading>` CPython does not guarantee :term:`thread-safe` "
"behavior of iterator operations."
msgstr ""
"CPython n'est pas toujours cohérent sur le fait de demander ou non à un "
"itérateur de définir :meth:`__iter__`."

#: glossary.rst:879
msgid "key"
msgstr ""

#: glossary.rst:881
msgid ""
"A value that identifies an entry in a :term:`mapping`. See "
"also :term:`subscript`."
msgstr ""

#: glossary.rst:883
msgid "key function"
msgstr "fonction clé"

#: glossary.rst:885
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 clé est un objet appelable qui renvoie une valeur à fins de tri "
"ou de classement. Par exemple, la fonction :func:`locale.strxfrm` est "
"utilisée pour générer une clé de classement prenant en compte les "
"conventions de classement spécifiques aux paramètres régionaux courants."

#: glossary.rst:890
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 clés pour déterminer "
"comment les éléments sont classés ou groupés. On peut citer les "
"fonctions :func:`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq.nlargest` "
"et :func:`itertools.groupby`."

#: glossary.rst:896
#, fuzzy
msgid ""
"There are several ways to create a key function.  For example. "
"the :meth:`str.casefold` 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, :func:`operator.attrgetter`, :func:`operator.itemgetter`, "
"and :func:`operator.methodcaller` are three key function constructors.  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 clé. Par exemple, la "
"méthode :meth:`str.lower` peut servir de fonction clé pour effectuer des "
"recherches insensibles à la casse. Aussi, il est possible de créer des "
"fonctions clés avec des expressions :keyword:`lambda`, comme ``lambda r: "
"(r[0], r[2])``. Par "
"ailleurs :func:`~operator.attrgetter`, :func:`~operator.itemgetter` "
"et :func:`~operator.methodcaller` permettent de créer des fonctions clés. "
"Voir :ref:`le guide pour le tri <sortinghowto>` pour des exemples de "
"création et d'utilisation de fonctions clefs."

#: glossary.rst:903
msgid "keyword argument"
msgstr "argument nommé"

#: glossary.rst:1292
msgid "See :term:`argument`."
msgstr "Voir :term:`argument`."

#: glossary.rst:906
msgid "lambda"
msgstr "lambda"

#: glossary.rst:908
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 [parameters]: expression``"
msgstr ""
"Fonction anonyme sous la forme d'une :term:`expression` et ne contenant "
"qu'une seule expression, exécutée lorsque la fonction est appelée. La "
"syntaxe pour créer des fonctions lambda est : ``lambda [parameters]: "
"expression``"

#: glossary.rst:911
msgid "LBYL"
msgstr "LBYL"

#: glossary.rst:913
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 avant de sauter, (*Look before you leap* en anglais). 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`."

#: glossary.rst:918
#, fuzzy
msgid ""
"In a multi-threaded environment, the LBYL approach can risk introducing "
"a :term:`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 :term:`locks <lock>` or by using "
"the :term:`EAFP` approach.  See also :term:`thread-safe`."
msgstr ""
"Dans un environnement avec plusieurs fils d'exécution (*multi-threaded* en "
"anglais), le style *LBYL* peut engendrer un séquencement critique (*race "
"condition* en anglais) entre le \"regarde\" et le \"sauter\". Par exemple, "
"le code ``if key in mapping: return mapping[key]`` peut échouer si un autre "
"fil d'exécution supprime la clé *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."

#: glossary.rst:924
msgid "lexical analyzer"
msgstr ""

#: glossary.rst:927
msgid "Formal name for the *tokenizer*; see :term:`token`."
msgstr ""

#: glossary.rst:928
msgid "list"
msgstr "liste"

#: glossary.rst:930
#, fuzzy
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 is "
"*O*\\ (1)."
msgstr ""
"Un type natif de :term:`sequence` dans Python. En dépit de son nom, une "
"``list`` ressemble plus à un tableau (*array* dans la plupart des langages) "
"qu'à une liste chaînée puisque les accès se font en O(1)."

#: glossary.rst:933
msgid "list comprehension"
msgstr "liste en compréhension (ou liste en intension)"

#: glossary.rst:935
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 ""
"Écriture concise pour manipuler tout ou partie des éléments d'une séquence "
"et renvoyer une liste contenant les résultats. ``result = "
"['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]`` génère la liste "
"composée des nombres pairs de 0 à 255 écrits sous formes de chaînes de "
"caractères et en hexadécimal (``0x…``). La clause :keyword:`if` est "
"optionnelle. Si elle est omise, tous les éléments du ``range(256)`` seront "
"utilisés."

#: glossary.rst:941
msgid "lock"
msgstr ""

#: glossary.rst:943
msgid ""
"A :term:`synchronization primitive` that allows only one thread at a time to "
"access a shared resource.  A thread must acquire a lock before accessing the "
"protected resource and release it afterward.  If a thread attempts to "
"acquire a lock that is already held by another thread, it will block until "
"the lock becomes available.  Python's :mod:`threading` module "
"provides :class:`~threading.Lock` (a basic lock) "
"and :class:`~threading.RLock` (a :term:`reentrant` lock).  Locks are used to "
"prevent :term:`race conditions <race condition>` and ensure :term:`thread-"
"safe` access to shared data.  Alternative design patterns to locks exist "
"such as queues, producer/consumer patterns, and thread-local state. See "
"also :term:`deadlock`, and :term:`reentrant`."
msgstr ""

#: glossary.rst:954
msgid "lock-free"
msgstr ""

#: glossary.rst:956
msgid ""
"An operation that does not acquire any :term:`lock` and uses atomic CPU "
"instructions to ensure correctness. Lock-free operations can execute "
"concurrently without blocking each other and cannot be blocked by operations "
"that hold locks. In :term:`free-threaded <free threading>` Python, built-in "
"types like :class:`dict` and :class:`list` provide lock-free read "
"operations, which means other threads may observe intermediate states during "
"multi-step modifications even when those modifications hold the :term:`per-"
"object lock`."
msgstr ""

#: glossary.rst:964
msgid "loader"
msgstr "chargeur"

#: glossary.rst:966
#, fuzzy
msgid ""
"An object that loads a module. It must define the :meth:`!exec_module` "
"and :meth:`!create_module` methods to implement "
"the :class:`~importlib.abc.Loader` interface. A loader is typically returned "
"by a :term:`finder`. See also:"
msgstr ""
"Objet qui charge un module. Il doit définir une méthode "
"nommée :meth:`load_module`. Un chargeur est typiquement donné par "
"un :term:`chercheur <finder>`. Voir la :pep:`302` pour plus de détails "
"et :class:`importlib.ABC.Loader` pour sa :term:`classe abstraite "
"<abstract base class>`."

#: glossary.rst:972
msgid ":ref:`finders-and-loaders`"
msgstr ""

#: glossary.rst:973
msgid ":class:`importlib.abc.Loader`"
msgstr ""

#: glossary.rst:974
#, fuzzy
msgid ":pep:`302`"
msgstr "Voir la :pep:`1`."

#: glossary.rst:975
msgid "locale encoding"
msgstr "encodage régional"

#: glossary.rst:977
msgid ""
"On Unix, it is the encoding of the LC_CTYPE locale. It can be set "
"with :func:`locale.setlocale(locale.LC_CTYPE, new_locale) "
"<locale.setlocale>`."
msgstr ""
"Sous Unix, il est défini par la variable régionale LC_CTYPE. Il peut être "
"modifié par :func:`locale.setlocale(locale.LC_CTYPE, new_locale) "
"<locale.setlocale>`."

#: glossary.rst:980
msgid "On Windows, it is the ANSI code page (ex: ``\"cp1252\"``)."
msgstr "Sous Windows, c'est un encodage ANSI (par ex. : ``\"cp1252\"``)."

#: glossary.rst:982
msgid ""
"On Android and VxWorks, Python uses ``\"utf-8\"`` as the locale encoding."
msgstr ""
"Sous Android et VxWorks, Python utilise ``\"utf-8\"`` comme encodage "
"régional."

#: glossary.rst:984
#, fuzzy
msgid ":func:`locale.getencoding` can be used to get the locale encoding."
msgstr "``locale.getencoding()`` permet de récupérer l'encodage régional."

#: glossary.rst:986
msgid "See also the :term:`filesystem encoding and error handler`."
msgstr ""
"Voir aussi l':term:`encodage du systèmes de fichiers et gestionnaire "
"d'erreurs associé <filesystem encoding and error handler>`."

#: glossary.rst:987
msgid "magic method"
msgstr "méthode magique"

#: glossary.rst:991
msgid "An informal synonym for :term:`special method`."
msgstr "Un synonyme informel de :term:`special method`."

#: glossary.rst:992
msgid "mapping"
msgstr "tableau de correspondances (*mapping* en anglais)"

# Obligé de garder l'ordre des références...
#: glossary.rst:994
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 ""
"Conteneur permettant de rechercher des éléments à partir de clés et "
"implémentant les méthodes spécifiées dans les classes abstraites "
"des :class:`tableaux de correspondances <collections.abc.Mapping>` "
"(immuables) ou :class:`tableaux de correspondances mutables "
"<collections.abc.MutableMapping>` (voir les :ref:`classes abstraites "
"<collections-abstract-base-classes>`). Les classes suivantes sont des "
"exemples de tableaux de "
"correspondances : :class:`dict`, :class:`collections.defaultdict`, :class:`collections.OrderedDict` "
"et :class:`collections.Counter`."

#: glossary.rst:1000
msgid "meta path finder"
msgstr "chercheur dans les méta-chemins"

#: glossary.rst:1002
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:`chercheur <finder>` renvoyé par une recherche "
"dans :data:`sys.meta_path`. Les chercheurs dans les méta-chemins "
"ressemblent, mais sont différents des :term:`chercheurs d'entrée dans path "
"<path entry finder>`."

#: glossary.rst:1006
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 "
"chercheurs dans les méta-chemins doivent implémenter."

#: glossary.rst:1008
msgid "metaclass"
msgstr "métaclasse"

#: glossary.rst:1010
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 ""
"Classe d'une classe. Les définitions de classe créent un nom pour la classe, "
"un dictionnaire de classe et une liste de classes parentes. 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. La particularité de Python est la possibilité de créer des "
"métaclasses personnalisées. La plupart des utilisateurs n'auront jamais "
"besoin de cet outil, mais lorsque le besoin survient, les métaclasses "
"offrent des solutions élégantes et puissantes. Elles sont utilisées pour "
"journaliser les accès à des propriétés, rendre sûrs les environnements "
"*multi-threads*, suivre la création d'objets, implémenter des singletons et "
"bien d'autres tâches."

#: glossary.rst:1020
msgid "More information can be found in :ref:`metaclasses`."
msgstr "Plus d'informations sont disponibles dans : :ref:`metaclasses`."

#: glossary.rst:1021
msgid "method"
msgstr "méthode"

#: glossary.rst:1023
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 ""
"Fonction définie à l'intérieur d'une classe. Lorsqu'elle est appelée comme "
"un attribut d'une instance de cette classe, la méthode reçoit l'instance en "
"premier :term:`argument` (qui, par convention, est habituellement nommé "
"``self``). Voir :term:`function` et :term:`nested scope`."

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

#: glossary.rst:1029
#, fuzzy
msgid ""
"Method Resolution Order is the order in which base classes are searched for "
"a member during lookup. See :ref:`python_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* pour *Method Resolution Order* en "
"anglais) est, lors de la recherche d'un attribut dans les classes parentes, "
"la façon dont l'interpréteur Python classe ces 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."

#: glossary.rst:1032
msgid "module"
msgstr "module"

#: glossary.rst:1034
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 ""
"Objet utilisé pour organiser une portion unitaire de code en Python. Les "
"modules ont un espace de nommage et peuvent contenir n'importe quels objets "
"Python. Charger des modules est appelé :term:`importer <importing>`."

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

#: glossary.rst:1039
msgid "module spec"
msgstr "spécificateur de module"

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

#: glossary.rst:1044
#, fuzzy
msgid "See also :ref:`module-specs`."
msgstr "Voir aussi :term:`module`."

#: glossary.rst:1045
msgid "MRO"
msgstr "MRO"

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

#: glossary.rst:1048
msgid "mutable"
msgstr "mutable"

#: glossary.rst:1050
msgid ""
"An :term:`object` with state that is allowed to change during the course of "
"the program.  In multi-threaded programs, mutable objects that are shared "
"between threads require careful synchronization to avoid :term:`race "
"conditions <race condition>`.  See also :term:`immutable`, :term:`thread-"
"safe`, and :term:`concurrent modification`."
msgstr ""

#: glossary.rst:1055
msgid "named tuple"
msgstr "*n*-uplet nommé"

#: glossary.rst:1057
msgid ""
"The term \"named tuple\" applies to any type or class that inherits from "
"tuple and whose indexable elements are also accessible using named "
"attributes.  The type or class may have other features as well."
msgstr ""
"Le terme \"n-uplet nommé\" s'applique à tous les types ou classes qui "
"héritent de la classe ``tuple`` et dont les éléments indexables sont aussi "
"accessibles en utilisant des attributs nommés. Les types et classes peuvent "
"avoir aussi d'autres caractéristiques."

#: glossary.rst:1061
msgid ""
"Several built-in types are named tuples, including the values returned "
"by :func:`time.localtime` and :func:`os.stat`.  Another example "
"is :data:`sys.float_info`::"
msgstr ""
"Plusieurs types natifs sont appelés n-uplets, y compris les valeurs "
"retournées par :func:`time.localtime` et :func:`os.stat`. Un autre exemple "
"est :data:`sys.float_info` ::"

#: glossary.rst:1072
#, fuzzy
msgid ""
"Some named tuples are built-in types (such as the above examples). "
"Alternatively, a named tuple can be created from a regular class definition "
"that inherits from :class:`tuple` and that defines named fields.  Such a "
"class can be written by hand, or it can be created by "
"inheriting :class:`typing.NamedTuple`, or with the factory "
"function :func:`collections.namedtuple`.  The latter techniques also add "
"some extra methods that may not be found in hand-written or built-in named "
"tuples."
msgstr ""
"Certains *n-uplets nommés* sont des types natifs (comme les exemples ci-"
"dessus). Sinon, un *n-uplet nommé* peut être créé à partir d'une définition "
"de classe habituelle qui hérite de :class:`tuple` et qui définit les champs "
"nommés. Une telle classe peut être écrite à la main ou être créée avec la "
"fonction :func:`collections.namedtuple`. Cette dernière méthode ajoute des "
"méthodes supplémentaires qui ne seront pas trouvées dans celles écrites à la "
"main ni dans les n-uplets nommés natifs."

#: glossary.rst:1080
msgid "namespace"
msgstr "espace de nommage"

#: glossary.rst:1082
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 nommage sont "
"implémentés avec des dictionnaires. Il existe des espaces de nommage "
"globaux, natifs ou imbriqués dans les objets (dans les méthodes). Les "
"espaces de nommage favorisent la modularité car ils permettent 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 nommage aident aussi à la lisibilité et la maintenabilité en rendant "
"clair quel module implémente une fonction. Par exemple, "
"écrire :func:`random.seed` ou :func:`itertools.islice` affiche clairement "
"que ces fonctions sont implémentées respectivement dans les "
"modules :mod:`random` et :mod:`itertools`."

#: glossary.rst:1092
msgid "namespace package"
msgstr "paquet-espace de nommage"

#: glossary.rst:1094
#, fuzzy
msgid ""
"A :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 nommage 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``."

#: glossary.rst:1099
msgid ""
"Namespace packages allow several individually installable packages to have a "
"common parent package. Otherwise, it is recommended to use a :term:`regular "
"package`."
msgstr ""

#: glossary.rst:1102
msgid ""
"For more information, see :pep:`420` and :ref:`reference-namespace-package`."
msgstr ""

#: glossary.rst:1104
msgid "See also :term:`module`."
msgstr "Voir aussi :term:`module`."

#: glossary.rst:1105
#, fuzzy
msgid "native code"
msgstr "code intermédiaire (*bytecode*)"

#: glossary.rst:1107
msgid ""
"Code that is compiled to machine instructions and runs directly on the "
"processor, as opposed to code that is interpreted or runs in a virtual "
"machine.  In the context of Python, native code typically refers to C, C++, "
"Rust or Fortran code in :term:`extension modules <extension module>` that "
"can be called from Python.  See also :term:`extension module`."
msgstr ""

#: glossary.rst:1112
msgid "nested scope"
msgstr "portée imbriquée"

#: glossary.rst:1114
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 ""
"Possibilité de faire référence à une variable déclarée dans une définition "
"englobante. Typiquement, une fonction définie à l'intérieur d'une autre "
"fonction a accès aux variables de cette dernière. 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 "
"nommage le plus proche. Tout comme les variables globales qui sont stockés "
"dans l'espace de nommage global, le mot clef :keyword:`nonlocal` permet "
"d'écrire dans l'espace de nommage dans lequel est déclarée la variable."

#: glossary.rst:1121
msgid "new-style class"
msgstr "nouvelle classe"

#: glossary.rst:1123
#, fuzzy
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:`~object.__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, seules les nouvelles classes "
"pouvaient utiliser les nouvelles fonctionnalités telles "
"que :attr:`~object.__slots__`, les descripteurs, les "
"propriétés, :meth:`__getattribute__`, les méthodes de classe et les méthodes "
"statiques."

#: glossary.rst:1128
msgid "non-deterministic"
msgstr ""

#: glossary.rst:1130
msgid ""
"Behavior where the outcome of a program can vary between executions with the "
"same inputs.  In multi-threaded programs, non-deterministic behavior often "
"results from :term:`race conditions <race condition>` where the relative "
"timing or interleaving of threads affects the result. Proper synchronization "
"using :term:`locks <lock>` and other :term:`synchronization primitives "
"<synchronization primitive>` helps ensure deterministic behavior."
msgstr ""

#: glossary.rst:1137
msgid "object"
msgstr "objet"

#: glossary.rst:1139
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 "
"d'une valeur) et un comportement (des méthodes). C'est aussi (``object``) "
"l'ancêtre commun à absolument toutes les :term:`nouvelles classes <new-style "
"class>`."

#: glossary.rst:1142
#, fuzzy
msgid "optimized scope"
msgstr "portée imbriquée"

#: glossary.rst:1144
msgid ""
"A scope where target local variable names are reliably known to the compiler "
"when the code is compiled, allowing optimization of read and write access to "
"these names. The local namespaces for functions, generators, coroutines, "
"comprehensions, and generator expressions are optimized in this fashion. "
"Note: most interpreter optimizations are applied to all scopes, only those "
"relying on a known set of local and nonlocal variable names are restricted "
"to optimized scopes."
msgstr ""

#: glossary.rst:1151
#, fuzzy
msgid "optional module"
msgstr "module d'extension"

#: glossary.rst:1153
msgid ""
"An :term:`extension module` that is part of the :term:`standard library`, "
"but may be absent in some builds of :term:`CPython`, usually due to missing "
"third-party libraries or because the module is not available for a given "
"platform."
msgstr ""

#: glossary.rst:1158
msgid ""
"See :ref:`optional-module-requirements` for a list of optional modules that "
"require third-party libraries."
msgstr ""

#: glossary.rst:1160
msgid "package"
msgstr "paquet"

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

#: glossary.rst:1166
msgid "See also :term:`regular package` and :term:`namespace package`."
msgstr "Voir aussi :term:`paquet classique` et :term:`namespace package`."

#: glossary.rst:1167
msgid "parallelism"
msgstr ""

#: glossary.rst:1169
msgid ""
"Executing multiple operations at the same time (e.g. on multiple CPU "
"cores).  In Python builds with the :term:`global interpreter lock (GIL) "
"<global interpreter lock>`, only one thread runs Python bytecode at a time, "
"so taking advantage of multiple CPU cores typically involves multiple "
"processes (e.g. :mod:`multiprocessing`) or native extensions that release "
"the GIL. In :term:`free-threaded <free threading>` Python, multiple Python "
"threads can run Python code simultaneously on different cores."
msgstr ""

#: glossary.rst:1177
msgid "parameter"
msgstr "paramètre"

#: glossary.rst:1179
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 ""
"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 sortes de paramètres :"

#: glossary.rst:1183
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` : l'argument peut être passé soit par "
"sa :term:`position <argument>`, soit en tant que :term:`argument nommé "
"<argument>`. C'est le type de paramètre par défaut. Par exemple, *foo* et "
"*bar* dans l'exemple suivant ::"

#: glossary.rst:1192
msgid ""
":dfn:`positional-only`: specifies an argument that can be supplied only by "
"position. Positional-only parameters can be defined by including a ``/`` "
"character in the parameter list of the function definition after them, for "
"example *posonly1* and *posonly2* in the following::"
msgstr ""
":dfn:`positional-only` : définit un argument qui ne peut être fourni que par "
"position. Les paramètres *positional-only* peuvent être définis en insérant "
"un caractère \"/\" dans la liste de paramètres de la définition de fonction "
"après eux. Par exemple : *posonly1* et *posonly2* dans le code suivant ::"

#: glossary.rst:1201
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` : l'argument ne peut être fourni que nommé. Les "
"paramètres *keyword-only* peuvent être définis en utilisant un seul "
"paramètre *var-positional*, ou en ajoutant une étoile (``*``) seule dans la "
"liste des paramètres avant eux. Par exemple, *kw_only1* et *kw_only2* dans "
"le code suivant ::"

#: glossary.rst:1209
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` : une séquence d'arguments positionnels peut être "
"fournie (en plus de tous les arguments positionnels déjà acceptés par "
"d'autres paramètres). Un tel paramètre peut être défini en préfixant son nom "
"par une ``*``. Par exemple *args* ci-après ::"

#: glossary.rst:1217
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` : une quantité arbitraire d'arguments peut être passée, "
"chacun étant nommé (en plus de tous les arguments nommés déjà acceptés par "
"d'autres paramètres). Un tel paramètre est défini en préfixant le nom du "
"paramètre par ``**``. Par exemple, *kwargs* ci-dessus."

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

#: glossary.rst:1226
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ètres <faq-argument-vs-"
"parameter>` dans la FAQ, la classe :class:`inspect.Parameter`, la "
"section :ref:`function` et la :pep:`362`."

#: glossary.rst:1230
msgid "per-object lock"
msgstr ""

#: glossary.rst:1232
msgid ""
"A :term:`lock` associated with an individual object instance rather than a "
"global lock shared across all objects. In :term:`free-threaded <free "
"threading>` Python, built-in types like :class:`dict` and :class:`list` use "
"per-object locks to allow concurrent operations on different objects while "
"serializing operations on the same object. Operations that hold the per-"
"object lock prevent other locking operations on the same object from "
"proceeding, but do not block :term:`lock-free` operations."
msgstr ""

#: glossary.rst:1240
msgid "path entry"
msgstr "entrée de chemin"

#: glossary.rst:1242
msgid ""
"A single location on the :term:`import path` which the :term:`path based "
"finder` consults to find modules for importing."
msgstr ""
"Emplacement dans le :term:`chemin des importations <import path>` (*import "
"path* en anglais, d'où le *path*) que le :term:`chercheur basé sur les "
"chemins <path based finder>` consulte pour trouver des modules à importer."

#: glossary.rst:1244
msgid "path entry finder"
msgstr "chercheur de chemins"

#: glossary.rst:1246
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 ""
":term:`chercheur <finder>` renvoyé par un appelable sur "
"un :data:`sys.path_hooks` (c'est-à-dire un :term:`point d'entrée pour la "
"recherche dans path <path entry hook>`) qui sait où trouver des modules "
"lorsqu'on lui donne une :term:`entrée de path <path entry>`."

#: glossary.rst:1250
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 "
"chercheur d'entrée dans *path* doit implémenter."

#: glossary.rst:1252
msgid "path entry hook"
msgstr "point d'entrée pour la recherche dans *path*"

#: glossary.rst:1254
#, fuzzy
msgid ""
"A callable on the :data:`sys.path_hooks` list which returns a :term:`path "
"entry finder` if it knows how to find modules on a specific :term:`path "
"entry`."
msgstr ""
"Appelable dans la liste :data:`sys.path_hook` qui donne un :term:`chercheur "
"d'entrée dans path <path entry finder>` s'il sait où trouver des modules "
"pour une :term:`entrée dans path <path entry>` donnée."

#: glossary.rst:1257
msgid "path based finder"
msgstr "chercheur basé sur les chemins"

#: glossary.rst:1259
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:`chercheurs dans les méta-chemins <meta path finder>` par "
"défaut qui cherche des modules dans un :term:`chemin des importations "
"<import path>`."

#: glossary.rst:1261
msgid "path-like object"
msgstr "objet simili-chemin"

#: glossary.rst:1263
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 ""
"Objet représentant un chemin du système de fichiers. Un objet simili-chemin "
"est un objet :class:`str` ou un objet :class:`bytes` représentant un chemin "
"ou un objet implémentant le protocole :class:`os.PathLike`. Un objet qui "
"accepte le protocole :class:`os.PathLike` peut être converti en un "
"chemin :class:`str` ou :class:`bytes` du système de fichiers en appelant 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. A été Introduit par "
"la :pep:`519`."

#: glossary.rst:1271
msgid "PEP"
msgstr "PEP"

#: glossary.rst:1273
msgid ""
"Python Enhancement Proposal. A PEP is a design document providing "
"information to the Python community, or describing a new feature for Python "
"or its processes or environment. PEPs should provide a concise technical "
"specification and a rationale for proposed features."
msgstr ""
"*Python Enhancement Proposal* (Proposition d'amélioration de Python). Une "
"PEP est un document de conception fournissant des informations à la "
"communauté Python ou décrivant une nouvelle fonctionnalité pour Python, ses "
"processus ou son environnement. Les PEP doivent fournir une spécification "
"technique concise et une justification des fonctionnalités proposées."

#: glossary.rst:1279
msgid ""
"PEPs are intended to be the primary mechanisms for proposing major new "
"features, for collecting community input on an issue, and for documenting "
"the design decisions that have gone into Python. The PEP author is "
"responsible for building consensus within the community and documenting "
"dissenting opinions."
msgstr ""
"Les PEP sont censées être les principaux mécanismes pour proposer de "
"nouvelles fonctionnalités majeures, pour recueillir les commentaires de la "
"communauté sur une question et pour documenter les décisions de conception "
"qui sont intégrées en Python. L’auteur du PEP est responsable de "
"l’établissement d’un consensus au sein de la communauté et de documenter les "
"opinions contradictoires."

#: glossary.rst:1285
msgid "See :pep:`1`."
msgstr "Voir la :pep:`1`."

#: glossary.rst:1286
msgid "portion"
msgstr "portion"

#: glossary.rst:1288
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 ""
"Jeu de fichiers dans un seul dossier (pouvant être stocké sous forme de "
"fichier zip) qui contribue à l'espace de nommage d'un paquet, tel que défini "
"dans la :pep:`420`."

#: glossary.rst:1290
msgid "positional argument"
msgstr "argument positionnel"

#: glossary.rst:1293
msgid "provisional API"
msgstr "API provisoire"

#: glossary.rst:1295
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 qui n'offre aucune garantie de "
"rétrocompatibilité (la bibliothèque standard exige la rétrocompatibilité). "
"Bien que des changements majeurs d'une telle interface ne soient pas "
"attendus, tant qu'elle est étiquetée provisoire, des changements cassant la "
"rétrocompatibilité (y compris sa suppression complète) peuvent survenir si "
"les développeurs principaux le jugent nécessaire. Ces modifications ne "
"surviendront que si de sérieux problèmes sont découverts et qu'ils n'avaient "
"pas été identifiés avant l'ajout de l'API."

#: glossary.rst:1304
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 changements cassant la rétrocompatibilité "
"sont considérés comme des \"solutions de dernier recours\". Tout ce qui est "
"possible sera fait pour tenter de résoudre les problèmes en conservant la "
"rétrocompatibilité."

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

#: glossary.rst:1311
msgid "provisional package"
msgstr "paquet provisoire"

#: glossary.rst:1313
msgid "See :term:`provisional API`."
msgstr "Voir :term:`provisional API`."

#: glossary.rst:1314
msgid "Python 3000"
msgstr "Python 3000"

#: glossary.rst:1316
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 donné à la série des Python 3.x (très vieux surnom donné à l'époque "
"où Python 3 représentait un futur lointain). Aussi abrégé *Py3k*."

#: glossary.rst:1319
msgid "Pythonic"
msgstr "*Pythonique*"

#: glossary.rst:1321
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 ""
"Idée, ou bout de code, qui colle aux idiomes de Python plutôt qu'aux "
"concepts communs rencontrés dans d'autres langages. Par exemple, il est "
"idiomatique en Python de parcourir les éléments d'un itérable en "
"utilisant :keyword:`for`. Beaucoup d'autres langages n'ont pas cette "
"possibilité, donc les gens qui ne sont pas habitués à Python utilisent "
"parfois un compteur numérique à la place ::"

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

#: glossary.rst:1335
msgid "qualified name"
msgstr "nom qualifié"

#: glossary.rst:1337
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 ""
"Nom, comprenant des points, montrant le \"chemin\" de l'espace de nommage "
"global d'un module vers une classe, 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 ::"

#: glossary.rst:1354
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* "
"(*fully qualified name - FQN* en anglais) signifie le chemin complet (séparé "
"par des points) vers le module, incluant tous les paquets parents. Par "
"exemple : ``email.mime.text`` ::"

#: glossary.rst:1361
#, fuzzy
msgid "race condition"
msgstr "ramasse-miettes"

#: glossary.rst:1363
msgid ""
"A condition of a program where the behavior depends on the relative timing "
"or ordering of events, particularly in multi-threaded programs.  Race "
"conditions can lead to :term:`non-deterministic` behavior and bugs that are "
"difficult to reproduce.  A :term:`data race` is a specific type of race "
"condition involving unsynchronized access to shared memory.  "
"The :term:`LBYL` coding style is particularly susceptible to race conditions "
"in multi-threaded code.  Using :term:`locks <lock>` and "
"other :term:`synchronization primitives <synchronization primitive>` helps "
"prevent race conditions."
msgstr ""

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

#: glossary.rst:1375
#, fuzzy
msgid ""
"The number of references to an object.  When the reference count of an "
"object drops to zero, it is deallocated.  Some objects are :term:`immortal` "
"and have reference counts that are never modified, and therefore the objects "
"are never deallocated.  Reference counting is generally not visible to "
"Python code, but it is a key element of the :term:`CPython` implementation.  "
"Programmers can call the :func:`sys.getrefcount` function to return the "
"reference count for a particular object."
msgstr ""
"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 clé de "
"l'implémentation :term:`CPython`. Les développeurs peuvent utiliser la "
"fonction :func:`sys.getrefcount` pour obtenir le nombre de références à un "
"objet donné."

#: glossary.rst:1384
msgid ""
"In :term:`CPython`, reference counts are not considered to be stable or well-"
"defined values; the number of references to an object, and how that number "
"is affected by Python code, may be different between versions."
msgstr ""

#: glossary.rst:1388
msgid "regular package"
msgstr "paquet classique"

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

#: glossary.rst:1393
msgid "See also :term:`namespace package`."
msgstr "Voir aussi :term:`paquet-espace de nommage <namespace package>`."

#: glossary.rst:1394
msgid "reentrant"
msgstr ""

#: glossary.rst:1396
msgid ""
"A property of a function or :term:`lock` that allows it to be called or "
"acquired multiple times by the same thread without causing errors or "
"a :term:`deadlock`."
msgstr ""

#: glossary.rst:1400
msgid ""
"For functions, reentrancy means the function can be safely called again "
"before a previous invocation has completed, which is important when "
"functions may be called recursively or from signal handlers. Thread-unsafe "
"functions may be :term:`non-deterministic` if they're called reentrantly in "
"a multithreaded program."
msgstr ""

#: glossary.rst:1406
msgid ""
"For locks, Python's :class:`threading.RLock` (reentrant lock) is reentrant, "
"meaning a thread that already holds the lock can acquire it again without "
"blocking.  In contrast, :class:`threading.Lock` is not reentrant - "
"attempting to acquire it twice from the same thread will cause a deadlock."
msgstr ""

#: glossary.rst:1412
#, fuzzy
msgid "See also :term:`lock` and :term:`deadlock`."
msgstr "Voir aussi :term:`paquet classique` et :term:`namespace package`."

#: glossary.rst:1413
msgid "REPL"
msgstr "REPL"

#: glossary.rst:1415
msgid ""
"An acronym for the \"read–eval–print loop\", another name for "
"the :term:`interactive` interpreter shell."
msgstr ""
"Un acronyme pour \"*read–eval–print loop*\", un autre terme pour "
"l’interpréteur :term:`interactif <interactive>`."

#: glossary.rst:1417
msgid "__slots__"
msgstr "__slots__"

#: glossary.rst:1419
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 ""
"Déclaration dans une classe qui économise de la mémoire en pré-allouant de "
"l'espace pour les attributs des instances et qui élimine le dictionnaire "
"(des attributs) des instances. Bien que populaire, cette technique est "
"difficile à maîtriser et devrait être réservée à de rares cas où un grand "
"nombre d'instances dans une application devient un sujet critique pour la "
"mémoire."

#: glossary.rst:1424
msgid "sequence"
msgstr "séquence"

#: glossary.rst:1426
#, fuzzy
msgid ""
"An :term:`iterable` which supports efficient element access using integer "
"indices via the :meth:`~object.__getitem__` special method and defines "
"a :meth:`~object.__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:`~object.__getitem__` and :meth:`!"
"__len__`, but is considered a mapping rather than a sequence because the "
"lookups use arbitrary :term:`hashable` keys rather than integers."
msgstr ""
":term:`itérable` qui offre un accès efficace à ses éléments par un indice "
"sous forme de nombre entier via la méthode spéciale :meth:`__getitem__` et "
"qui définit une méthode :meth:`__len__` donnant sa taille. Voici quelques "
"séquences natives : :class:`list`, :class:`str`, :class:`tuple`, "
"et :class:`bytes`. Notez que :class:`dict` possède 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 clé arbitraire :term:`immuable` plutôt qu'un nombre entier."

#: glossary.rst:1435
#, fuzzy
msgid ""
"The :class:`collections.abc.Sequence` abstract base class defines a much "
"richer interface that goes beyond just :meth:`~object.__getitem__` "
"and :meth:`~object.__len__`, "
"adding :meth:`~sequence.count`, :meth:`~sequence.index`, :meth:`~object.__contains__`, "
"and :meth:`~object.__reversed__`. Types that implement this expanded "
"interface can be registered explicitly using :func:`~abc.ABCMeta.register`. "
"For more documentation on sequence methods generally, see :ref:`Common "
"Sequence Operations <typesseq-common>`."
msgstr ""
"La classe abstraite de base :class:`collections.abc.Sequence` définit 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`."

#: glossary.rst:1445
msgid "set comprehension"
msgstr "ensemble en compréhension (ou ensemble en intension)"

#: glossary.rst:1447
msgid ""
"A compact way to process all or part of the elements in an iterable and "
"return a set with the results. ``results = {c for c in 'abracadabra' if c "
"not in 'abc'}`` generates the set of strings ``{'r', 'd'}``.  "
"See :ref:`comprehensions`."
msgstr ""
"Une façon compacte de traiter tout ou partie des éléments d'un itérable et "
"de renvoyer un *set* avec les résultats. ``results = {c for c in "
"'abracadabra' if c not in 'abc'}`` génère l'ensemble contenant les lettres "
"« r » et « d » ``{'r', 'd'}``. Voir :ref:`comprehensions`."

#: glossary.rst:1451
msgid "single dispatch"
msgstr "distribution simple"

#: glossary.rst:1453
msgid ""
"A form of :term:`generic function` dispatch where the implementation is "
"chosen based on the type of a single argument."
msgstr ""
"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."

#: glossary.rst:1455
msgid "slice"
msgstr "tranche"

#: glossary.rst:1457
msgid ""
"An object of type :class:`slice`, used to describe a portion of "
"a :term:`sequence`. A slice object is created when using the :ref:`slicing "
"<slicings>` form of :ref:`subscript notation <subscriptions>`, with colons "
"inside square brackets, such as in ``variable_name[1:3:5]``."
msgstr ""

#: glossary.rst:1462
msgid "soft deprecated"
msgstr ""

#: glossary.rst:1464
msgid ""
"A soft deprecated API should not be used in new code, but it is safe for "
"already existing code to use it. The API remains documented and tested, but "
"will not be enhanced further."
msgstr ""

#: glossary.rst:1468
msgid ""
"Soft deprecation, unlike normal deprecation, does not plan on removing the "
"API and will not emit warnings."
msgstr ""

#: glossary.rst:1471
msgid ""
"See `PEP 387: Soft Deprecation <https://peps.python.org/pep-0387/#soft-"
"deprecation>`_."
msgstr ""

#: glossary.rst:1473
msgid "special method"
msgstr "méthode spéciale"

#: glossary.rst:1477
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* en anglais) Méthode appelée implicitement par Python pour "
"exécuter une opération sur un type, comme 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`."

#: glossary.rst:1481
msgid "standard library"
msgstr ""

#: glossary.rst:1483
msgid ""
"The collection of :term:`packages <package>`, :term:`modules <module>` "
"and :term:`extension modules <extension module>` distributed as a part of "
"the official Python interpreter package.  The exact membership of the "
"collection may vary based on platform, available system libraries, or other "
"criteria.  Documentation can be found at :ref:`library-index`."
msgstr ""

#: glossary.rst:1489
msgid ""
"See also :data:`sys.stdlib_module_names` for a list of all possible standard "
"library module names."
msgstr ""

#: glossary.rst:1491
msgid "statement"
msgstr "instruction"

#: glossary.rst:1493
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* en anglais) est un composant d'un \"bloc\" de "
"code. Une instruction est soit une :term:`expression`, soit une ou plusieurs "
"constructions basées sur un mot-clé, comme :keyword:`if`, :keyword:`while` "
"ou :keyword:`for`."

#: glossary.rst:1496
msgid "static type checker"
msgstr ""

#: glossary.rst:1498
msgid ""
"An external tool that reads Python code and analyzes it, looking for issues "
"such as incorrect types. See also :term:`type hints <type hint>` and "
"the :mod:`typing` module."
msgstr ""

#: glossary.rst:1501
msgid "stdlib"
msgstr ""

#: glossary.rst:1503
msgid "An abbreviation of :term:`standard library`."
msgstr ""

#: glossary.rst:1504
msgid "strong reference"
msgstr "référence forte"

#: glossary.rst:1506
#, fuzzy
msgid ""
"In Python's C API, a strong reference is a reference to an object which is "
"owned by the code holding the reference.  The strong reference is taken by "
"calling :c:func:`Py_INCREF` when the reference is created and released "
"with :c:func:`Py_DECREF` when the reference is deleted."
msgstr ""
"Dans l'API C de Python, une référence forte est une référence vers un objet "
"qui incrémente son compteur de références lorsqu'elle est créée et le "
"décrémente lorsqu'elle est effacée."

#: glossary.rst:1512
msgid ""
"The :c:func:`Py_NewRef` function can be used to create a strong reference to "
"an object. Usually, the :c:func:`Py_DECREF` function must be called on the "
"strong reference before exiting the scope of the strong reference, to avoid "
"leaking one reference."
msgstr ""
"Une référence forte est créée à l'aide de la fonction :c:func:`Py_NewRef`. "
"Il faut normalement appeler :c:func:`Py_DECREF` dessus avant de sortir de sa "
"portée lexicale, sans quoi il y a une fuite de référence."

#: glossary.rst:1517
msgid "See also :term:`borrowed reference`."
msgstr "Voir aussi :term:`référence empruntée<borrowed reference>`."

#: glossary.rst:1518
#, fuzzy
msgid "subscript"
msgstr "descripteur"

#: glossary.rst:1520
msgid ""
"The expression in square brackets of a :ref:`subscription expression "
"<subscriptions>`, for example, the ``3`` in ``items[3]``. Usually used to "
"select an element of a container. Also called a :term:`key` when "
"subscripting a :term:`mapping`, or an :term:`index` when subscripting "
"a :term:`sequence`."
msgstr ""

#: glossary.rst:1526
msgid "synchronization primitive"
msgstr ""

#: glossary.rst:1528
msgid ""
"A basic building block for coordinating (synchronizing) the execution of "
"multiple threads to ensure :term:`thread-safe` access to shared resources. "
"Python's :mod:`threading` module provides several synchronization primitives "
"including :class:`~threading.Lock`, :class:`~threading.RLock`, :class:`~threading.Semaphore`, :class:`~threading.Condition`, :class:`~threading.Event`, "
"and :class:`~threading.Barrier`.  Additionally, the :mod:`queue` module "
"provides multi-producer, multi-consumer queues that are especially useful in "
"multithreaded programs. These primitives help prevent :term:`race conditions "
"<race condition>` and coordinate thread execution.  See also :term:`lock`."
msgstr ""

#: glossary.rst:1538
#, fuzzy
msgid "t-string"
msgstr "f-string"

#: glossary.rst:1539
#, fuzzy
msgid "t-strings"
msgstr "f-string"

#: glossary.rst:1541
#, fuzzy
msgid ""
"String literals prefixed with ``t`` or ``T`` are commonly called \"t-"
"strings\" which is short for :ref:`template string literals <t-strings>`."
msgstr ""
"Chaîne littérale préfixée de ``'f'`` ou ``'F'``. Les \"f-strings\" sont un "
"raccourci pour :ref:`formatted string literals <f-strings>`. Voir "
"la :pep:`498`."

#: glossary.rst:1544
msgid "text encoding"
msgstr "encodages de texte"

#: glossary.rst:1546
msgid ""
"A string in Python is a sequence of Unicode code points (in range "
"``U+0000``--``U+10FFFF``). To store or transfer a string, it needs to be "
"serialized as a sequence of bytes."
msgstr ""
"Une chaîne de caractères en Python est une suite de points de code Unicode "
"(dans l'intervalle ``U+0000``--``U+10FFFF``). Pour stocker ou transmettre "
"une chaîne, il est nécessaire de la sérialiser en suite d'octets."

#: glossary.rst:1550
msgid ""
"Serializing a string into a sequence of bytes is known as \"encoding\", and "
"recreating the string from the sequence of bytes is known as \"decoding\"."
msgstr ""
"Sérialiser une chaîne de caractères en une suite d'octets s'appelle "
"« encoder » et recréer la chaîne à partir de la suite d'octets s'appelle "
"« décoder »."

#: glossary.rst:1553
msgid ""
"There are a variety of different text serialization :ref:`codecs <standard-"
"encodings>`, which are collectively referred to as \"text encodings\"."
msgstr ""
"Il existe de multiples :ref:`codecs <standard-encodings>` pour la "
"sérialisation de texte, que l'on regroupe sous l'expression « encodages de "
"texte »."

#: glossary.rst:1556
msgid "text file"
msgstr "fichier texte"

#: glossary.rst:1558
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 ""
":term:`Objet fichier <file object>` capable de lire et d'écrire des "
"objets :class:`str`. Souvent, un fichier texte (*text file* en anglais) "
"accède en fait à un flux de donnée en octets et gère l':term:`encodage de "
"texte <text encoding>` automatiquement. Des exemples de fichiers textes sont "
"les fichiers ouverts en mode texte (``'r'`` ou "
"``'w'``), :data:`sys.stdin`, :data:`sys.stdout` et les instances "
"de :class:`io.StringIO`."

#: glossary.rst:1565
msgid ""
"See also :term:`binary file` for a file object able to read and "
"write :term:`bytes-like objects <bytes-like object>`."
msgstr ""
"Voir aussi :term:`fichier binaire <binary file>` pour un objet fichier "
"capable de lire et d'écrire des :term:`objets octets-compatibles <bytes-like "
"object>`."

#: glossary.rst:1567
msgid "thread state"
msgstr ""

#: glossary.rst:1570
msgid ""
"The information used by the :term:`CPython` runtime to run in an OS thread. "
"For example, this includes the current exception, if any, and the state of "
"the bytecode interpreter."
msgstr ""

#: glossary.rst:1574
msgid ""
"Each thread state is bound to a single OS thread, but threads may have many "
"thread states available.  At most, one of them may be :term:`attached "
"<attached thread state>` at once."
msgstr ""

#: glossary.rst:1578
msgid ""
"An :term:`attached thread state` is required to call most of Python's C API, "
"unless a function explicitly documents otherwise. The bytecode interpreter "
"only runs under an attached thread state."
msgstr ""

#: glossary.rst:1582
msgid ""
"Each thread state belongs to a single interpreter, but each interpreter may "
"have many thread states, including multiple for the same OS thread. Thread "
"states from multiple interpreters may be bound to the same thread, but only "
"one can be :term:`attached <attached thread state>` in that thread at any "
"given moment."
msgstr ""

#: glossary.rst:1588
msgid ""
"See :ref:`Thread State and the Global Interpreter Lock <threads>` for more "
"information."
msgstr ""

#: glossary.rst:1590
msgid "thread-safe"
msgstr ""

#: glossary.rst:1592
msgid ""
"A module, function, or class that behaves correctly when used by multiple "
"threads concurrently.  Thread-safe code uses "
"appropriate :term:`synchronization primitives <synchronization primitive>` "
"like :term:`locks <lock>` to protect shared mutable state, or is designed to "
"avoid shared mutable state entirely.  In the :term:`free-threaded <free "
"threading>` build, built-in types like :class:`dict`, :class:`list`, "
"and :class:`set` use internal locking to make many operations thread-safe, "
"although thread safety is not necessarily guaranteed.  Code that is not "
"thread-safe may experience :term:`race conditions <race condition>` "
"and :term:`data races <data race>` when used in multi-threaded programs."
msgstr ""

#: glossary.rst:1603
msgid "token"
msgstr ""

#: glossary.rst:1606
msgid ""
"A small unit of source code, generated by the :ref:`lexical analyzer "
"<lexical>` (also called the *tokenizer*). Names, numbers, strings, "
"operators, newlines and similar are represented by tokens."
msgstr ""

#: glossary.rst:1611
msgid ""
"The :mod:`tokenize` module exposes Python's lexical analyzer. "
"The :mod:`token` module contains information on the various types of tokens."
msgstr ""

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

#: glossary.rst:1616
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 ""
"Chaîne qui est délimitée par trois guillemets simples (``'``) ou trois "
"guillemets doubles (``\"``). Bien qu'elle ne fournisse aucune fonctionnalité "
"qui ne soit pas disponible avec une chaîne entre guillemets, elle est utile "
"pour de nombreuses raisons. Elle vous autorise à insérer des guillemets "
"simples et doubles dans une chaîne sans avoir à les protéger et elle peut "
"s'étendre sur plusieurs lignes sans avoir à terminer chaque ligne par un "
"``\\``. Elle est ainsi particulièrement utile pour les chaînes de "
"documentation (*docstrings*)."

#: glossary.rst:1623
msgid "type"
msgstr "type"

#: glossary.rst:1625
#, fuzzy
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:`~object.__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)``."

#: glossary.rst:1629
msgid "type alias"
msgstr "alias de type"

#: glossary.rst:1631
msgid "A synonym for a type, created by assigning the type to an identifier."
msgstr "Synonyme d'un type, créé en affectant le type à un identifiant."

#: glossary.rst:1633
msgid ""
"Type aliases are useful for simplifying :term:`type hints <type hint>`. For "
"example::"
msgstr ""
"Les alias de types sont utiles pour simplifier les :term:`indications de "
"types <type hint>`. Par exemple ::"

#: glossary.rst:1640
msgid "could be made more readable like this::"
msgstr "pourrait être rendu plus lisible comme ceci ::"

#: glossary.rst:1661
msgid "See :mod:`typing` and :pep:`484`, which describe this functionality."
msgstr ""
"Voir :mod:`typing` et la :pep:`484`, qui décrivent cette fonctionnalité."

#: glossary.rst:1648
msgid "type hint"
msgstr "indication de type"

#: glossary.rst:1650
msgid ""
"An :term:`annotation` that specifies the expected type for a variable, a "
"class attribute, or a function parameter or return value."
msgstr ""
"L':term:`annotation <annotation>` qui spécifie le type attendu pour une "
"variable, un attribut de classe, un paramètre de fonction ou une valeur de "
"retour."

#: glossary.rst:1653
#, fuzzy
msgid ""
"Type hints are optional and are not enforced by Python but they are useful "
"to :term:`static type checkers <static type checker>`. They can also aid "
"IDEs with code completion and refactoring."
msgstr ""
"Les indications de type sont facultatives et ne sont pas indispensables à "
"l'interpréteur Python, mais elles sont utiles aux outils d'analyse de type "
"statique et aident les IDE à compléter et à réusiner (*code refactoring* en "
"anglais) le code."

#: glossary.rst:1657
msgid ""
"Type hints of global variables, class attributes, and functions, but not "
"local variables, can be accessed using :func:`typing.get_type_hints`."
msgstr ""
"Les indications de type de variables globales, d'attributs de classe et de "
"fonctions, mais pas de variables locales, peuvent être consultées en "
"utilisant :func:`typing.get_type_hints`."

#: glossary.rst:1662
msgid "universal newlines"
msgstr "retours à la ligne universels"

#: glossary.rst:1664
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 sont reconnues "
"toutes les fins de ligne suivantes : 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."

#: glossary.rst:1669
msgid "variable annotation"
msgstr "annotation de variable"

#: glossary.rst:1671
msgid "An :term:`annotation` of a variable or a class attribute."
msgstr ":term:`annotation` d'une variable ou d'un attribut de classe."

#: glossary.rst:1673
msgid ""
"When annotating a variable or a class attribute, assignment is optional::"
msgstr ""
"Lorsque vous annotez une variable ou un attribut de classe, l'affectation "
"est facultative ::"

#: glossary.rst:1678
msgid ""
"Variable annotations are usually used for :term:`type hints <type hint>`: "
"for example this variable is expected to take :class:`int` values::"
msgstr ""
"Les annotations de variables sont généralement utilisées pour "
"des :term:`indications de types <type hint>` : par exemple, cette variable "
"devrait prendre des valeurs de type :class:`int` ::"

#: glossary.rst:1684
msgid "Variable annotation syntax is explained in section :ref:`annassign`."
msgstr ""
"La syntaxe d'annotation de variable est expliquée dans la "
"section :ref:`annassign`."

#: glossary.rst:1686
msgid ""
"See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe "
"this functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"Reportez-vous à :term:`annotation de fonction<function annotation>`, à "
"la :pep:`484` et à la :pep:`526` qui décrivent cette fonctionnalité. Voir "
"aussi :ref:`annotations-howto` sur les bonnes pratiques concernant les "
"annotations."

#: glossary.rst:1690
msgid "virtual environment"
msgstr "environnement virtuel"

#: glossary.rst:1692
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 ""
"Environnement d'exécution isolé (en mode coopératif) 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."

#: glossary.rst:1697
msgid "See also :mod:`venv`."
msgstr "Voir aussi :mod:`venv`."

#: glossary.rst:1698
msgid "virtual machine"
msgstr "machine virtuelle"

#: glossary.rst:1700
msgid ""
"A computer defined entirely in software.  Python's virtual machine executes "
"the :term:`bytecode` emitted by the bytecode compiler."
msgstr ""
"Ordinateur défini entièrement par du logiciel. La machine virtuelle "
"(*virtual machine*) de Python exécute le :term:`code intermédiaire "
"<bytecode>` produit par le compilateur de *bytecode*."

#: glossary.rst:1702
#, fuzzy
msgid "walrus operator"
msgstr "itérateur asynchrone"

#: glossary.rst:1704
msgid ""
"A light-hearted way to refer to the :ref:`assignment expression <assignment-"
"expressions>` operator ``:=`` because it looks a bit like a walrus if you "
"turn your head."
msgstr ""

#: glossary.rst:1707
msgid "Zen of Python"
msgstr "Le zen de Python"

#: glossary.rst:1709
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 préceptes utiles pour comprendre et utiliser le "
"langage. Cette liste peut être obtenue en tapant \"``import this``\" dans "
"une invite Python interactive."

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

#~ 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* en anglais), 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, "
#~ "comme dans ``variable_name[1:3:5]``. Cette notation utilise des "
#~ "objets :class:`slice` en interne."

#~ msgid "The :const:`Ellipsis` built-in constant."
#~ msgstr "La constante :const:`Ellipsis`."

#, fuzzy
#~ msgid ""
#~ "An object which controls the environment seen in a :keyword:`with` "
#~ "statement by defining :meth:`~object.__enter__` "
#~ "and :meth:`~object.__exit__` methods. See :pep:`343`."
#~ msgstr ""
#~ "Objet contrôlant l'environnement à l'intérieur d'un bloc :keyword:`with` "
#~ "en définissant les méthodes :meth:`__enter__` et :meth:`__exit__`. "
#~ "Consultez la :pep:`343`."

#~ msgid ""
#~ "A variable which can have different values depending on its context. This "
#~ "is similar to Thread-Local Storage in which each execution thread may "
#~ "have a different value for a variable. However, with context variables, "
#~ "there may be several contexts in one execution thread and the main usage "
#~ "for context variables is to keep track of variables in concurrent "
#~ "asynchronous tasks. See :mod:`contextvars`."
#~ msgstr ""
#~ "Une variable qui peut avoir des valeurs différentes en fonction de son "
#~ "contexte. Cela est similaire au stockage par fil d’exécution (*Thread "
#~ "Local Storage* en anglais) dans lequel chaque fil d’exécution peut avoir "
#~ "une valeur différente pour une variable. Toutefois, avec les variables de "
#~ "contexte, il peut y avoir plusieurs contextes dans un fil d’exécution et "
#~ "l’utilisation principale pour les variables de contexte est de garder une "
#~ "trace des variables dans les tâches asynchrones concourantes. "
#~ "Voir :mod:`contextvars`."

#, fuzzy
#~ msgid "C-contiguous"
#~ msgstr "contigu"

#, fuzzy
#~ msgid "Fortran contiguous"
#~ msgstr "contigu"

#, fuzzy
#~ msgid "special"
#~ msgstr "méthode spéciale"

#~ msgid "2to3"
#~ msgstr "2to3"

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

#~ 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`."

#~ 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 "
#~ "leurs mauvaises performances dans le cas d'un processeur unique. Il est "
#~ "admis que corriger ce problème de performance induit mènerait à une "
#~ "implémentation beaucoup plus compliquée et donc plus coûteuse à maintenir."

#~ msgid ""
#~ "Python uses the :term:`filesystem encoding and error handler` to convert "
#~ "between Unicode filenames and bytes filenames."
#~ msgstr ""
#~ "Python utilise l':term:`encodage du système de fichier et gestionnaire "
#~ "d'erreur<filesystem encoding and error handler>` pour les conversions de "
#~ "noms de fichier entre Unicode et octets."

#~ msgid "A codec which encodes Unicode strings to bytes."
#~ msgstr ""
#~ "Codec (codeur-décodeur) qui convertit des chaînes de caractères Unicode "
#~ "en octets (classe *bytes*)."

#~ msgid "coercion"
#~ msgstr "coercition"

#~ 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 :exc:`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 ""
#~ "Conversion implicite d'une instance d'un type vers un autre lors d'une "
#~ "opération dont les deux opérandes doivent être de même type. Par exemple "
#~ "``int(3.15)`` convertit explicitement le nombre à virgule flottante en "
#~ "nombre entier ``3``. Mais dans l'opération ``3 + 4.5``, les deux "
#~ "opérandes sont d'un type différent (un entier et un nombre à virgule "
#~ "flottante), alors qu'ils doivent avoir le même type pour être additionnés "
#~ "(sinon une exception :exc:`TypeError` serait levée). Sans coercition, "
#~ "tous les opérandes, même de types compatibles, devraient être convertis "
#~ "(on parle aussi de *cast*) explicitement par le développeur, par "
#~ "exemple : ``float(3) + 4.5`` au lieu du simple ``3 + 4.5``."

#~ msgid ""
#~ "See :pep:`483` for more details, and :mod:`typing` or :ref:`generic alias "
#~ "type <types-genericalias>` for its uses."
#~ msgstr ""
#~ "Voir la :pep:`483` pour plus de détails, et :mod:`typing` ou :ref:`alias "
#~ "générique de type <types-genericalias>` pour ses utilisations."

#~ msgid ""
#~ "A pseudo-module which programmers can use to enable new language features "
#~ "which are not compatible with the current interpreter."
#~ msgstr ""
#~ "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é."

#~ 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 à quel moment une nouvelle fonctionnalité a été rajoutée "
#~ "dans le langage et quand elle devient le comportement par défaut ::"