executionmodel.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: 2025-10-17 09:58+0200\n"
"PO-Revision-Date: 2022-11-11 19:54+0100\n"
"Last-Translator: Jules Lasne <jules.lasne@gmail.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 2.4.2\n"

#: reference/executionmodel.rst:6
msgid "Execution model"
msgstr "Modèle d'exécution"

#: reference/executionmodel.rst:15
msgid "Structure of a program"
msgstr "Structure d'un programme"

#: reference/executionmodel.rst:19
msgid ""
"A Python program is constructed from code blocks. A :dfn:`block` is a piece "
"of Python program text that is executed as a unit. The following are blocks: "
"a module, a function body, and a class definition. Each command typed "
"interactively is a block.  A script file (a file given as standard input to "
"the interpreter or specified as a command line argument to the interpreter) "
"is a code block.  A script command (a command specified on the interpreter "
"command line with the :option:`-c` option) is a code block. A module run as "
"a top level script (as module ``__main__``) from the command line using "
"a :option:`-m` argument is also a code block. The string argument passed to "
"the built-in functions :func:`eval` and :func:`exec` is a code block."
msgstr ""
"Un programme Python est construit à partir de blocs de code. Un :dfn:`bloc` "
"est un morceau de texte de programme Python qui est exécuté en tant "
"qu'unité. Les éléments suivants sont des blocs : un module, un corps de "
"fonction et une définition de classe. Chaque commande écrite dans "
"l'interpréteur interactif de Python est un bloc. Un fichier de script (un "
"fichier donné en entrée standard à l'interpréteur ou spécifié en tant "
"qu'argument de ligne de commande à l'interpréteur) est un bloc de code. Une "
"commande de script (une commande spécifiée en ligne de commande à "
"l'interpréteur avec l'option :option:`-c`) est un bloc de code. Un module "
"exécuté en tant que script principal (module ``__main__``) depuis la ligne "
"de commande en utilisant l'option :option:`-m` est aussi un bloc de code. La "
"chaîne passée en argument aux fonctions natives :func:`eval` et :func:`exec` "
"est un bloc de code."

#: reference/executionmodel.rst:33
msgid ""
"A code block is executed in an :dfn:`execution frame`.  A frame contains "
"some administrative information (used for debugging) and determines where "
"and how execution continues after the code block's execution has completed."
msgstr ""
"Un bloc de code est exécuté dans un :dfn:`cadre d'exécution`. Un cadre "
"contient des informations administratives (utilisées pour le débogage) et "
"détermine où et comment l'exécution se poursuit après la fin de l'exécution "
"du bloc de code."

#: reference/executionmodel.rst:40
msgid "Naming and binding"
msgstr "Noms et liaisons"

#: reference/executionmodel.rst:49
msgid "Binding of names"
msgstr "Liaisons des noms"

#: reference/executionmodel.rst:55
msgid ""
":dfn:`Names` refer to objects.  Names are introduced by name binding "
"operations."
msgstr ""
"Les :dfn:`noms` sont des références aux objets. Ils sont créés lors des "
"opérations de liaisons de noms (*name binding* en anglais)."

#: reference/executionmodel.rst:59
msgid "The following constructs bind names:"
msgstr "Les noms sont liés *via* les constructions suivantes :"

#: reference/executionmodel.rst:61
msgid "formal parameters to functions,"
msgstr "paramètres formels de fonctions,"

#: reference/executionmodel.rst:62
msgid "class definitions,"
msgstr "définitions de classes,"

#: reference/executionmodel.rst:63
msgid "function definitions,"
msgstr "définitions de fonctions,"

#: reference/executionmodel.rst:64
msgid "assignment expressions,"
msgstr "expressions d'affectation,"

#: reference/executionmodel.rst:65
msgid ""
":ref:`targets <assignment>` that are identifiers if occurring in an "
"assignment:"
msgstr ""
":ref:`cibles <assignment>` qui sont des identifiants, lorsque c'est une "
"affectation :"

#: reference/executionmodel.rst:68
msgid ":keyword:`for` loop header,"
msgstr "de l'entête d'une boucle :keyword:`for`,"

#: reference/executionmodel.rst:69
msgid ""
"after :keyword:`!as` in a :keyword:`with` statement, :keyword:`except` "
"clause, :keyword:`except* <except_star>` clause, or in the as-pattern in "
"structural pattern matching,"
msgstr ""
"après :keyword:`!as` dans une instruction :keyword:`with`, dans une "
"clause :keyword:`except`, dans une clause :keyword:`except* <except_star>` "
"ou dans un filtrage par motifs,"

#: reference/executionmodel.rst:71
msgid "in a capture pattern in structural pattern matching"
msgstr "dans un champ de recherche d'un filtre de capture,"

#: reference/executionmodel.rst:73
msgid ":keyword:`import` statements."
msgstr "des instructions :keyword:`import`."

#: reference/executionmodel.rst:74
#, fuzzy
msgid ":keyword:`type` statements."
msgstr "des instructions :keyword:`import`."

#: reference/executionmodel.rst:75
msgid ":ref:`type parameter lists <type-params>`."
msgstr ""

