从一种方法到另一种方法的 Python 异常，它是如何工作的

Question

Hi I'm a bit lost with the exception and error hierarchy and I'd like to know how to manage properly

Basically

let's say I want to have a task with retry

@app.MyTask(bind=True)
try:
 doThis()
except(MyException):
 self.retry()

Now I want to get this exception from an exception within a function called by DoThis.Let's make it simple with code:

def DoThis():
 if a:
  doThat()
 else:
  doAnotherThing()

def doAnotherThing():
 try:
  havingfun()
 except (AnOtherException)
  raise MyException

So my question is, am I doing it the right way or should I do a try, except, and raise the same exception in DoThis like this

def DoThis()
 if a:
  doThat()
else:
  try:
    doAnotherThing()
  except(MyException):
    raise(MyException)

Answer 1

There is no general rule on where and how to catch errors. What I personally would not do is, to catch an Exception just to rewrite it.

A small example:

from typing import Union

def outer_function(a: Union[list, None] ,b: Union[list, None]):
    try:
        inner_function(a, b)
    except TypeError:
        print("Log error somehow")

def inner_function(a: list, b: list) -> list:
        return a + b
        
outer_function([1,2,3], None)

The inner_function does expect two lists as inputs. You do not assume an error to happen within that aux function. And such a function does normally not hold the info of how to handle the exception.

The outer_function does asume (stupid example) that a and b may be None. Therefore a TypeError is to be expected in some cases.

Therefore we catch the exception (always as precise as possible) -> TypeError.

Now we log it and handle it with some logic.

Not sure if that was your question after rereading it..