Post History

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:
```none
>>> 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:
```none
>>> 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:
```none
>>> 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
```