python-docs-fr/tutorial/errors.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: 2021-05-19 22:36+0200\n"
"PO-Revision-Date: 2021-09-04 02:20+0200\n"
"Last-Translator: Jean Abou Samra <jean@abou-samra.fr>\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.1\n"

#: tutorial/errors.rst:5
msgid "Errors and Exceptions"
msgstr "Erreurs et exceptions"

#: tutorial/errors.rst:7
msgid ""
"Until now error messages haven't been more than mentioned, but if you have "
"tried out the examples you have probably seen some.  There are (at least) "
"two distinguishable kinds of errors: *syntax errors* and *exceptions*."
msgstr ""
"Jusqu'ici, les messages d'erreurs ont seulement été mentionnés. Mais si vous "
"avez essayé les exemples vous avez certainement vu plus que cela. En fait, "
"il y a au moins deux types d'erreurs à distinguer : les *erreurs de syntaxe* "
"et les *exceptions*."

#: tutorial/errors.rst:15
msgid "Syntax Errors"
msgstr "Les erreurs de syntaxe"

#: tutorial/errors.rst:17
msgid ""
"Syntax errors, also known as parsing errors, are perhaps the most common "
"kind of complaint you get while you are still learning Python::"
msgstr ""
"Les erreurs de syntaxe, qui sont des erreurs d'analyse du code, sont peut-"
"être celles que vous rencontrez le plus souvent lorsque vous êtes encore en "
"phase d'apprentissage de Python ::"

#: tutorial/errors.rst:26
msgid ""
"The parser repeats the offending line and displays a little 'arrow' pointing "
"at the earliest point in the line where the error was detected.  The error "
"is caused by (or at least detected at) the token *preceding* the arrow: in "
"the example, the error is detected at the function :func:`print`, since a "
"colon (``':'``) is missing before it.  File name and line number are printed "
"so you know where to look in case the input came from a script."
msgstr ""
"L'analyseur indique la ligne incriminée et affiche une petite « flèche » "
"pointant vers le premier endroit de la ligne où l'erreur a été détectée. "
"L'erreur est causée (ou, au moins, a été détectée comme telle) par le "
"symbole placé *avant* la flèche. Dans cet exemple la flèche est sur la "
"fonction :func:`print` car il manque deux points (``':'``) juste avant. Le "
"nom du fichier et le numéro de ligne sont affichés pour vous permettre de "
"localiser facilement l'erreur lorsque le code provient d'un script."

#: tutorial/errors.rst:37
msgid "Exceptions"
msgstr "Exceptions"

#: tutorial/errors.rst:39
msgid ""
"Even if a statement or expression is syntactically correct, it may cause an "
"error when an attempt is made to execute it. Errors detected during "
"execution are called *exceptions* and are not unconditionally fatal: you "
"will soon learn how to handle them in Python programs.  Most exceptions are "
"not handled by programs, however, and result in error messages as shown "
"here::"
msgstr ""
"Même si une instruction ou une expression est syntaxiquement correcte, elle "
"peut générer une erreur lors de son exécution. Les erreurs détectées durant "
"l'exécution sont appelées des *exceptions* et ne sont pas toujours fatales : "
"nous apprendrons bientôt comment les traiter dans vos programmes. La plupart "
"des exceptions toutefois ne sont pas prises en charge par les programmes, ce "
"qui génère des messages d'erreurs comme celui-ci ::"

