Attraper plusieurs exceptions sur une seule ligne (sauf bloc)

Question

Je sais que je peux faire:

try:
    # do something that may fail
except:
    # do this if ANYTHING goes wrong

Je peux aussi faire ça:

try:
    # do something that may fail
except IDontLikeYouException:
    # say please
except YouAreTooShortException:
    # stand on a ladder

Mais si je veux faire la même chose avec deux exceptions différentes, le mieux que je puisse penser maintenant est de le faire:

try:
    # do something that may fail
except IDontLikeYouException:
    # say please
except YouAreBeingMeanException:
    # say please

Existe-t-il un moyen de faire quelque chose comme ceci (puisque l'action à prendre dans les deux exceptions consiste à say please):

try:
    # do something that may fail
except IDontLikeYouException, YouAreBeingMeanException:
    # say please

Maintenant, cela ne fonctionnera vraiment pas, car cela correspond à la syntaxe de:

try:
    # do something that may fail
except Exception, e:
    # say please

Donc, mon effort pour attraper les deux exceptions distinctes ne porte pas exactement.

Y a-t-il un moyen de faire cela?

Answer 1

De Documentation Python :

Une clause except peut nommer plusieurs exceptions sous la forme d'un tuple entre parenthèses, par exemple

except (IDontLikeYouException, YouAreBeingMeanException) as e:
    pass

Ou, pour Python 2 uniquement:

except (IDontLikeYouException, YouAreBeingMeanException), e:
    pass

Séparer l'exception de la variable par une virgule fonctionnera toujours dans Python 2.6 et 2.7, mais est maintenant obsolète et ne fonctionne pas dans Python 3; maintenant vous devriez utiliser as.

Answer 2

Comment attraper plusieurs exceptions sur une seule ligne (sauf block)

Faire ceci:

try:
    may_raise_specific_errors():
except (SpecificErrorOne, SpecificErrorTwo) as error:
    handle(error) # might log or have some other default behavior...

Les parenthèses sont obligatoires car l'ancienne syntaxe utilisait les virgules pour attribuer un objet à l'objet d'erreur. Le mot clé as est utilisé pour l'affectation. Vous pouvez utiliser n'importe quel nom pour l'objet d'erreur, je préfère personnellement error.

Meilleur entrainement

Pour ce faire, de manière compatible avec Python et à l’avenir, vous devez séparer les exceptions par des virgules et les entourer de parenthèses afin de différencier la syntaxe précédente qui affectait l’instance d’exception à un nom de variable en suivant le type d’exception à intercepter. virgule.

Voici un exemple d'utilisation simple:

try:
    mainstuff()
except (KeyboardInterrupt, EOFError): # the parens are necessary
    quit(0)

Je ne spécifie que ces exceptions pour éviter de masquer les bogues, ce qui, si je rencontre, attend la trace complète de la pile.

Ceci est documenté ici: https://docs.python.org/tutorial/errors.html

Vous pouvez affecter l’exception à une variable (e est courant, mais vous préférerez peut-être une variable plus détaillée si vous avez une longue gestion des exceptions ou si votre IDE ne met en surbrillance que les sélections plus grandes.) fait.) L’instance a un attribut args. Voici un exemple:

try:
    mainstuff()
except (KeyboardInterrupt, EOFError) as err: 
    print(err)
    print(err.args)
    quit(0)

Notez que dans Python 3, l'objet err tombe en dehors de la portée lorsque le bloc except est terminé.

Obsolète

Vous pouvez voir le code qui attribue l'erreur avec une virgule. Cet usage, le seul formulaire disponible dans Python 2.5 et versions antérieures, est obsolète. Si vous souhaitez que votre code soit compatible avec le transfert en aval dans Python 3, vous devez mettre à jour la syntaxe pour utiliser le code suivant. nouvelle forme:

try:
    mainstuff()
except (KeyboardInterrupt, EOFError), err: # don't do this in Python 2.6+
    print err
    print err.args
    quit(0)

Si l'attribution du nom par une virgule apparaît dans votre base de code et que vous utilisez Python 2.5 ou version ultérieure, passez à la nouvelle façon de procéder afin que votre code reste compatible lors de la mise à niveau.

Le gestionnaire de contexte suppress

La réponse acceptée est vraiment 4 lignes de code, minimum:

try:
    do_something()
except (IDontLikeYouException, YouAreBeingMeanException) as e:
    pass