#: reference/executionmodel.rst:77
msgid ""
"The :keyword:`!import` statement of the form ``from ... import *`` binds all "
"names defined in the imported module, except those beginning with an "
"underscore. This form may only be used at the module level."
msgstr ""
"L'instruction :keyword:`!import` sous la forme ``from … import *`` lie tous "
"les noms définis dans le module importé, sauf ceux qui commencent par le "
"caractère souligné. Cette écriture ne peut être utilisée qu'au niveau du "
"module."

#: reference/executionmodel.rst:81
msgid ""
"A target occurring in a :keyword:`del` statement is also considered bound "
"for this purpose (though the actual semantics are to unbind the name)."
msgstr ""
"Une cible qui apparaît dans une instruction :keyword:`del` est aussi "
"considérée comme une liaison à un nom dans ce cadre (bien que la sémantique "
"véritable soit de délier le nom)."

#: reference/executionmodel.rst:84
msgid ""
"Each assignment or import statement occurs within a block defined by a class "
"or function definition or at the module level (the top-level code block)."
msgstr ""
"Chaque affectation ou instruction *import* a lieu dans un bloc défini par "
"une définition de classe ou de fonction, ou au niveau du module (le bloc de "
"code de plus haut niveau)."

#: reference/executionmodel.rst:89
#, fuzzy
msgid ""
"If a name is bound in a block, it is a local variable of that block, unless "
"declared as :keyword:`nonlocal` or :keyword:`global`.  If a name is bound at "
"the module level, it is a global variable.  (The variables of the module "
"code block are local and global.)  If a variable is used in a code block but "
"not defined there, it is a :term:`free variable`."
msgstr ""
"Si un nom est lié dans un bloc, c'est une variable locale de ce bloc, à "
"moins qu'il ne soit déclaré :keyword:`nonlocal` ou :keyword:`global`. Si un "
"nom est lié au niveau du module, c'est une variable globale (les variables "
"du bloc de code de niveau module sont locales et globales). Si une variable "
"est utilisée dans un bloc de code alors qu'elle n'y est pas définie, c'est "
"une :dfn:`variable libre`."

#: reference/executionmodel.rst:95
msgid ""
"Each occurrence of a name in the program text refers to the :dfn:`binding` "
"of that name established by the following name resolution rules."
msgstr ""
"Chaque occurrence d'un nom dans un programme fait référence à "
"la :dfn:`liaison` de ce nom établie par les règles de résolution des noms "
"suivantes."

#: reference/executionmodel.rst:101
msgid "Resolution of names"
msgstr "Résolution des noms"

#: reference/executionmodel.rst:105
msgid ""
"A :dfn:`scope` defines the visibility of a name within a block.  If a local "
"variable is defined in a block, its scope includes that block.  If the "
"definition occurs in a function block, the scope extends to any blocks "
"contained within the defining one, unless a contained block introduces a "
"different binding for the name."
msgstr ""
"La :dfn:`portée` définit la visibilité d'un nom dans un bloc. Si une "
"variable locale est définie dans un bloc, sa portée comprend ce bloc. Si la "
"définition intervient dans le bloc d'une fonction, la portée s'étend à tous "
"les blocs contenus dans celui qui comprend la définition, à moins qu'un bloc "
"intérieur ne définisse une autre liaison pour ce nom."

#: reference/executionmodel.rst:113
msgid ""
"When a name is used in a code block, it is resolved using the nearest "
"enclosing scope.  The set of all such scopes visible to a code block is "
"called the block's :dfn:`environment`."
msgstr ""
"Quand un nom est utilisé dans un bloc de code, la résolution utilise la "
"portée la plus petite. L'ensemble de toutes les portées visibles dans un "
"bloc de code s'appelle :dfn:`l'environnement` du bloc."

#: reference/executionmodel.rst:121
msgid ""
"When a name is not found at all, a :exc:`NameError` exception is raised. If "
"the current scope is a function scope, and the name refers to a local "
"variable that has not yet been bound to a value at the point where the name "
"is used, an :exc:`UnboundLocalError` exception is "
"raised. :exc:`UnboundLocalError` is a subclass of :exc:`NameError`."
msgstr ""
"Quand un nom n'est trouvé nulle part, une exception :exc:`NameError` est "
"levée. Si la portée courante est celle d'une fonction et que le nom fait "
"référence à une variable locale qui n'a pas encore été liée au moment où le "
"nom est utilisé, une exception :exc:`UnboundLocalError` est "
"levée. :exc:`UnboundLocalError` est une sous-classe de :exc:`NameError`."

