Julien Palard
c584ff6fbb
Some checks failed
ci/woodpecker/push/woodpecker Pipeline failed
Reviewed-on: #122 Reviewed-by: Christophe Nanteuil <christophenan@noreply.localhost>
752 lines
35 KiB
Plaintext
752 lines
35 KiB
Plaintext
# 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: 2023-01-15 22:33+0100\n"
|
||
"PO-Revision-Date: 2023-02-04 14:34+0100\n"
|
||
"Last-Translator: \n"
|
||
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
||
"Language: fr\n"
|
||
"MIME-Version: 1.0\n"
|
||
"Content-Type: text/plain; charset=UTF-8\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"X-Generator: Poedit 3.2.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 :keyword:`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 try/except block."
|
||
msgstr ""
|
||
"si une exception intervient pendant l'exécution de la clause :keyword:`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 le bloc ``try``/"
|
||
"``except``."
|
||
|
||
# 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 :keyword:`!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 mère. 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 ""
|
||
"When an exception occurs, it may have associated values, also known as the "
|
||
"exception's *arguments*. The presence and types of the arguments 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:154
|
||
msgid ""
|
||
"The *except clause* may specify a variable after the exception name. The "
|
||
"variable is bound to the exception instance which typically has an ``args`` "
|
||
"attribute that stores the arguments. For convenience, builtin exception "
|
||
"types define :meth:`__str__` to print all the arguments without explicitly "
|
||
"accessing ``.args``. ::"
|
||
msgstr ""
|
||
"La clause ``except`` peut spécifier un nom de variable après le nom de "
|
||
"l'exception. Cette variable est liée à l'instance d'exception avec les "
|
||
"arguments stockés dans l'attribut ``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``. ::"
|
||
|
||
#: tutorial/errors.rst:177
|
||
msgid ""
|
||
"The exception's :meth:`__str__` output is printed as the last part "
|
||
"('detail') of the message for unhandled exceptions."
|
||
msgstr ""
|
||
"La sortie produite par :meth:`__str__` de l'exception est affichée en "
|
||
"dernière partie (« détail ») du message des exceptions qui ne sont pas "
|
||
"gérées."
|
||
|
||
#: tutorial/errors.rst:180
|
||
msgid ""
|
||
":exc:`BaseException` is the common base class of all exceptions. One of its "
|
||
"subclasses, :exc:`Exception`, is the base class of all the non-fatal "
|
||
"exceptions. Exceptions which are not subclasses of :exc:`Exception` are not "
|
||
"typically handled, because they are used to indicate that the program should "
|
||
"terminate. They include :exc:`SystemExit` which is raised by :meth:`sys."
|
||
"exit` and :exc:`KeyboardInterrupt` which is raised when a user wishes to "
|
||
"interrupt the program."
|
||
msgstr ""
|
||
":exc:`BaseException` est la classe mère de toutes les exceptions. Une de ses "
|
||
"sous-classes, :exc:`Exception`, est la classe mère de toutes les exceptions "
|
||
"non fatales. Les exceptions qui ne sont pas des sous-classes de :exc:"
|
||
"`Exception` ne sont normalement pas gérées, car elles sont utilisées pour "
|
||
"indiquer que le programme doit se terminer. C'est le cas de :exc:"
|
||
"`SystemExit` qui est levée par :meth:`sys.exit` et :exc:`KeyboardInterrupt` "
|
||
"qui est levée quand l'utilisateur souhaite interrompre le programme."
|
||
|
||
#: tutorial/errors.rst:188
|
||
msgid ""
|
||
":exc:`Exception` can be used as a wildcard that catches (almost) everything. "
|
||
"However, it is good practice to be as specific as possible with the types of "
|
||
"exceptions that we intend to handle, and to allow any unexpected exceptions "
|
||
"to propagate on."
|
||
msgstr ""
|
||
":exc:`Exception` peut être utilisée pour intercepter (presque) tous les cas. "
|
||
"Cependant, une bonne pratique consiste à être aussi précis que possible dans "
|
||
"les types d'exception que l'on souhaite gérer et autoriser toutes les "
|
||
"exceptions non prévues à se propager."
|
||
|
||
#: tutorial/errors.rst:193
|
||
msgid ""
|
||
"The most common pattern for handling :exc:`Exception` is to print or log the "
|
||
"exception and then re-raise it (allowing a caller to handle the exception as "
|
||
"well)::"
|
||
msgstr ""
|
||
"La manière la plus utilisée pour gérer une :exc:`Exception` consiste à "
|
||
"afficher ou journaliser l'exception et ensuite la lever à nouveau afin de "
|
||
"permettre à l'appelant de la gérer à son tour ::"
|
||
|
||
#: tutorial/errors.rst:211
|
||
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:225
|
||
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:230
|
||
msgid ""
|
||
"Exception handlers do not handle only exceptions that occur immediately in "
|
||
"the *try clause*, but also those that 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:248
|
||
msgid "Raising Exceptions"
|
||
msgstr "Déclencher des exceptions"
|
||
|
||
#: tutorial/errors.rst:250
|
||
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:258
|
||
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:`BaseException`, such as :exc:`Exception` or one of "
|
||
"its subclasses). 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:`BaseException`, telle que :exc:`Exception` ou une "
|
||
"de ses sous-classes). Si une classe est donnée, elle est implicitement "
|
||
"instanciée *via* l'appel de son constructeur, sans argument ::"
|
||
|
||
#: tutorial/errors.rst:266
|
||
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:285
|
||
msgid "Exception Chaining"
|
||
msgstr "Chaînage d'exceptions"
|
||
|
||
#: tutorial/errors.rst:287
|
||
msgid ""
|
||
"If an unhandled exception occurs inside an :keyword:`except` section, it "
|
||
"will have the exception being handled attached to it and included in the "
|
||
"error message::"
|
||
msgstr ""
|
||
"Si une exception non gérée se produit à l'intérieur d'une section :keyword:"
|
||
"`except`, l'exception en cours de traitement est jointe à l'exception non "
|
||
"gérée et incluse dans le message d'erreur ::"
|
||
|
||
#: tutorial/errors.rst:306
|
||
msgid ""
|
||
"To indicate that an exception is a direct consequence of another, the :"
|
||
"keyword:`raise` statement allows an optional :keyword:`from<raise>` clause::"
|
||
msgstr ""
|
||
"Pour indiquer qu'une exception est la conséquence directe d'une autre, "
|
||
"l'instruction :keyword:`raise` autorise une clause facultative :keyword:"
|
||
"`from<raise>` ::"
|
||
|
||
#: tutorial/errors.rst:312
|
||
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:333
|
||
msgid ""
|
||
"It also allows disabling automatic exception chaining using the ``from "
|
||
"None`` idiom::"
|
||
msgstr ""
|
||
"Cela permet également de désactiver le chaînage automatique des exceptions à "
|
||
"l'aide de l'idiome ``from None`` ::"
|
||
|
||
#: tutorial/errors.rst:345
|
||
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:351
|
||
msgid "User-defined Exceptions"
|
||
msgstr "Exceptions définies par l'utilisateur"
|
||
|
||
#: tutorial/errors.rst:353
|
||
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:357
|
||
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."
|
||
msgstr ""
|
||
"Les classes d'exceptions sont des classes comme les autres, et peuvent donc "
|
||
"utiliser toutes les fonctionnalités des classes. Néanmoins, en général, "
|
||
"elles demeurent assez simples, et se contentent d'offrir des attributs qui "
|
||
"permettent aux gestionnaires de ces exceptions d'extraire les informations "
|
||
"relatives à l'erreur qui s'est produite."
|
||
|
||
#: tutorial/errors.rst:361
|
||
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:364
|
||
msgid ""
|
||
"Many standard modules define their own exceptions to report errors that may "
|
||
"occur in functions they define."
|
||
msgstr ""
|
||
"Beaucoup de modules standards définissent leurs propres exceptions pour "
|
||
"signaler les erreurs possibles dans les fonctions qu'ils définissent."
|
||
|
||
#: tutorial/errors.rst:371
|
||
msgid "Defining Clean-up Actions"
|
||
msgstr "Définition d'actions de nettoyage"
|
||
|
||
#: tutorial/errors.rst:373
|
||
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:387
|
||
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:393
|
||
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:399
|
||
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:403
|
||
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:407
|
||
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:413
|
||
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:419
|
||
msgid "For example::"
|
||
msgstr "Par exemple ::"
|
||
|
||
#: tutorial/errors.rst:430
|
||
msgid "A more complicated example::"
|
||
msgstr "Un exemple plus compliqué ::"
|
||
|
||
#: tutorial/errors.rst:455
|
||
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:460
|
||
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:468
|
||
msgid "Predefined Clean-up Actions"
|
||
msgstr "Actions de nettoyage prédéfinies"
|
||
|
||
#: tutorial/errors.rst:470
|
||
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:478
|
||
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:488
|
||
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."
|
||
|
||
#: tutorial/errors.rst:496
|
||
msgid "Raising and Handling Multiple Unrelated Exceptions"
|
||
msgstr "Levée et gestion de multiples exceptions non corrélées"
|
||
|
||
#: tutorial/errors.rst:498
|
||
msgid ""
|
||
"There are situations where it is necessary to report several exceptions that "
|
||
"have occurred. This is often the case in concurrency frameworks, when "
|
||
"several tasks may have failed in parallel, but there are also other use "
|
||
"cases where it is desirable to continue execution and collect multiple "
|
||
"errors rather than raise the first exception."
|
||
msgstr ""
|
||
"Il existe des situations où il est nécessaire de signaler plusieurs "
|
||
"exceptions qui se sont produites. C'est souvent le cas dans les programmes à "
|
||
"multiples fils, lorsque plusieurs tâches échouent en parallèle. Mais il "
|
||
"existe également d'autres cas où il est souhaitable de poursuivre "
|
||
"l'exécution, de collecter plusieurs erreurs plutôt que de lever la première "
|
||
"exception rencontrée."
|
||
|
||
#: tutorial/errors.rst:504
|
||
msgid ""
|
||
"The builtin :exc:`ExceptionGroup` wraps a list of exception instances so "
|
||
"that they can be raised together. It is an exception itself, so it can be "
|
||
"caught like any other exception. ::"
|
||
msgstr ""
|
||
"L'idiome natif :exc:`ExceptionGroup` englobe une liste d'instances "
|
||
"d'exceptions afin de pouvoir les lever en même temps. C'est une exception, "
|
||
"et peut donc être interceptée comme toute autre exception. ::"
|
||
|
||
#: tutorial/errors.rst:530
|
||
msgid ""
|
||
"By using ``except*`` instead of ``except``, we can selectively handle only "
|
||
"the exceptions in the group that match a certain type. In the following "
|
||
"example, which shows a nested exception group, each ``except*`` clause "
|
||
"extracts from the group exceptions of a certain type while letting all other "
|
||
"exceptions propagate to other clauses and eventually to be reraised. ::"
|
||
msgstr ""
|
||
"En utilisant ``except*`` au lieu de ``except``, vous pouvez choisir de ne "
|
||
"gérer que les exceptions du groupe qui correspondent à un certain type. Dans "
|
||
"l'exemple qui suit, dans lequel se trouve imbriqué un groupe d'exceptions, "
|
||
"chaque clause ``except*`` extrait du groupe des exceptions d'un certain type "
|
||
"tout en laissant toutes les autres exceptions se propager vers d'autres "
|
||
"clauses et éventuellement être réactivées. ::"
|
||
|
||
#: tutorial/errors.rst:564
|
||
msgid ""
|
||
"Note that the exceptions nested in an exception group must be instances, not "
|
||
"types. This is because in practice the exceptions would typically be ones "
|
||
"that have already been raised and caught by the program, along the following "
|
||
"pattern::"
|
||
msgstr ""
|
||
"Notez que les exceptions imbriquées dans un groupe d'exceptions doivent être "
|
||
"des instances, pas des types. En effet, dans la pratique, les exceptions "
|
||
"sont normalement celles qui ont déjà été déclenchées et interceptées par le "
|
||
"programme, en utilisant le modèle suivant ::"
|
||
|
||
#: tutorial/errors.rst:582
|
||
msgid "Enriching Exceptions with Notes"
|
||
msgstr "Enrichissement des exceptions avec des notes"
|
||
|
||
#: tutorial/errors.rst:584
|
||
msgid ""
|
||
"When an exception is created in order to be raised, it is usually "
|
||
"initialized with information that describes the error that has occurred. "
|
||
"There are cases where it is useful to add information after the exception "
|
||
"was caught. For this purpose, exceptions have a method ``add_note(note)`` "
|
||
"that accepts a string and adds it to the exception's notes list. The "
|
||
"standard traceback rendering includes all notes, in the order they were "
|
||
"added, after the exception. ::"
|
||
msgstr ""
|
||
"Quand une exception est créée pour être levée, elle est généralement "
|
||
"initialisée avec des informations décrivant l'erreur qui s'est produite. Il "
|
||
"existe des cas où il est utile d'ajouter des informations après que "
|
||
"l'exception a été interceptée. Dans ce but, les exceptions ont une méthode "
|
||
"``add_note(note)`` qui reçoit une chaîne et l'ajoute à la liste des notes de "
|
||
"l'exception. L'affichage de la pile de trace standard inclut toutes les "
|
||
"notes, dans l'ordre dans lequel elles ont été ajoutées, après l'exception. ::"
|
||
|
||
#: tutorial/errors.rst:605
|
||
msgid ""
|
||
"For example, when collecting exceptions into an exception group, we may want "
|
||
"to add context information for the individual errors. In the following each "
|
||
"exception in the group has a note indicating when this error has occurred. ::"
|
||
msgstr ""
|
||
"Par exemple, lors de la collecte d'exceptions dans un groupe d'exceptions, "
|
||
"il est probable que vous souhaitiez ajouter des informations de contexte aux "
|
||
"erreurs individuelles. Dans ce qui suit, chaque exception du groupe est "
|
||
"accompagnée d'une note indiquant quand cette erreur s'est produite. ::"
|
||
|
||
#~ 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 ::"
|
||
|
||
#~ msgid ""
|
||
#~ "Exception chaining happens automatically when an exception is raised "
|
||
#~ "inside an :keyword:`except` or :keyword:`finally` section. This 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`` :"
|
||
|
||
#~ msgid ""
|
||
#~ "All exceptions inherit from :exc:`BaseException`, and so it can be used "
|
||
#~ "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 ""
|
||
#~ "Toutes les exceptions héritent de :exc:`BaseException`, il est donc "
|
||
#~ "possible de s'en servir comme un 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) ::"
|