u5-script-exceptions

Question 1

What’s the basic structure of a try-except block in Python?

Answer 1

try:
    # code that might raise exception
except ExceptionType as e:
    # code to handle the exception
    print(f"Error: {e}")

Question 2

What’s the difference between except ValueError and except (ValueError, TypeError)?

Answer 2

The first catches only ValueError, while the second catches both. Example:

try:
    result = numerator / denominator
except (ValueError, TypeError) as ex:  # Catches both
    print(f"Warning: {ex}")
    return None

Question 3

What is the purpose of the ‘as’ keyword in except statements?

Answer 3

It captures the exception object in a variable, allowing you to access its details. Example:

try:
    result = 1 / 0
except ZeroDivisionError as e:
    print(f"Error details: {e}")```

Question 4

What’s the difference between else and finally in try blocks?

Answer 4

else runs only if no exception occurred, finally runs always regardless of exceptions. Example:

try:
    x = 1/1
except ZeroDivisionError:
    print("division error")
else:
    print("success")  # runs if no exception
finally:
    print("cleanup")  # always runs```

Question 5

How do you re-raise an exception in an except block?

Answer 5

Use the ‘raise’ keyword without arguments to re-raise the caught exception. Example:

try:
    x = int("invalid")
except ValueError as e:
    print("Converting failed")
    raise  # Re-raises the ValueError```

Question 6

What happens when you have nested try-except blocks?

Answer 6

Each try-except handles exceptions in its scope. If an exception isn’t caught, it propagates to outer blocks. Example:

try:
    try:
        1/0
    except TypeError:  # Won't catch ZeroDivisionError
        print("Type error")
except ZeroDivisionError:  # Catches it here
    print("Division error")```

Question 7

How do you create a custom error message while preserving the original exception?

Answer 7

Use ‘raise from’ to chain exceptions while keeping the original cause. Example:

try:
    int("abc")
except ValueError as e:
    raise RuntimeError("Invalid input") from e

Question 8

What’s the difference between catching a specific exception vs all exceptions?

Answer 8

Specific catches (except ValueError) are preferred as they handle known cases. Catching all (except:) can hide bugs. Example:

try:
    value = int("abc")
except ValueError:  # Good: specific
    print("Invalid number")
except:  # Bad: catches everything```

Question 9

How can you handle KeyError when accessing dictionary values?

Answer 9

Use try-except to catch KeyError or use dict.get() method. Example:

def get_value(d: dict, key, default=None):
    try:
        return d[key]
    except KeyError:
        return default

Question 10

What’s the purpose of multiple except blocks?

Answer 10

They allow different handling for different types of exceptions. Example:

try:
    result = num/divisor
except ZeroDivisionError:
    print("Cannot divide by zero")
except TypeError:
    print("Invalid operand types")```

Question 11

How do exceptions affect program flow in Python?

Answer 11

When an exception occurs, Python immediately jumps to the matching except block, skipping remaining try block code. Example:

try:
    print("Start")
    1/0  # Exception occurs
    print("Never reaches here")
except ZeroDivisionError:
    print("Caught error")```

Question 12

What’s the proper way to handle conversion errors in Python?

Answer 12

Chain multiple try-except blocks or use multiple except clauses. Example:

def add(a, b):
    try:
        return a + b
    except TypeError:
        try:
            return int(a) + int(b)
        except ValueError:
            try:
                return float(a) + float(b)
            except ValueError:
                raise  # Re-raise original TypeError

Question 13

How do you ensure cleanup code always runs, even if exceptions occur?

Answer 13

Use a finally block, which executes whether an exception occurred or not. Example:

file = open("data.txt")
try:
    data = file.read()
except IOError:
    print("Error reading file")
finally:
    file.close()  # Always closes file