#: reference/executionmodel.rst:127
msgid ""
"If a name binding operation occurs anywhere within a code block, all uses of "
"the name within the block are treated as references to the current block.  "
"This can lead to errors when a name is used within a block before it is "
"bound.  This rule is subtle.  Python lacks declarations and allows name "
"binding operations to occur anywhere within a code block.  The local "
"variables of a code block can be determined by scanning the entire text of "
"the block for name binding operations. See :ref:`the FAQ entry on "
"UnboundLocalError <faq-unboundlocalerror>` for examples."
msgstr ""
"Si une opération de liaison intervient dans un bloc de code, toutes les "
"utilisations du nom dans le bloc sont considérées comme des références au "
"bloc courant. Ceci peut conduire à des erreurs quand un nom est utilisé à "
"l'intérieur d'un bloc avant d'être lié. La règle est subtile. Python "
"n'attend pas de déclaration de variables et autorise les opérations de "
"liaison n'importe où dans un bloc de code. Les variables locales d'un bloc "
"de code peuvent être déterminées en parcourant tout le texte du bloc à la "
"recherche des opérations de liaisons. Reportez-vous à :ref:`l'entrée de la "
"FAQ relative à UnboundLocalError <faq-unboundlocalerror>` pour des exemples."

#: reference/executionmodel.rst:136
#, fuzzy
msgid ""
"If the :keyword:`global` statement occurs within a block, all uses of the "
"names specified in the statement refer to the bindings of those names in the "
"top-level namespace.  Names are resolved in the top-level namespace by "
"searching the global namespace, i.e. the namespace of the module containing "
"the code block, and the builtins namespace, the namespace of the "
"module :mod:`builtins`.  The global namespace is searched first.  If the "
"names are not found there, the builtins namespace is searched next. If the "
"names are also not found in the builtins namespace, new variables are "
"created in the global namespace. The global statement must precede all uses "
"of the listed names."
msgstr ""
"Si l'instruction :keyword:`global` apparaît dans un bloc, toutes les "
"utilisations du nom spécifié dans l'instruction font référence à la liaison "
"de ce nom dans l'espace de nommage de plus haut niveau. Les noms sont "
"résolus dans cet espace de nommage de plus haut niveau en recherchant "
"l'espace des noms globaux, c'est-à-dire l'espace de nommage du module "
"contenant le bloc de code ainsi que dans l'espace de nommage natif, celui du "
"module :mod:`builtins`. La recherche commence dans l'espace de nommage "
"global. Si le nom n'y est pas trouvé, la recherche se poursuit dans l'espace "
"de nommage natif. L'instruction :keyword:`!global` doit précéder toute "
"utilisation des noms considérés."

#: reference/executionmodel.rst:146
msgid ""
"The :keyword:`global` statement has the same scope as a name binding "
"operation in the same block.  If the nearest enclosing scope for a free "
"variable contains a global statement, the free variable is treated as a "
"global."
msgstr ""
"L'instruction :keyword:`global` a la même porte qu'une opération de liaison "
"du même bloc. Si la portée englobante la plus petite pour une variable libre "
"contient une instruction *global*, la variable libre est considérée globale."

#: reference/executionmodel.rst:152
#, fuzzy
msgid ""
"The :keyword:`nonlocal` statement causes corresponding names to refer to "
"previously bound variables in the nearest enclosing function "
"scope. :exc:`SyntaxError` is raised at compile time if the given name does "
"not exist in any enclosing function scope. :ref:`Type parameters <type-"
"params>` cannot be rebound with the :keyword:`!nonlocal` statement."
msgstr ""
"L'instruction :keyword:`nonlocal` fait que les noms correspondants font "
"référence aux variables liées précédemment dans la portée de fonction "
"englobante la plus petite possible. :exc:`SyntaxError` est levée à la "
"compilation si le nom donné n'existe dans aucune portée de fonction "
"englobante."

#: reference/executionmodel.rst:160
msgid ""
"The namespace for a module is automatically created the first time a module "
"is imported.  The main module for a script is always called :mod:`__main__`."
msgstr ""
"L'espace de nommage pour un module est créé automatiquement la première fois "
"que le module est importé. Le module principal d'un script s'appelle "
"toujours :mod:`__main__`."

#: reference/executionmodel.rst:163
#, fuzzy
msgid ""
"Class definition blocks and arguments to :func:`exec` and :func:`eval` are "
"special in the context of name resolution. A class definition is an "
"executable statement that may use and define names. These references follow "
"the normal rules for name resolution with an exception that unbound local "
"variables are looked up in the global namespace. The namespace of the class "
"definition becomes the attribute dictionary of the class. The scope of names "
"defined in a class block is limited to the class block; it does not extend "
"to the code blocks of methods. This includes comprehensions and generator "
"expressions, but it does not include :ref:`annotation scopes <annotation-"
"scopes>`, which have access to their enclosing class scopes. This means that "
"the following will fail::"
msgstr ""
"Les blocs de définition de classe et les arguments de :func:`exec` ainsi "
"que :func:`eval` sont traités de manière spéciale dans le cadre de la "
"résolution des noms. Une définition de classe est une instruction exécutable "
"qui peut utiliser et définir des noms. Toutes ces références suivent les "
"règles normales de la résolution des noms à l'exception des variables "
"locales non liées qui sont recherchées dans l'espace des noms globaux. "
"L'espace de nommage de la définition de classe devient le dictionnaire des "
"attributs de la classe. La portée des noms définis dans un bloc de classe "
"est limitée au bloc de la classe ; elle ne s'étend pas aux blocs de code des "
"méthodes — y compris les compréhensions et les expressions générateurs "
"puisque celles-ci sont implémentées en utilisant une portée de fonction. "
"Ainsi, les instructions suivantes échouent ::"

