532 lines
25 KiB
Plaintext
532 lines
25 KiB
Plaintext
# SOME DESCRIPTIVE TITLE.
|
||
# Copyright (C) 1990-2016, Python Software Foundation
|
||
# This file is distributed under the same license as the Python package.
|
||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||
#
|
||
msgid ""
|
||
msgstr ""
|
||
"Project-Id-Version: Python 2.7\n"
|
||
"Report-Msgid-Bugs-To: \n"
|
||
"POT-Creation-Date: 2016-10-30 10:44+0100\n"
|
||
"PO-Revision-Date: 2017-05-16 23:24+0200\n"
|
||
"Last-Translator: Julien Palard <julien@palard.fr>\n"
|
||
"Language-Team: \n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 1.8.11\n"
|
||
|
||
#: ../Doc/tutorial/errors.rst:5
|
||
msgid "Errors and Exceptions"
|
||
msgstr "Erreurs et exceptions"
|
||
|
||
#: ../Doc/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*."
|
||
|
||
#: ../Doc/tutorial/errors.rst:15
|
||
msgid "Syntax Errors"
|
||
msgstr "Les erreurs de syntaxe"
|
||
|
||
#: ../Doc/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 : ::"
|
||
|
||
#: ../Doc/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 keyword :keyword:`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 répère 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, ici car il manque deux points (``':'``) "
|
||
"avant lui, dans l'exemple l'erreur est détectée au mot clef :keyword:"
|
||
"`print`, car il manque deux points (``':'``) juste avant. Le nom de 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."
|
||
|
||
#: ../Doc/tutorial/errors.rst:37
|
||
msgid "Exceptions"
|
||
msgstr "Exceptions"
|
||
|
||
#: ../Doc/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 : ::"
|
||
|
||
#: ../Doc/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 réservés)."
|
||
|
||
#: ../Doc/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."
|
||
|
||
#: ../Doc/tutorial/errors.rst:69
|
||
msgid ""
|
||
"The preceding part of the error message shows the context where the "
|
||
"exception happened, 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 dans le 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."
|
||
|
||
#: ../Doc/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`."
|
||
|
||
#: ../Doc/tutorial/errors.rst:80
|
||
msgid "Handling Exceptions"
|
||
msgstr "Gestion des exceptions"
|
||
|
||
#: ../Doc/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`."
|
||
|
||
#: ../Doc/tutorial/errors.rst:96
|
||
msgid "The :keyword:`try` statement works as follows."
|
||
msgstr "L'instruction :keyword:`try` fonctionne comme ceci :"
|
||
|
||
#: ../Doc/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 ;"
|
||
|
||
#: ../Doc/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 ;"
|
||
|
||
#: ../Doc/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` ;"
|
||
|
||
#: ../Doc/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."
|
||
|
||
#: ../Doc/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 tuple entre parenthèses, comme dans cet exemple : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:123
|
||
msgid ""
|
||
"Note that the parentheses around this tuple are required, because ``except "
|
||
"ValueError, e:`` was the syntax used for what is normally written as "
|
||
"``except ValueError as e:`` in modern Python (described below). The old "
|
||
"syntax is still supported for backwards compatibility. This means ``except "
|
||
"RuntimeError, TypeError`` is not equivalent to ``except (RuntimeError, "
|
||
"TypeError):`` but to ``except RuntimeError as TypeError:`` which is not what "
|
||
"you want."
|
||
msgstr ""
|
||
"Notez que les parenthèses autour de ce tuple sont nécessaires, car ``except "
|
||
"ValueError, e:`` est la syntaxe utilisée pour ce qui s'écrit désormais "
|
||
"``except ValueError as e:`` dans les dernières versions de Python (comme "
|
||
"décrit ci-dessous). L'ancienne syntaxe est toujours supportée pour la "
|
||
"compatibilité ascendante. Ce qui signifie que ``except RuntimeError, "
|
||
"TypeError:`` n'est pas l'équivalent de ``except (RuntimeError, TypeError):`` "
|
||
"mais de ``except RuntimeError as TypeError:``, ce qui n'est pas ce que l'on "
|
||
"souhaite."
|
||
|
||
#: ../Doc/tutorial/errors.rst:131
|
||
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) ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:150
|
||
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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:164
|
||
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`."
|
||
|
||
#: ../Doc/tutorial/errors.rst:169
|
||
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."
|
||
|
||
#: ../Doc/tutorial/errors.rst:173
|
||
msgid ""
|
||
"The except clause may specify a variable after the exception name (or "
|
||
"tuple). 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``."
|
||
msgstr ""
|
||
"La clause except peut spécifier un nom de variable après le nom de "
|
||
"l'exception (ou le tuple). 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 imprimés directement sans avoir à référencer "
|
||
"``.args``."
|
||
|
||
#: ../Doc/tutorial/errors.rst:179
|
||
msgid ""
|
||
"One may also instantiate an exception first before raising it and add any "
|
||
"attributes to it as desired. ::"
|
||
msgstr ""
|
||
"On peut aussi instancier une exception et lui ajouter autant d'attributs que "
|
||
"nécessaire avant de la déclencher ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:198
|
||
msgid ""
|
||
"If an exception has an argument, it is printed as the last part ('detail') "
|
||
"of the message for unhandled exceptions."
|
||
msgstr ""
|
||
"Si une exception a un argument, il est imprimé dans la dernière partie "
|
||
"('detail') du message des exceptions non gérées."
|
||
|
||
#: ../Doc/tutorial/errors.rst:201
|
||
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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:219
|
||
msgid "Raising Exceptions"
|
||
msgstr "Déclencher des exceptions"
|
||
|
||
#: ../Doc/tutorial/errors.rst:221
|
||
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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:229
|
||
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`)."
|
||
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`)."
|
||
|
||
#: ../Doc/tutorial/errors.rst:233
|
||
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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:252
|
||
msgid "User-defined Exceptions"
|
||
msgstr "Exceptions définies par l'utilisateur"
|
||
|
||
#: ../Doc/tutorial/errors.rst:254
|
||
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. For example::"
|
||
msgstr ""
|
||
"Les programmes peuvent nommer leur propres exceptions en créant de nouvelles "
|
||
"classes (voir :ref:`tut-classes` à propos des classes Python). Ces "
|
||
"exceptions doivent typiquement être dérivées de la classe :exc:`Exception`, "
|
||
"directement ou indirectement. Par exemple : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:276
|
||
msgid ""
|
||
"In this example, the default :meth:`__init__` of :class:`Exception` has been "
|
||
"overridden. The new behavior simply creates the *value* attribute. This "
|
||
"replaces the default behavior of creating the *args* attribute."
|
||
msgstr ""
|
||
"Dans cet exemple, la méthode :meth:`__init__` de la classe :class:"
|
||
"`Exception` a été surchargée. Le nouveau comportement crée simplement "
|
||
"l'attribut *value*. Ceci remplace le comportement par défaut qui crée "
|
||
"l'attribut *args*."
|
||
|
||
#: ../Doc/tutorial/errors.rst:280
|
||
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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:318
|
||
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."
|
||
|
||
#: ../Doc/tutorial/errors.rst:321
|
||
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`."
|
||
|
||
#: ../Doc/tutorial/errors.rst:329
|
||
msgid "Defining Clean-up Actions"
|
||
msgstr "Définition d'actions de nettoyage"
|
||
|
||
#: ../Doc/tutorial/errors.rst:331
|
||
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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:345
|
||
msgid ""
|
||
"A *finally clause* is always executed before leaving the :keyword:`try` "
|
||
"statement, whether an exception has occurred or not. When an exception has "
|
||
"occurred in the :keyword:`try` clause and has not been handled by an :"
|
||
"keyword:`except` clause (or it has occurred in an :keyword:`except` or :"
|
||
"keyword:`else` clause), it is re-raised after the :keyword:`finally` clause "
|
||
"has been executed. The :keyword:`finally` clause is also executed \"on the "
|
||
"way out\" when any other clause of the :keyword:`try` statement is left via "
|
||
"a :keyword:`break`, :keyword:`continue` or :keyword:`return` statement. A "
|
||
"more complicated example (having :keyword:`except` and :keyword:`finally` "
|
||
"clauses in the same :keyword:`try` statement works as of Python 2.5)::"
|
||
msgstr ""
|
||
"La clause *finally* est toujours exécutée avant de sortir de l'instruction :"
|
||
"keyword:`try`, qu'une exception soit survenu ou non. Lorsqu'une exception "
|
||
"est survenue dans la clause :keyword:`try` et n'a pas été attrapée par un :"
|
||
"keyword:`except` (ou qu'elle s'est produite dans un :keyword:`except` ou :"
|
||
"keyword:`else`), elle sera relancée après la fin de l'exécution de la "
|
||
"clause :keyword:`finally`. La clause :keyword:`finally` est aussi exécutée "
|
||
"\"en sortant\" lorsque n'importe quelle autre clause du :keyword:`try` est "
|
||
"interrompue que ce soit avec un :keyword:`break`, :keyword:`continue` ou :"
|
||
"keyword:`return`. Un exemple plus compliqué (ayant un :keyword:`except` et "
|
||
"un :keyword:`finally` dans le même :keyword:`try` fonctionne comme en Python "
|
||
"2.6) : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:379
|
||
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."
|
||
|
||
#: ../Doc/tutorial/errors.rst:384
|
||
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."
|
||
|
||
#: ../Doc/tutorial/errors.rst:392
|
||
msgid "Predefined Clean-up Actions"
|
||
msgstr "Actions de nettoyage prédéfinies"
|
||
|
||
#: ../Doc/tutorial/errors.rst:394
|
||
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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:402
|
||
msgid ""
|
||
"The problem with this code is that it leaves the file open for an "
|
||
"indeterminate amount of time after 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 ait 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 : ::"
|
||
|
||
#: ../Doc/tutorial/errors.rst:412
|
||
msgid ""
|
||
"After the statement is executed, the file *f* is always closed, even if a "
|
||
"problem was encountered while processing the lines. Other objects which "
|
||
"provide predefined clean-up actions will indicate this in their "
|
||
"documentation."
|
||
msgstr ""
|
||
"Dès que l'instruction est exécutée, le fichier *f* est toujours fermé, même "
|
||
"si un problème est intervenu pendant l'exécution de ces lignes. D'autres "
|
||
"objets qui fournissent des actions de nettoyage prédéfinies l'indiquent dans "
|
||
"leur documentation."
|