Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
How can I provide additional information when raising an exception?
Suppose I have some code like:
filename = "bad_dir"
print(f"File not found: {filename}.")
raise(FileNotFoundError)
When the exception isn't caught, the stack trace is printed at the end of the output, right as the program aborts. The printed message could be far above this and is hard to find in the terminal and hard to associate with the exception.
How can I provide additional information in the exception, so that it can be seen immediately when the traceback is displayed?
2 answers
The following users marked this post as Works for me:
| User | Comment | Date |
|---|---|---|
| mcp | (no comment) | Oct 26, 2022 at 15:19 |
Python documentation suggests that you can simply add other parameters when raising the Exception and retrieve them using args:
Code
try:
raise Exception('spam', 'eggs')
except Exception as inst:
print(inst.args) # arguments stored in .args
x, y = inst.args # unpack args
print('x =', x)
print('y =', y)
Output
('spam', 'eggs')
x = spam
y = eggs
The raise statement in Python accepts either an Exception class or an instance of that class. When used with a class, Python will create and raise an instance by passing no arguments to the constructor.
Python exception constructors, by default, accept an arbitrary number of positional arguments and store them as the args attribute of the created exception:
>>> Exception(1, 2).args
(1, 2)
When the exception is raised and not caught, the traceback will format its arguments depending on how many there are. With an empty args tuple, nothing is shown besides the exception type name:
>>> raise Exception
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
Exception
>>> raise Exception()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
Exception
With a single element in args, its str representation is shown after a colon:
>>> class ExampleClass:
... def __str__(self):
... return 'str'
... def __repr__(self):
... return 'repr'
...
>>> raise Exception(ExampleClass())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
Exception: str
With two or more elements in args, the str representation of the entire tuple (which will, in turn, rely on the repr representation of the elements) is shown:
>>> raise Exception(ExampleClass(), ExampleClass())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
Exception: (repr, repr)
When the exception is caught, the except clause can use as to name the exception object, and then access its args for further processing:
>>> try: # this is obviously for demonstration purposes only!
... raise Exception(1, 2, 3, 4)
... except Exception as e:
... print(sum(e.args))
...
10
0 comment threads
0 comment threads