# 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: 2024-11-01 00:16+0100\n"

"PO-Revision-Date: 2023-10-05 22:23-0600\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.4\n"

#: glossary.rst:5

msgid "Glossary"

msgstr "Glossaire"

#: glossary.rst:10

msgid "``>>>``"

msgstr "``>>>``"

#: glossary.rst:12

#, fuzzy

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 interactif. 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

#, fuzzy

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 interactif "

"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:24

msgid "The :const:`Ellipsis` built-in constant."

msgstr "La constante :const:`Ellipsis`."

#: glossary.rst:25

msgid "abstract base class"

msgstr "classe mère abstraite"

#: glossary.rst:27

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 mères 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:38

msgid "annotation"

msgstr "annotation"

#: glossary.rst:40

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:44

msgid ""

"Annotations of local variables cannot be accessed at runtime, but "

"annotations of global variables, class attributes, and functions are stored "

"in the :attr:`__annotations__` special attribute of 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:50

msgid ""

"See :term:`variable annotation`, :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 ""

"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:54

msgid "argument"

msgstr "argument"

#: glossary.rst:56

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:59

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:67

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:76

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:81

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:84

msgid "asynchronous context manager"

msgstr "gestionnaire de contexte asynchrone"

#: glossary.rst:86

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:89

msgid "asynchronous generator"

msgstr "générateur asynchrone"

#: glossary.rst:91

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:96

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:100

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:103

msgid "asynchronous generator iterator"

msgstr "itérateur de générateur asynchrone"

#: glossary.rst:105

msgid "An object created by a :term:`asynchronous generator` function."

msgstr ""

"Objet créé par un :term:`générateur asynchrone <asynchronous generator>`."

#: glossary.rst:107

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:112

msgid ""

"Each :keyword:`yield` temporarily suspends processing, remembering the "

"location execution state (including local variables and pending try-"

"statements). When the *asynchronous generator iterator* effectively resumes "

"with another awaitable returned by :meth:`~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:117

msgid "asynchronous iterable"

msgstr "itérable asynchrone"

#: glossary.rst:119

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:122

msgid "asynchronous iterator"

msgstr "itérateur asynchrone"

#: glossary.rst:124

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:129

msgid "attribute"

msgstr "attribut"

#: glossary.rst:131

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:136

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:141

msgid "awaitable"

msgstr "attendable (*awaitable*)"

#: glossary.rst:143

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:146

msgid "BDFL"

msgstr "BDFL"

#: glossary.rst:148

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:150

msgid "binary file"

msgstr "fichier binaire"

#: glossary.rst:152

#, 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:159

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:161

msgid "borrowed reference"

msgstr "référence empruntée"

#: glossary.rst:163

#, 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:169

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:174

msgid "bytes-like object"

msgstr "objet octet-compatible"

#: glossary.rst:176

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:183

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:191

msgid "bytecode"

msgstr "code intermédiaire (*bytecode*)"

#: glossary.rst:193

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:203

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:205

msgid "callable"

msgstr "appelable (*callable*)"

#: glossary.rst:207

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:212

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:215

msgid "callback"

msgstr "fonction de rappel (*callback*)"

#: glossary.rst:217

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:219

msgid "class"

msgstr "classe"

#: glossary.rst:221

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:224

msgid "class variable"

msgstr "variable de classe"

#: glossary.rst:226

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:228

#, fuzzy

msgid "closure variable"

msgstr "variable de classe"

#: glossary.rst:230

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:235

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:246

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:250

msgid "complex number"

msgstr "nombre complexe"

#: glossary.rst:252

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:262

#, fuzzy

msgid "context"

msgstr "gestionnaire de contexte"

#: glossary.rst:264

msgid ""

"This term has different meanings depending on where and how it is used. Some "

"common meanings:"

msgstr ""

#: glossary.rst:267

msgid ""

"The temporary state or environment established by a :term:`context manager` "

"via a :keyword:`with` statement."

msgstr ""

#: glossary.rst:269

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:273

msgid ""

"A :class:`contextvars.Context` object. Also see :term:`current context`."

msgstr ""

#: glossary.rst:275

#, fuzzy

msgid "context management protocol"

msgstr "gestionnaire de contexte"

#: glossary.rst:277

msgid ""

"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by "

"the :keyword:`with` statement. See :pep:`343`."

msgstr ""

#: glossary.rst:279

msgid "context manager"

msgstr "gestionnaire de contexte"

#: glossary.rst:281

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:284

msgid "context variable"

msgstr "variable de contexte"

#: glossary.rst:286

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:290

msgid "contiguous"

msgstr "contigu"

#: glossary.rst:294

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:302

msgid "coroutine"

msgstr "coroutine"

#: glossary.rst:304

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:309

msgid "coroutine function"

msgstr "fonction coroutine"

#: glossary.rst:311

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:316

msgid "CPython"

msgstr "CPython"

#: glossary.rst:318

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:322

msgid "current context"

msgstr ""

#: glossary.rst:324

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:330

msgid "decorator"

msgstr "décorateur"

#: glossary.rst:332

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:336

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:347

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:350

msgid "descriptor"

msgstr "descripteur"

#: glossary.rst:352

#, 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:363

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:365

msgid "dictionary"

msgstr "dictionnaire"

#: glossary.rst:367

#, 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:371

msgid "dictionary comprehension"

msgstr "dictionnaire en compréhension (ou dictionnaire en intension)"

#: glossary.rst:373

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:377

msgid "dictionary view"

msgstr "vue de dictionnaire"

#: glossary.rst:379

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:385

msgid "docstring"

msgstr "chaîne de documentation (*docstring*)"

#: glossary.rst:387

#, 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:393

msgid "duck-typing"

msgstr "typage canard (*duck-typing*)"

#: glossary.rst:395

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 mère abstraites <abstract base class>`. À la place, le *duck-"

"typing* utilise plutôt :func:`hasattr` ou la programmation :term:`EAFP`."

#: glossary.rst:404

msgid "EAFP"

msgstr "EAFP"

#: glossary.rst:406

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:412

msgid "expression"

msgstr "expression"

#: glossary.rst:414

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:421

msgid "extension module"

msgstr "module d'extension"

#: glossary.rst:423

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:425

msgid "f-string"

msgstr "f-string"

#: glossary.rst:427

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:430

msgid "file object"

msgstr "objet fichier"

#: glossary.rst:432