#: reference/executionmodel.rst:180
msgid "However, the following will succeed::"
msgstr ""

#: reference/executionmodel.rst:191
msgid "Annotation scopes"
msgstr ""

#: reference/executionmodel.rst:193
msgid ""
":term:`Annotations <annotation>`, :ref:`type parameter lists <type-params>` "
"and :keyword:`type` statements introduce *annotation scopes*, which behave "
"mostly like function scopes, but with some exceptions discussed below."
msgstr ""

#: reference/executionmodel.rst:198
msgid "Annotation scopes are used in the following contexts:"
msgstr ""

#: reference/executionmodel.rst:200
msgid ":term:`Function annotations <function annotation>`."
msgstr ""

#: reference/executionmodel.rst:201
msgid ":term:`Variable annotations <variable annotation>`."
msgstr ""

#: reference/executionmodel.rst:202
msgid ""
"Type parameter lists for :ref:`generic type aliases <generic-type-aliases>`."
msgstr ""

#: reference/executionmodel.rst:203
msgid ""
"Type parameter lists for :ref:`generic functions <generic-functions>`. A "
"generic function's annotations are executed within the annotation scope, but "
"its defaults and decorators are not."
msgstr ""

#: reference/executionmodel.rst:206
msgid ""
"Type parameter lists for :ref:`generic classes <generic-classes>`. A generic "
"class's base classes and keyword arguments are executed within the "
"annotation scope, but its decorators are not."
msgstr ""

#: reference/executionmodel.rst:209
msgid ""
"The bounds, constraints, and default values for type parameters "
"(:ref:`lazily evaluated <lazy-evaluation>`)."
msgstr ""

#: reference/executionmodel.rst:211
msgid "The value of type aliases (:ref:`lazily evaluated <lazy-evaluation>`)."
msgstr ""

#: reference/executionmodel.rst:213
msgid "Annotation scopes differ from function scopes in the following ways:"
msgstr ""

#: reference/executionmodel.rst:215
msgid ""
"Annotation scopes have access to their enclosing class namespace. If an "
"annotation scope is immediately within a class scope, or within another "
"annotation scope that is immediately within a class scope, the code in the "
"annotation scope can use names defined in the class scope as if it were "
"executed directly within the class body. This contrasts with regular "
"functions defined within classes, which cannot access names defined in the "
"class scope."
msgstr ""

#: reference/executionmodel.rst:221
msgid ""
"Expressions in annotation scopes cannot contain :keyword:`yield`, ``yield "
"from``, :keyword:`await`, or :token:`:= <python-"
"grammar:assignment_expression>` expressions. (These expressions are allowed "
"in other scopes contained within the annotation scope.)"
msgstr ""

#: reference/executionmodel.rst:225
msgid ""
"Names defined in annotation scopes cannot be rebound "
"with :keyword:`nonlocal` statements in inner scopes. This includes only type "
"parameters, as no other syntactic elements that can appear within annotation "
"scopes can introduce new names."
msgstr ""

#: reference/executionmodel.rst:228
msgid ""
"While annotation scopes have an internal name, that name is not reflected in "
"the :term:`qualified name` of objects defined within the scope. Instead, "
"the :attr:`~definition.__qualname__` of such objects is as if the object "
"were defined in the enclosing scope."
msgstr ""

#: reference/executionmodel.rst:233
msgid "Annotation scopes were introduced in Python 3.12 as part of :pep:`695`."
msgstr ""

#: reference/executionmodel.rst:236
msgid ""
"Annotation scopes are also used for type parameter defaults, as introduced "
"by :pep:`696`."
msgstr ""

#: reference/executionmodel.rst:240
msgid ""
"Annotation scopes are now also used for annotations, as specified "
"in :pep:`649` and :pep:`749`."
msgstr ""

#: reference/executionmodel.rst:247
msgid "Lazy evaluation"
msgstr ""

#: reference/executionmodel.rst:249
msgid ""
"Most annotation scopes are *lazily evaluated*. This includes annotations, "
"the values of type aliases created through the :keyword:`type` statement, "
"and the bounds, constraints, and default values of type variables created "
"through the :ref:`type parameter syntax <type-params>`. This means that they "
"are not evaluated when the type alias or type variable is created, or when "
"the object carrying annotations is created. Instead, they are only evaluated "
"when necessary, for example when the ``__value__`` attribute on a type alias "
"is accessed."
msgstr ""

#: reference/executionmodel.rst:258
msgid "Example:"
msgstr "Exemple :"

#: reference/executionmodel.rst:274
msgid ""
"Here the exception is raised only when the ``__value__`` attribute of the "
"type alias or the ``__bound__`` attribute of the type variable is accessed."
msgstr ""

#: reference/executionmodel.rst:278
msgid ""
"This behavior is primarily useful for references to types that have not yet "
"been defined when the type alias or type variable is created. For example, "
"lazy evaluation enables creation of mutually recursive type aliases::"
msgstr ""

