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 print
ed 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