#: tutorial/errors.rst:58
msgid ""
"The last line of the error message indicates what happened. Exceptions come "
"in different types, and the type is printed as part of the message: the "
"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"
"`TypeError`. The string printed as the exception type is the name of the "
"built-in exception that occurred.  This is true for all built-in exceptions, "
"but need not be true for user-defined exceptions (although it is a useful "
"convention). Standard exception names are built-in identifiers (not reserved "
"keywords)."
msgstr ""
"La dernière ligne du message d'erreur indique ce qui s'est passé. Les "
"exceptions peuvent être de différents types et ce type est indiqué dans le "
"message : les types indiqués dans l'exemple sont :exc:`ZeroDivisionError`, :"
"exc:`NameError` et :exc:`TypeError`. Le texte affiché comme type de "
"l'exception est le nom de l'exception native qui a été déclenchée. Ceci est "
"vrai pour toutes les exceptions natives mais n'est pas une obligation pour "
"les exceptions définies par l'utilisateur (même si c'est une convention bien "
"pratique). Les noms des exceptions standards sont des identifiants natifs "
"(pas des mots-clef réservés)."

#: tutorial/errors.rst:66
msgid ""
"The rest of the line provides detail based on the type of exception and what "
"caused it."
msgstr ""
"Le reste de la ligne fournit plus de détails en fonction du type de "
"l'exception et de ce qui l'a causée."

#: tutorial/errors.rst:69
msgid ""
"The preceding part of the error message shows the context where the "
"exception occurred, in the form of a stack traceback. In general it contains "
"a stack traceback listing source lines; however, it will not display lines "
"read from standard input."
msgstr ""
"La partie précédente du message d'erreur indique le contexte dans lequel "
"s'est produite l'exception, sous la forme d'une trace de pile d'exécution. "
"En général, celle-ci contient les lignes du code source ; toutefois, les "
"lignes lues à partir de l'entrée standard ne sont pas affichées."

#: tutorial/errors.rst:74
msgid ""
":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."
msgstr ""
"Vous trouvez la liste des exceptions natives et leur signification dans :ref:"
"`bltin-exceptions`."

#: tutorial/errors.rst:80
msgid "Handling Exceptions"
msgstr "Gestion des exceptions"

#: tutorial/errors.rst:82
msgid ""
"It is possible to write programs that handle selected exceptions. Look at "
"the following example, which asks the user for input until a valid integer "
"has been entered, but allows the user to interrupt the program (using :kbd:"
"`Control-C` or whatever the operating system supports); note that a user-"
"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "
"exception. ::"
msgstr ""
"Il est possible d'écrire des programmes qui prennent en charge certaines "
"exceptions. Regardez l'exemple suivant, qui demande une saisie à "
"l'utilisateur jusqu'à ce qu'un entier valide ait été entré, mais permet à "
"l'utilisateur d'interrompre le programme (en utilisant :kbd:`Control-C` ou "
"un autre raccourci que le système accepte) ; notez qu'une interruption "
"générée par l'utilisateur est signalée en levant l'exception :exc:"
"`KeyboardInterrupt`. ::"

# début d'énumération
#: tutorial/errors.rst:96
msgid "The :keyword:`try` statement works as follows."
msgstr "L'instruction :keyword:`try` fonctionne comme ceci :"

#: tutorial/errors.rst:98
msgid ""
"First, the *try clause* (the statement(s) between the :keyword:`try` and :"
"keyword:`except` keywords) is executed."
msgstr ""
"premièrement, la *clause try* (instruction(s) placée(s) entre les mots-clés :"
"keyword:`try` et :keyword:`except`) est exécutée."

#: tutorial/errors.rst:101
msgid ""
"If no exception occurs, the *except clause* is skipped and execution of the :"
"keyword:`try` statement is finished."
msgstr ""
"si aucune exception n'intervient, la clause ``except`` est sautée et "
"l'exécution de l'instruction :keyword:`try` est terminée."

#: tutorial/errors.rst:104
msgid ""
"If an exception occurs during execution of the try clause, the rest of the "
"clause is skipped.  Then if its type matches the exception named after the :"
"keyword:`except` keyword, the except clause is executed, and then execution "
"continues after the :keyword:`try` statement."
msgstr ""
"si une exception intervient pendant l'exécution de la clause ``try``, le "
"reste de cette clause est sauté. Si le type d'exception levée correspond à "
"un nom indiqué après le mot-clé :keyword:`except`, la clause ``except`` "
"correspondante est exécutée, puis l'exécution continue après l'instruction :"
"keyword:`try`."