#: reference/executionmodel.rst:288
msgid ""
"Lazily evaluated values are evaluated in :ref:`annotation scope <annotation-"
"scopes>`, which means that names that appear inside the lazily evaluated "
"value are looked up as if they were used in the immediately enclosing scope."
msgstr ""

#: reference/executionmodel.rst:297
msgid "Builtins and restricted execution"
msgstr "Noms natifs et restrictions d'exécution"

#: reference/executionmodel.rst:303
msgid ""
"Users should not touch ``__builtins__``; it is strictly an implementation "
"detail.  Users wanting to override values in the builtins namespace "
"should :keyword:`import` the :mod:`builtins` module and modify its "
"attributes appropriately."
msgstr ""
"l'utilisateur ne doit pas toucher à ``__builtins__`` ; c'est et cela doit "
"rester réservé aux besoins de l'implémentation. Les utilisateurs qui "
"souhaitent surcharger des valeurs dans l'espace de nommage natif "
"doivent :keyword:`importer <import>` le module :mod:`builtins` et modifier "
"ses attributs judicieusement."

#: reference/executionmodel.rst:308
msgid ""
"The builtins namespace associated with the execution of a code block is "
"actually found by looking up the name ``__builtins__`` in its global "
"namespace; this should be a dictionary or a module (in the latter case the "
"module's dictionary is used).  By default, when in the :mod:`__main__` "
"module, ``__builtins__`` is the built-in module :mod:`builtins`; when in any "
"other module, ``__builtins__`` is an alias for the dictionary of "
"the :mod:`builtins` module itself."
msgstr ""
"L'espace de nommage natif associé à l'exécution d'un bloc de code est "
"effectivement trouvé en cherchant le nom ``__builtins__`` dans l'espace de "
"nommage globaux ; ce doit être un dictionnaire ou un module (dans ce dernier "
"cas, le dictionnaire du module est utilisé). Par défaut, lorsque l'on se "
"trouve dans le module :mod:`__main__`, ``__builtins__`` est le module "
"natif :mod:`builtins` ; lorsque l'on se trouve dans tout autre module, "
"``__builtins__`` est un pseudonyme du dictionnaire du module :mod:`builtins` "
"lui-même."

#: reference/executionmodel.rst:320
msgid "Interaction with dynamic features"
msgstr "Interaction avec les fonctionnalités dynamiques"

#: reference/executionmodel.rst:322
msgid ""
"Name resolution of free variables occurs at runtime, not at compile time. "
"This means that the following code will print 42::"
msgstr ""
"La résolution des noms de variables libres intervient à l'exécution, pas à "
"la compilation. Cela signifie que le code suivant affiche 42 ::"

#: reference/executionmodel.rst:333
msgid ""
"The :func:`eval` and :func:`exec` functions do not have access to the full "
"environment for resolving names.  Names may be resolved in the local and "
"global namespaces of the caller.  Free variables are not resolved in the "
"nearest enclosing namespace, but in the global namespace.  [#]_ "
"The :func:`exec` and :func:`eval` functions have optional arguments to "
"override the global and local namespace.  If only one namespace is "
"specified, it is used for both."
msgstr ""
"Les fonctions :func:`eval` et :func:`exec` n'ont pas accès à l'environnement "
"complet pour résoudre les noms. Les noms doivent être résolus dans les "
"espaces de nommage locaux et globaux de l'appelant. Les variables libres ne "
"sont pas résolues dans l'espace de nommage englobant le plus proche mais "
"dans l'espace de nommage globaux [#]_. Les fonctions :func:`eval` "
"et :func:`exec` possèdent des arguments optionnels pour surcharger les "
"espaces de nommage globaux et locaux. Si seulement un espace de nommage est "
"spécifié, il est utilisé pour les deux."

#: reference/executionmodel.rst:347
msgid "Exceptions"
msgstr "Exceptions"

#: reference/executionmodel.rst:358
msgid ""
"Exceptions are a means of breaking out of the normal flow of control of a "
"code block in order to handle errors or other exceptional conditions.  An "
"exception is *raised* at the point where the error is detected; it may be "
"*handled* by the surrounding code block or by any code block that directly "
"or indirectly invoked the code block where the error occurred."
msgstr ""
"Les exceptions sont un moyen de sortir du flot normal d'exécution d'un bloc "
"de code de manière à gérer des erreurs ou des conditions exceptionnelles. "
"Une exception est *levée* au moment où l'erreur est détectée ; elle doit "
"être *gérée* par le bloc de code qui l'entoure ou par tout bloc de code qui "
"a, directement ou indirectement, invoqué le bloc de code où l'erreur s'est "
"produite."

#: reference/executionmodel.rst:364
msgid ""
"The Python interpreter raises an exception when it detects a run-time error "
"(such as division by zero).  A Python program can also explicitly raise an "
"exception with the :keyword:`raise` statement. Exception handlers are "
"specified with the :keyword:`try` ... :keyword:`except` statement.  "
"The :keyword:`finally` clause of such a statement can be used to specify "
"cleanup code which does not handle the exception, but is executed whether an "
"exception occurred or not in the preceding code."
msgstr ""
"L'interpréteur Python lève une exception quand il détecte une erreur à "
"l'exécution (telle qu'une division par zéro). Un programme Python peut aussi "
"lever explicitement une exception avec l'instruction :keyword:`raise`. Les "
"gestionnaires d'exception sont spécifiés avec l'instruction :keyword:`try` "
"… :keyword:`except`. La clause :keyword:`finally` d'une telle instruction "
"peut être utilisée pour spécifier un code de nettoyage qui ne gère pas "
"l'exception mais qui est exécuté quoi qu'il arrive (exception ou pas)."

