Catch multiple exceptions in one line (except block)

Enhanced termination and exception suppression

When dealing with exceptions that need a swift and graceful exit, leverage sys.exit(0) within your except block. If you need to intentionally ignore certain exceptions, use the trusty pass operation.

import sys

try:
    # I venture deep into the belly of the beast. Pray for me.
except (IOError, EOFError):
    sys.exit(0)  # Executing Order 66...program termination. 
except (KeyboardInterrupt, MemoryError):
    pass  # "These aren't the errors you're looking for." - Obi-Wan KenericError


For cleaner code when sidelining exceptions, Python 3.4 and up recommends using contextlib.suppress.

from contextlib import suppress

with suppress(FileNotFoundError):
    open("schrodinger_file.txt")  # Will I find a file or an exception? Guess we won't know!


Delving deeper into error specifics

When exception-land mines detonate, you may want to pull the error black box and inspect the crash details. Attach as e to bind the exception to a variable and access its arguments with e.args.

try:
    # code, code, code ... BOOM! (Possibly...)
except (OSError, RuntimeError) as e:
    error_message = e.args[0]  # Extract the secret message from the error bottle.


Avoiding rogue error trapping

Using except: is like casting a wide fishing net - you catch all sorts, including undesired exceptions. It's better to specify the exact kinds of fish you're after.

try:
    # Navigating the choppy waters of possible errors.
except Exception:  # A safer net.
    # handle operations


Crafted solutions for maintenance efficiency

To effectively orchestrate recurring exceptions, conjure global tuples to be used across your code.

COMMON_EXCEPTIONS = (ValueError, TypeError, KeyError)  # The usual suspects.

try:
    # some code
except COMMON_EXCEPTIONS as e:
    # I've got my eyes on you, common exceptions.


Advanced handling to level up your game

For more complex error-handling quests, forge custom functions that can be invoked within your except blocks.

def log_error(err):
    # Time to analyze the crime scene.
    pass

try:
    # Not all code that's written glitters...these ones might fail.
except (ConnectionError, TimeoutError) as e:
    log_error(e)  # Call in the error CSI team!


Handling operations post-exceptional events

Add an else block to your code that will spring into action only if no exceptions occur. This block stomps into the scene before any finally sequel and is useful for cleanup actions.

try:
    # code
except (KeyError, IndexError) as e:
    # handle listed exceptions
else:
    # If we made it here without blowing anything up, let's proceed with the victory dance!


With these concepts, you'll be a pythonic exception-handling maestro.

Handling individuality within group dynamics

While it's beneficial to group similar exceptions, there are times you need to respond individually to each exception. Separate except blocks allow for this individualized handling.

try:
    # Risk adjustment zone.
except ValueError:
    # Tailored handling for ValueError.
except (TypeError, KeyError):
    # One-for-two deal on TypeError and KeyError!
except Exception as e:
    # Your one-stop shop for all other exceptions.


Strategies and pointers for frequent cases

Multiple operations? No problem.

Attempting various operations that can falter within one try block reduces nested complexities.

try:
    operation1()  # Ready...
    operation2()  # Aim...
    operation3()  # Fire!
except (Operation1Error, Operation2Error, Operation3Error) as e:
    # Error land mines defused. Proceed with caution!


Error traceback preservation

To maintain traceback information when handling exceptions, consider chain linking them with the from keyword.

try:
    # Risky business here.
except SomeError as original_error:
    raise NewError("This just in: an error occurred!") from original_error


User-defined exception magic

Crafting custom exceptions thickens the plot when you want to raise and catch errors specific to your application's narrative.

class MyCustomError(Exception):
    pass

try:
    # code that's too cool for school
except MyCustomError as e:
    # Handle exception like a boss!