# dernier élément de l'énumération
#: tutorial/errors.rst:109
msgid ""
"If an exception occurs which does not match the exception named in the "
"except clause, it is passed on to outer :keyword:`try` statements; if no "
"handler is found, it is an *unhandled exception* and execution stops with a "
"message as shown above."
msgstr ""
"si une exception intervient et ne correspond à aucune exception mentionnée "
"dans la clause ``except``, elle est transmise à l'instruction :keyword:`try` "
"de niveau supérieur ; si aucun gestionnaire d'exception n'est trouvé, il "
"s'agit d'une *exception non gérée* et l'exécution s'arrête avec un message "
"comme indiqué ci-dessus."

#: tutorial/errors.rst:114
msgid ""
"A :keyword:`try` statement may have more than one except clause, to specify "
"handlers for different exceptions.  At most one handler will be executed. "
"Handlers only handle exceptions that occur in the corresponding try clause, "
"not in other handlers of the same :keyword:`!try` statement.  An except "
"clause may name multiple exceptions as a parenthesized tuple, for example::"
msgstr ""
"Une instruction :keyword:`try` peut comporter plusieurs clauses ``except`` "
"pour permettre la prise en charge de différentes exceptions. Mais un seul "
"gestionnaire, au plus, sera exécuté. Les gestionnaires ne prennent en charge "
"que les exceptions qui interviennent dans la clause `!try` correspondante, "
"pas dans d'autres gestionnaires de la même instruction :keyword:`!try`. Mais "
"une même clause ``except`` peut citer plusieurs exceptions sous la forme "
"d'un *n*-uplet entre parenthèses, comme dans cet exemple ::"

#: tutorial/errors.rst:123
msgid ""
"A class in an :keyword:`except` clause is compatible with an exception if it "
"is the same class or a base class thereof (but not the other way around --- "
"an except clause listing a derived class is not compatible with a base "
"class).  For example, the following code will print B, C, D in that order::"
msgstr ""
"Une classe dans une clause :keyword:`except` est compatible avec une "
"exception si elle est de la même classe ou d'une de ses classes dérivées. "
"Mais l'inverse n'est pas vrai, une clause ``except`` spécifiant une classe "
"dérivée n'est pas compatible avec une classe de base. Par exemple, le code "
"suivant affiche B, C et D dans cet ordre ::"

#: tutorial/errors.rst:147
msgid ""
"Note that if the except clauses were reversed (with ``except B`` first), it "
"would have printed B, B, B --- the first matching except clause is triggered."
msgstr ""
"Notez que si les clauses ``except`` avaient été inversées (avec ``except B`` "
"en premier), il aurait affiché B, B, B — la première clause ``except`` qui "
"correspond est déclenchée."

#: tutorial/errors.rst:150
msgid ""
"The last except clause may omit the exception name(s), to serve as a "
"wildcard. Use this with extreme caution, since it is easy to mask a real "
"programming error in this way!  It can also be used to print an error "
"message and then re-raise the exception (allowing a caller to handle the "
"exception as well)::"
msgstr ""
"La dernière clause ``except`` peut omettre le(s) nom(s) d'exception(s) et "
"joue alors le rôle de joker. C'est toutefois à utiliser avec beaucoup de "
"précautions car il est facile de masquer une vraie erreur de programmation "
"par ce biais. Elle peut aussi être utilisée pour afficher un message "
"d'erreur avant de propager l'exception (en permettant à un appelant de gérer "
"également l'exception) ::"

#: tutorial/errors.rst:169
msgid ""
"The :keyword:`try` ... :keyword:`except` statement has an optional *else "
"clause*, which, when present, must follow all except clauses.  It is useful "
"for code that must be executed if the try clause does not raise an "
"exception.  For example::"
msgstr ""
"L'instruction :keyword:`try` ... :keyword:`except` accepte également une "
"*clause else* optionnelle qui, lorsqu'elle est présente, doit se placer "
"après toutes les clauses ``except``. Elle est utile pour du code qui doit "
"être exécuté lorsqu'aucune exception n'a été levée par la clause ``try``. "
"Par exemple ::"