#: reference/executionmodel.rst:374
msgid ""
"Python uses the \"termination\" model of error handling: an exception "
"handler can find out what happened and continue execution at an outer level, "
"but it cannot repair the cause of the error and retry the failing operation "
"(except by re-entering the offending piece of code from the top)."
msgstr ""
"Python utilise le modèle par *terminaison* de gestion des erreurs : un "
"gestionnaire d'exception peut trouver ce qui est arrivé et continuer "
"l'exécution à un niveau plus élevé, mais il ne peut pas réparer l'origine de "
"l'erreur et ré-essayer l'opération qui a échoué (sauf à entrer à nouveau "
"dans le code en question par le haut)."

#: reference/executionmodel.rst:381
msgid ""
"When an exception is not handled at all, the interpreter terminates "
"execution of the program, or returns to its interactive main loop.  In "
"either case, it prints a stack traceback, except when the exception "
"is :exc:`SystemExit`."
msgstr ""
"Quand une exception n'est pas du tout gérée, l'interpréteur termine "
"l'exécution du programme ou retourne à la boucle interactive. Dans ces cas, "
"il affiche une trace de la pile d'appels, sauf si l'exception "
"est :exc:`SystemExit`."

#: reference/executionmodel.rst:385
msgid ""
"Exceptions are identified by class instances.  The :keyword:`except` clause "
"is selected depending on the class of the instance: it must reference the "
"class of the instance or a :term:`non-virtual base class <abstract base "
"class>` thereof. The instance can be received by the handler and can carry "
"additional information about the exceptional condition."
msgstr ""
"Les exceptions sont identifiées par des instances de classe. La "
"clause :keyword:`except` sélectionnée dépend de la classe de l'instance : "
"elle doit faire référence à la classe de l'instance ou à une de "
"ses :term:`classes ancêtres non virtuelles <abstract base class>`. "
"L'instance peut être transmise au gestionnaire et peut apporter des "
"informations complémentaires sur les conditions de l'exception."

#: reference/executionmodel.rst:393
msgid ""
"Exception messages are not part of the Python API.  Their contents may "
"change from one version of Python to the next without warning and should not "
"be relied on by code which will run under multiple versions of the "
"interpreter."
msgstr ""
"Les messages d'exception ne font pas partie de l'API Python. Leur contenu "
"peut changer d'une version de Python à une autre sans avertissement et le "
"code ne doit pas reposer sur ceux-ci s'il doit fonctionner sur plusieurs "
"versions de l'interpréteur."

#: reference/executionmodel.rst:397
msgid ""
"See also the description of the :keyword:`try` statement in "
"section :ref:`try` and :keyword:`raise` statement in section :ref:`raise`."
msgstr ""
"Reportez-vous aussi aux descriptions de l'instruction :keyword:`try` dans la "
"section :ref:`try` et de l'instruction :keyword:`raise` dans la "
"section :ref:`raise`."

#: reference/executionmodel.rst:404
msgid "Runtime Components"
msgstr ""

#: reference/executionmodel.rst:407
msgid "General Computing Model"
msgstr ""

#: reference/executionmodel.rst:409
msgid ""
"Python's execution model does not operate in a vacuum.  It runs on a host "
"machine and through that host's runtime environment, including its operating "
"system (OS), if there is one.  When a program runs, the conceptual layers of "
"how it runs on the host look something like this:"
msgstr ""

#: reference/executionmodel.rst:0
msgid "**host machine**"
msgstr ""

#: reference/executionmodel.rst:0
msgid "**process** (global resources)"
msgstr ""

#: reference/executionmodel.rst:0
msgid "**thread** (runs machine code)"
msgstr ""

#: reference/executionmodel.rst:419
msgid ""
"Each process represents a program running on the host.  Think of each "
"process itself as the data part of its program.  Think of the process' "
"threads as the execution part of the program.  This distinction will be "
"important to understand the conceptual Python runtime."
msgstr ""

#: reference/executionmodel.rst:424
msgid ""
"The process, as the data part, is the execution context in which the program "
"runs.  It mostly consists of the set of resources assigned to the program by "
"the host, including memory, signals, file handles, sockets, and environment "
"variables."
msgstr ""

#: reference/executionmodel.rst:429
msgid ""
"Processes are isolated and independent from one another.  (The same is true "
"for hosts.)  The host manages the process' access to its assigned resources, "
"in addition to coordinating between processes."
msgstr ""

#: reference/executionmodel.rst:433
msgid ""
"Each thread represents the actual execution of the program's machine code, "
"running relative to the resources assigned to the program's process.  It's "
"strictly up to the host how and when that execution takes place."
msgstr ""