Les lignes try, except, pass peuvent être gérées sur une seule ligne avec le gestionnaire de contexte suppression du contexte, disponible dans Python 3.4 :

from contextlib import suppress

with suppress(IDontLikeYouException, YouAreBeingMeanException):
     do_something()

Ainsi, lorsque vous souhaitez pass à certaines exceptions, utilisez suppress.

Answer 3

Pour python 2.5 et les versions antérieures, la syntaxe correcte est la suivante:

except (IDontLikeYouException, YouAreBeingMeanException), e:
    print e

Où e est l'instance d'Exception.

Answer 4

De documentation Python -> 8.3 Gestion des exceptions :

Une instruction try peut avoir plusieurs clauses except, pour spécifier des gestionnaires pour différentes exceptions. Au plus un gestionnaire sera exécuté. Les gestionnaires traitent uniquement les exceptions qui se produisent dans la clause try correspondante, et non dans les autres gestionnaires de la même instruction try. Une clause except peut nommer plusieurs exceptions sous forme de tuple entre parenthèses, par exemple:

except (RuntimeError, TypeError, NameError):
    pass

Notez que les parenthèses entourant ce n-uplet sont obligatoires, car excepté ValueError, e: était la syntaxe utilisée pour ce qui est normalement écrit sous la forme except ValueError as e: dans le moderne Python (décrit ci-dessous). L'ancienne syntaxe est toujours prise en charge pour la compatibilité ascendante. Cela signifie que except RuntimeError, TypeError n’est pas équivalent à except (RuntimeError, TypeError):, mais à except RuntimeError asTypeError: qui n’est pas ce que vous voulez.

Answer 5

Si vous utilisez fréquemment un grand nombre d'exceptions, vous pouvez prédéfinir un tuple, de sorte que vous n'ayez pas à les ressaisir plusieurs fois.

#This example code is a technique I use in a library that connects with websites to gather data

ConnectErrs  = (URLError, SSLError, SocketTimeoutError, BadStatusLine, ConnectionResetError)

def connect(url, data):
    #do connection and return some data
    return(received_data)

def some_function(var_a, var_b, ...):
    try: o = connect(url, data)
    except ConnectErrs as e:
        #do the recovery stuff
    blah #do normal stuff you would do if no exception occurred

NOTES:

1. Si vous devez également intercepter d'autres exceptions que celles du tuple prédéfini, vous devrez en définir une autre, à l'exception d'un bloc.

2. Si vous ne pouvez pas tolérer une variable globale, définissez-la dans main () et transmettez-la là où vous en avez besoin ...

Answer 6

Une des façons de faire est ..

try:
   You do your operations here;
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block. 

une autre méthode consiste à créer une méthode qui exécute une tâche exécutée par le bloc except et l’appelle par l’intermédiaire du bloc except que vous écrivez.

try:
   You do your operations here;
   ......................
except Exception1:
    functionname(parameterList)
except Exception2:
    functionname(parameterList)
except Exception3:
    functionname(parameterList)
else:
   If there is no exception then execute this block. 

def functionname( parameters ):
   //your task..
   return [expression]

Je sais que le second n'est pas la meilleure façon de faire cela, mais je montre juste un certain nombre de façons de faire cela.

Answer 7

La documentation Python 2.7 indique que:

Une instruction try peut avoir plusieurs clauses except, pour spécifier des gestionnaires pour différentes exceptions. Au plus un gestionnaire sera exécuté. Les gestionnaires traitent uniquement les exceptions qui se produisent dans la clause try correspondante, et non dans les autres gestionnaires de la même instruction try. Une clause except peut nommer plusieurs exceptions sous forme de tuple entre parenthèses, par exemple:

try:
    raise ValueError("hello")
except (RuntimeError, ValueError, KeyError) as a:
    print a

Notez que les parenthèses entourant ce n-uplet sont obligatoires car, sauf ValueError, e: était la syntaxe utilisée pour ce qui est normalement écrit sous la forme excepté ValueError sous la forme e: in modern Python (décrit ci-dessous). L'ancienne syntaxe est toujours prise en charge pour la compatibilité ascendante. Cela signifie qu'à l'exception de RuntimeError, TypeError n'est pas équivalent à l'exception à (RuntimeError, TypeError): mais à l'exception de RuntimeError car TypeError: ce qui n'est pas ce que vous souhaitez.