#: tutorial/errors.rst:183
msgid ""
"The use of the :keyword:`!else` clause is better than adding additional code "
"to the :keyword:`try` clause because it avoids accidentally catching an "
"exception that wasn't raised by the code being protected by the :keyword:`!"
"try` ... :keyword:`!except` statement."
msgstr ""
"Il vaut mieux utiliser la clause :keyword:`!else` plutôt que d'ajouter du "
"code à la clause :keyword:`try` car cela évite de capturer accidentellement "
"une exception qui n'a pas été levée par le code initialement protégé par "
"l'instruction :keyword:`!try` ... :keyword:`!except`."

#: tutorial/errors.rst:188
msgid ""
"When an exception occurs, it may have an associated value, also known as the "
"exception's *argument*. The presence and type of the argument depend on the "
"exception type."
msgstr ""
"Quand une exception intervient, une valeur peut lui être associée, que l'on "
"appelle *l'argument* de l'exception. La présence de cet argument et son type "
"dépendent du type de l'exception."

#: tutorial/errors.rst:192
msgid ""
"The except clause may specify a variable after the exception name.  The "
"variable is bound to an exception instance with the arguments stored in "
"``instance.args``.  For convenience, the exception instance defines :meth:"
"`__str__` so the arguments can be printed directly without having to "
"reference ``.args``.  One may also instantiate an exception first before "
"raising it and add any attributes to it as desired. ::"
msgstr ""
"La clause ``except`` peut spécifier un nom de variable après le nom de "
"l'exception. Cette variable est liée à une instance d'exception avec les "
"arguments stockés dans ``instance.args``. Pour plus de commodité, l'instance "
"de l'exception définit la méthode :meth:`__str__` afin que les arguments "
"puissent être affichés directement sans avoir à référencer ``.args``. Il est "
"possible de construire une exception, y ajouter ses attributs, puis la lever "
"plus tard. ::"

#: tutorial/errors.rst:216
msgid ""
"If an exception has arguments, they are printed as the last part ('detail') "
"of the message for unhandled exceptions."
msgstr ""
"Si une exception a un argument, il est affiché dans la dernière partie du "
"message des exceptions non gérées."

#: tutorial/errors.rst:219
msgid ""
"Exception handlers don't just handle exceptions if they occur immediately in "
"the try clause, but also if they occur inside functions that are called "
"(even indirectly) in the try clause. For example::"
msgstr ""
"Les gestionnaires d'exceptions n'interceptent pas que les exceptions qui "
"sont levées immédiatement dans leur clause ``try``, mais aussi celles qui "
"sont levées au sein de fonctions appelées (parfois indirectement) dans la "
"clause ``try``. Par exemple ::"

#: tutorial/errors.rst:237
msgid "Raising Exceptions"
msgstr "Déclencher des exceptions"

#: tutorial/errors.rst:239
msgid ""
"The :keyword:`raise` statement allows the programmer to force a specified "
"exception to occur. For example::"
msgstr ""
"L'instruction :keyword:`raise` permet au programmeur de déclencher une "
"exception spécifique. Par exemple ::"

#: tutorial/errors.rst:247
msgid ""
"The sole argument to :keyword:`raise` indicates the exception to be raised. "
"This must be either an exception instance or an exception class (a class "
"that derives from :class:`Exception`).  If an exception class is passed, it "
"will be implicitly instantiated by calling its constructor with no "
"arguments::"
msgstr ""
"Le seul argument à :keyword:`raise` indique l'exception à déclencher. Cela "
"peut être soit une instance d'exception, soit une classe d'exception (une "
"classe dérivée de :class:`Exception`). Si une classe est donnée, elle est "
"implicitement instanciée *via* l'appel de son constructeur, sans argument ::"

