Generic exception handling in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is generic exception handling in Python?

Generic exception handling means catching any kind of error that might happen during program execution using a broad exception clause like except Exception:. It helps prevent the program from crashing unexpectedly.

beginner

How do you write a generic exception handler in Python?

You use a try-except block with except Exception: to catch all exceptions that inherit from the base Exception class. For example:<br>

try:
    # code
except Exception:
    # handle error

intermediate

Why should you be careful when using generic exception handling?

Because it catches all exceptions, it can hide bugs or important errors. It might make debugging harder if you don't log or handle errors properly. It's best to use it when you want to catch unexpected errors but still know what happened.

intermediate

What is the difference between except: and except Exception:?

except: catches all exceptions including system-exiting ones like KeyboardInterrupt and SystemExit. except Exception: catches most errors but lets system-exiting exceptions pass through, which is usually safer.

beginner

Show a simple example of generic exception handling that prints the error message.

try:
    x = 1 / 0
except Exception as e:
    print(f"An error occurred: {e}")

This code catches any error and prints what went wrong.

Which keyword is used to catch all exceptions in Python safely?

A catch all:

B except BaseException:

C except Exception:

D except:

except Exception: catches most errors but excludes system-exiting exceptions, making it safer than a bare except:.

What happens if you use a bare except: clause?

A It only catches syntax errors.

B It catches all exceptions including system exit signals.

C It catches no exceptions.

D It only catches user-defined exceptions.

A bare except: catches every exception, including KeyboardInterrupt and SystemExit, which can stop the program unexpectedly.

Why might generic exception handling make debugging harder?

A Because it hides all errors if not logged or re-raised.

B Because it only catches syntax errors.

C Because it stops the program immediately.

D Because it only works with specific exceptions.

Generic handlers catch all errors, so if you don't log or handle them properly, you might not know what went wrong.

Which of these is a good practice when using generic exception handling?

A Log the error message inside the except block.

B Ignore the error silently.

C Use it everywhere without specific exceptions.

D Never use try-except blocks.

Logging errors helps you understand what happened and fix bugs later.

What does this code do?<br>

try:
    print(10 / 0)
except Exception as e:
    print(f"Error: {e}")

A Does nothing.

B Crashes the program.

C Prints 0.

D Prints 'Error: division by zero'.

The division by zero raises an exception caught by the generic handler, which prints the error message.

Explain what generic exception handling is and when you might use it.

Think about catching many errors at once to keep the program running.

Describe the difference between a bare except and except Exception in Python.

Consider what kinds of exceptions each catches and why that matters.