#: reference/executionmodel.rst:438
msgid ""
"From the point of view of Python, a program always starts with exactly one "
"thread.  However, the program may grow to run in multiple simultaneous "
"threads.  Not all hosts support multiple threads per process, but most do.  "
"Unlike processes, threads in a process are not isolated and independent from "
"one another.  Specifically, all threads in a process share all of the "
"process' resources."
msgstr ""

#: reference/executionmodel.rst:445
msgid ""
"The fundamental point of threads is that each one does *run* independently, "
"at the same time as the others.  That may be only conceptually at the same "
"time (\"concurrently\") or physically (\"in parallel\").  Either way, the "
"threads effectively run at a non-synchronized rate."
msgstr ""

#: reference/executionmodel.rst:453
msgid ""
"That non-synchronized rate means none of the process' memory is guaranteed "
"to stay consistent for the code running in any given thread.  Thus multi-"
"threaded programs must take care to coordinate access to intentionally "
"shared resources.  Likewise, they must take care to be absolutely diligent "
"about not accessing any *other* resources in multiple threads; otherwise two "
"threads running at the same time might accidentally interfere with each "
"other's use of some shared data.  All this is true for both Python programs "
"and the Python runtime."
msgstr ""

#: reference/executionmodel.rst:463
msgid ""
"The cost of this broad, unstructured requirement is the tradeoff for the "
"kind of raw concurrency that threads provide.  The alternative to the "
"required discipline generally means dealing with non-deterministic bugs and "
"data corruption."
msgstr ""

#: reference/executionmodel.rst:469
msgid "Python Runtime Model"
msgstr ""

#: reference/executionmodel.rst:471
msgid ""
"The same conceptual layers apply to each Python program, with some extra "
"data layers specific to Python:"
msgstr ""

#: reference/executionmodel.rst:0
msgid "Python global runtime (*state*)"
msgstr ""

#: reference/executionmodel.rst:0
msgid "Python interpreter (*state*)"
msgstr ""

#: reference/executionmodel.rst:0
msgid "**thread** (runs Python bytecode and \"C-API\")"
msgstr ""

#: reference/executionmodel.rst:0
msgid "Python thread *state*"
msgstr ""

#: reference/executionmodel.rst:481
msgid ""
"At the conceptual level: when a Python program starts, it looks exactly like "
"that diagram, with one of each.  The runtime may grow to include multiple "
"interpreters, and each interpreter may grow to include multiple thread "
"states."
msgstr ""

#: reference/executionmodel.rst:488
msgid ""
"A Python implementation won't necessarily implement the runtime layers "
"distinctly or even concretely.  The only exception is places where distinct "
"layers are directly specified or exposed to users, like through "
"the :mod:`threading` module."
msgstr ""

#: reference/executionmodel.rst:495
msgid ""
"The initial interpreter is typically called the \"main\" interpreter. Some "
"Python implementations, like CPython, assign special roles to the main "
"interpreter."
msgstr ""

#: reference/executionmodel.rst:499
msgid ""
"Likewise, the host thread where the runtime was initialized is known as the "
"\"main\" thread.  It may be different from the process' initial thread, "
"though they are often the same.  In some cases \"main thread\" may be even "
"more specific and refer to the initial thread state. A Python runtime might "
"assign specific responsibilities to the main thread, such as handling "
"signals."
msgstr ""

#: reference/executionmodel.rst:506
msgid ""
"As a whole, the Python runtime consists of the global runtime state, "
"interpreters, and thread states.  The runtime ensures all that state stays "
"consistent over its lifetime, particularly when used with multiple host "
"threads."
msgstr ""

#: reference/executionmodel.rst:511
msgid ""
"The global runtime, at the conceptual level, is just a set of interpreters.  "
"While those interpreters are otherwise isolated and independent from one "
"another, they may share some data or other resources.  The runtime is "
"responsible for managing these global resources safely.  The actual nature "
"and management of these resources is implementation-specific.  Ultimately, "
"the external utility of the global runtime is limited to managing "
"interpreters."
msgstr ""

#: reference/executionmodel.rst:519
msgid ""
"In contrast, an \"interpreter\" is conceptually what we would normally think "
"of as the (full-featured) \"Python runtime\".  When machine code executing "
"in a host thread interacts with the Python runtime, it calls into Python in "
"the context of a specific interpreter."
msgstr ""

#: reference/executionmodel.rst:526
msgid ""
"The term \"interpreter\" here is not the same as the \"bytecode "
"interpreter\", which is what regularly runs in threads, executing compiled "
"Python code."
msgstr ""

#: reference/executionmodel.rst:530
msgid ""
"In an ideal world, \"Python runtime\" would refer to what we currently call "
"\"interpreter\".  However, it's been called \"interpreter\" at least since "
"introduced in 1997 (`CPython:a027efa5b`_)."
msgstr ""

#: reference/executionmodel.rst:536
msgid ""
"Each interpreter completely encapsulates all of the non-process-global, non-"
"thread-specific state needed for the Python runtime to work. Notably, the "
"interpreter's state persists between uses.  It includes fundamental data "
"like :data:`sys.modules`.  The runtime ensures multiple threads using the "
"same interpreter will safely share it between them."
msgstr ""