#: tutorial/errors.rst:254
msgid ""
"If you need to determine whether an exception was raised but don't intend to "
"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"
"raise the exception::"
msgstr ""
"Si vous avez besoin de savoir si une exception a été levée mais que vous "
"n'avez pas intention de la gérer, une forme plus simple de l'instruction :"
"keyword:`raise` permet de propager l'exception ::"

#: tutorial/errors.rst:273
msgid "Exception Chaining"
msgstr "Chaînage d'exceptions"

#: tutorial/errors.rst:275
msgid ""
"The :keyword:`raise` statement allows an optional :keyword:`from<raise>` "
"which enables chaining exceptions. For example::"
msgstr ""
"L'instruction :keyword:`raise` autorise un :keyword:`from<raise>` optionnel "
"qui permet de chaîner les exceptions. Par exemple ::"

#: tutorial/errors.rst:281
msgid "This can be useful when you are transforming exceptions. For example::"
msgstr ""
"Cela peut être utile lorsque vous transformez des exceptions. Par exemple ::"

#: tutorial/errors.rst:302
msgid ""
"Exception chaining happens automatically when an exception is raised inside "
"an :keyword:`except` or :keyword:`finally` section. Exception chaining can "
"be disabled by using ``from None`` idiom:"
msgstr ""
"Le chaînage d'exceptions se produit automatiquement lorsqu'une exception est "
"levée dans une section :keyword:`except` ou :keyword:`finally`. Le chaînage "
"d'exceptions peut être désactivé en utilisant l'idiome ``from None`` :"

#: tutorial/errors.rst:315
msgid ""
"For more information about chaining mechanics, see :ref:`bltin-exceptions`."
msgstr ""
"Pour plus d'informations sur les mécanismes de chaînage, voir :ref:`bltin-"
"exceptions`."

#: tutorial/errors.rst:321
msgid "User-defined Exceptions"
msgstr "Exceptions définies par l'utilisateur"

#: tutorial/errors.rst:323
msgid ""
"Programs may name their own exceptions by creating a new exception class "
"(see :ref:`tut-classes` for more about Python classes).  Exceptions should "
"typically be derived from the :exc:`Exception` class, either directly or "
"indirectly."
msgstr ""
"Les programmes peuvent nommer leurs propres exceptions en créant une "
"nouvelle classe d'exception (voir :ref:`tut-classes` pour en savoir plus sur "
"les classes de Python). Les exceptions sont typiquement dérivées de la "
"classe :exc:`Exception`, directement ou non."

#: tutorial/errors.rst:327
msgid ""
"Exception classes can be defined which do anything any other class can do, "
"but are usually kept simple, often only offering a number of attributes that "
"allow information about the error to be extracted by handlers for the "
"exception.  When creating a module that can raise several distinct errors, a "
"common practice is to create a base class for exceptions defined by that "
"module, and subclass that to create specific exception classes for different "
"error conditions::"
msgstr ""
"Les classes d'exceptions peuvent être définies pour faire tout ce qu'une "
"autre classe peut faire. Elles sont le plus souvent gardées assez simples, "
"n'offrant que les attributs permettant aux gestionnaires de ces exceptions "
"d'extraire les informations relatives à l'erreur qui s'est produite. Lorsque "
"l'on crée un module qui peut déclencher plusieurs types d'erreurs distincts, "
"une pratique courante est de créer une classe de base pour l'ensemble des "
"exceptions définies dans ce module et de créer des sous-classes spécifiques "
"d'exceptions pour les différentes conditions d'erreurs ::"

#: tutorial/errors.rst:365
msgid ""
"Most exceptions are defined with names that end in \"Error\", similar to the "
"naming of the standard exceptions."
msgstr ""
"La plupart des exceptions sont définies avec des noms qui se terminent par "
"\"Error\", comme les exceptions standards."

#: tutorial/errors.rst:368
msgid ""
"Many standard modules define their own exceptions to report errors that may "
"occur in functions they define.  More information on classes is presented in "
"chapter :ref:`tut-classes`."
msgstr ""
"Beaucoup de modules standards définissent leurs propres exceptions pour "
"signaler les erreurs possibles dans les fonctions qu'ils définissent. Plus "
"d'informations sur les classes sont présentées dans le chapitre :ref:`tut-"
"classes`."

#: tutorial/errors.rst:376
msgid "Defining Clean-up Actions"
msgstr "Définition d'actions de nettoyage"

#: tutorial/errors.rst:378
msgid ""
"The :keyword:`try` statement has another optional clause which is intended "
"to define clean-up actions that must be executed under all circumstances.  "
"For example::"
msgstr ""
"L'instruction :keyword:`try` a une autre clause optionnelle qui est destinée "
"à définir des actions de nettoyage devant être exécutées dans certaines "
"circonstances. Par exemple ::"

#: tutorial/errors.rst:392
msgid ""
"If a :keyword:`finally` clause is present, the :keyword:`!finally` clause "
"will execute as the last task before the :keyword:`try` statement completes. "
"The :keyword:`!finally` clause runs whether or not the :keyword:`!try` "
"statement produces an exception. The following points discuss more complex "
"cases when an exception occurs:"
msgstr ""
"Si la clause :keyword:`finally` est présente, la clause :keyword:`!finally` "
"est la dernière tâche exécutée avant la fin du bloc :keyword:`try`. La "
"clause :keyword:`!finally` se lance que le bloc :keyword:`!try` produise une "
"exception ou non. Les prochains points parlent de cas plus complexes "
"lorsqu'une exception apparait :"

#: tutorial/errors.rst:398
msgid ""
"If an exception occurs during execution of the :keyword:`!try` clause, the "
"exception may be handled by an :keyword:`except` clause. If the exception is "
"not handled by an :keyword:`!except` clause, the exception is re-raised "
"after the :keyword:`!finally` clause has been executed."
msgstr ""
"Si une exception se produit durant l'exécution de la clause :keyword:`!try`, "
"elle peut être récupérée par une clause :keyword:`except`. Si l'exception "
"n'est pas récupérée par une clause :keyword:`!except`, l'exception est levée "
"à nouveau après que la clause :keyword:`!finally` a été exécutée."

#: tutorial/errors.rst:404
msgid ""
"An exception could occur during execution of an :keyword:`!except` or :"
"keyword:`!else` clause. Again, the exception is re-raised after the :keyword:"
"`!finally` clause has been executed."
msgstr ""
"Une exception peut se produire durant l'exécution d'une clause :keyword:`!"
"except` ou :keyword:`!else`. Encore une fois, l'exception est reprise après "
"que la clause :keyword:`!finally` a été exécutée."

#: tutorial/errors.rst:408
msgid ""
"If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:"
"`continue` or :keyword:`return` statement, exceptions are not re-raised."
msgstr ""
"Si dans l'exécution d'un bloc :keyword:`!finally`, on atteint une "
"instruction :keyword:`break`, :keyword:`continue` ou :keyword:`return`, "
"alors les exceptions ne sont pas reprises."

#: tutorial/errors.rst:412
msgid ""
"If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:"
"`continue` or :keyword:`return` statement, the :keyword:`!finally` clause "
"will execute just prior to the :keyword:`!break`, :keyword:`!continue` or :"
"keyword:`!return` statement's execution."
msgstr ""
"Si dans l'exécution d'un bloc :keyword:`!try`, on atteint une instruction :"
"keyword:`break`, :keyword:`continue` ou :keyword:`return`, alors la clause :"
"keyword:`!finally` s'exécute juste avant l'exécution de :keyword:`!break`, :"
"keyword:`!continue` ou :keyword:`!return`."