#: reference/executionmodel.rst:543
msgid ""
"A Python implementation may support using multiple interpreters at the same "
"time in the same process.  They are independent and isolated from one "
"another.  For example, each interpreter has its own :data:`sys.modules`."
msgstr ""

#: reference/executionmodel.rst:548
msgid ""
"For thread-specific runtime state, each interpreter has a set of thread "
"states, which it manages, in the same way the global runtime contains a set "
"of interpreters.  It can have thread states for as many host threads as it "
"needs.  It may even have multiple thread states for the same host thread, "
"though that isn't as common."
msgstr ""

#: reference/executionmodel.rst:554
msgid ""
"Each thread state, conceptually, has all the thread-specific runtime data an "
"interpreter needs to operate in one host thread.  The thread state includes "
"the current raised exception and the thread's Python call stack.  It may "
"include other thread-specific resources."
msgstr ""

#: reference/executionmodel.rst:561
msgid ""
"The term \"Python thread\" can sometimes refer to a thread state, but "
"normally it means a thread created using the :mod:`threading` module."
msgstr ""

#: reference/executionmodel.rst:564
msgid ""
"Each thread state, over its lifetime, is always tied to exactly one "
"interpreter and exactly one host thread.  It will only ever be used in that "
"thread and with that interpreter."
msgstr ""

#: reference/executionmodel.rst:568
msgid ""
"Multiple thread states may be tied to the same host thread, whether for "
"different interpreters or even the same interpreter.  However, for any given "
"host thread, only one of the thread states tied to it can be used by the "
"thread at a time."
msgstr ""

#: reference/executionmodel.rst:573
msgid ""
"Thread states are isolated and independent from one another and don't share "
"any data, except for possibly sharing an interpreter and objects or other "
"resources belonging to that interpreter."
msgstr ""

#: reference/executionmodel.rst:577
msgid ""
"Once a program is running, new Python threads can be created using "
"the :mod:`threading` module (on platforms and Python implementations that "
"support threads).  Additional processes can be created using "
"the :mod:`os`, :mod:`subprocess`, and :mod:`multiprocessing` modules. "
"Interpreters can be created and used with "
"the :mod:`~concurrent.interpreters` module.  Coroutines (async) can be run "
"using :mod:`asyncio` in each interpreter, typically only in a single thread "
"(often the main thread)."
msgstr ""

#: reference/executionmodel.rst:588
msgid "Footnotes"
msgstr "Notes"

#: reference/executionmodel.rst:589
msgid ""
"This limitation occurs because the code that is executed by these operations "
"is not available at the time the module is compiled."
msgstr ""
"En effet, le code qui est exécuté par ces opérations n'est pas connu au "
"moment où le module est compilé."

#, fuzzy
#~ msgid "execution model"
#~ msgstr "Modèle d'exécution"

#~ msgid "code"
#~ msgstr "code"

#~ msgid "execution"
#~ msgstr "exécution"

#~ msgid "frame"
#~ msgstr "cadre"

#~ msgid "namespace"
#~ msgstr "espace de noms"

#~ msgid "name"
#~ msgstr "nom"

#~ msgid "binding"
#~ msgstr "liaison"

#~ msgid "from"
#~ msgstr "from"

#~ msgid "import statement"
#~ msgstr "instruction *import*"

#~ msgid "variable"
#~ msgstr "variable"

#~ msgid "module"
#~ msgstr "module"

#~ msgid "__main__"
#~ msgstr "__main__"

#~ msgid "exception"
#~ msgstr "exception"

#~ msgid "termination model"
#~ msgstr "modèle de fin d'exécution"

#~ msgid ""
#~ "The following constructs bind names: formal parameters to "
#~ "functions, :keyword:`import` statements, class and function definitions "
#~ "(these bind the class or function name in the defining block), and "
#~ "targets that are identifiers if occurring in an "
#~ "assignment, :keyword:`for` loop header, or after :keyword:`!as` in "
#~ "a :keyword:`with` statement or :keyword:`except` clause. The :keyword:`!"
#~ "import` statement of the form ``from ... import *`` binds all names "
#~ "defined in the imported module, except those beginning with an "
#~ "underscore.  This form may only be used at the module level."
#~ msgstr ""
#~ "Les constructions suivantes conduisent à des opérations de liaison à des "
#~ "noms : les paramètres formels d'une fonction, les "
#~ "instructions :keyword:`import`, les définitions de fonctions et de "
#~ "classes (le nom de la classe ou de la fonction est lié au bloc qui la "
#~ "définit) et les cibles qui sont des identifiants dans les assignations, "
#~ "les entêtes de boucles :keyword:`for` ou après :keyword:`!as` dans une "
#~ "instruction :keyword:`with` ou une clause :keyword:`except`. "
#~ "L'instruction :keyword:`!import` sous la forme ``from ... import *`` lie "
#~ "tous les noms définis dans le module importé, sauf ceux qui commencent "
#~ "par un tiret bas (`'_'`). Cette forme ne doit être utilisée qu'au niveau "
#~ "du module."