#: tutorial/errors.rst:418
msgid ""
"If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the "
"returned value will be the one from the :keyword:`!finally` clause's :"
"keyword:`!return` statement, not the value from the :keyword:`!try` "
"clause's :keyword:`!return` statement."
msgstr ""
"Si la clause :keyword:`!finally` contient une instruction :keyword:`!"
"return`, la valeur retournée sera celle du :keyword:`!return` de la clause :"
"keyword:`!finally`, et non la valeur du :keyword:`!return` de la clause :"
"keyword:`!try`."

#: tutorial/errors.rst:424
msgid "For example::"
msgstr "Par exemple ::"

#: tutorial/errors.rst:435
msgid "A more complicated example::"
msgstr "Un exemple plus compliqué ::"

#: tutorial/errors.rst:460
msgid ""
"As you can see, the :keyword:`finally` clause is executed in any event.  "
"The :exc:`TypeError` raised by dividing two strings is not handled by the :"
"keyword:`except` clause and therefore re-raised after the :keyword:`!"
"finally` clause has been executed."
msgstr ""
"Comme vous pouvez le voir, la clause :keyword:`finally` est exécutée dans "
"tous les cas. L'exception de type :exc:`TypeError`, déclenchée en divisant "
"deux chaînes de caractères, n'est pas prise en charge par la clause :keyword:"
"`except` et est donc propagée après que la clause :keyword:`!finally` a été "
"exécutée."

#: tutorial/errors.rst:465
msgid ""
"In real world applications, the :keyword:`finally` clause is useful for "
"releasing external resources (such as files or network connections), "
"regardless of whether the use of the resource was successful."
msgstr ""
"Dans les vraies applications, la clause :keyword:`finally` est notamment "
"utile pour libérer des ressources externes (telles que des fichiers ou des "
"connexions réseau), quelle qu'ait été l'utilisation de ces ressources."

#: tutorial/errors.rst:473
msgid "Predefined Clean-up Actions"
msgstr "Actions de nettoyage prédéfinies"

#: tutorial/errors.rst:475
msgid ""
"Some objects define standard clean-up actions to be undertaken when the "
"object is no longer needed, regardless of whether or not the operation using "
"the object succeeded or failed. Look at the following example, which tries "
"to open a file and print its contents to the screen. ::"
msgstr ""
"Certains objets définissent des actions de nettoyage standards qui doivent "
"être exécutées lorsque l'objet n'est plus nécessaire, indépendamment du fait "
"que l'opération ayant utilisé l'objet ait réussi ou non. Regardez l'exemple "
"suivant, qui tente d'ouvrir un fichier et d'afficher son contenu à l'écran ::"

#: tutorial/errors.rst:483
msgid ""
"The problem with this code is that it leaves the file open for an "
"indeterminate amount of time after this part of the code has finished "
"executing. This is not an issue in simple scripts, but can be a problem for "
"larger applications. The :keyword:`with` statement allows objects like files "
"to be used in a way that ensures they are always cleaned up promptly and "
"correctly. ::"
msgstr ""
"Le problème avec ce code est qu'il laisse le fichier ouvert pendant une "
"durée indéterminée après que le code a fini de s'exécuter. Ce n'est pas un "
"problème avec des scripts simples, mais peut l'être au sein d'applications "
"plus conséquentes. L'instruction :keyword:`with` permet d'utiliser certains "
"objets comme des fichiers d'une façon qui assure qu'ils seront toujours "
"nettoyés rapidement et correctement. ::"

#: tutorial/errors.rst:493
msgid ""
"After the statement is executed, the file *f* is always closed, even if a "
"problem was encountered while processing the lines. Objects which, like "
"files, provide predefined clean-up actions will indicate this in their "
"documentation."
msgstr ""
"Après l'exécution du bloc, le fichier *f* est toujours fermé, même si un "
"problème est survenu pendant l'exécution de ces lignes. D'autres objets qui, "
"comme pour les fichiers, fournissent des actions de nettoyage prédéfinies "
"l'indiquent dans leur documentation."