## Why Catch Multiple Exceptions

When you write Python code that interacts with user input or external data, you must expect things to go wrong. For example, you might ask a user to enter a number as a string, convert it to an integer, and then use it as a divisor. Two common problems can occur:

- The string cannot be converted to an integer (such as "hello" or "3.14");
- The integer is zero, causing a division by zero error.

If you do not handle these exceptions, your program will crash and display a confusing error message. By catching multiple exceptions, you can provide clear feedback and keep your program running smoothly.

**Scenario:**
Suppose you ask a user to enter a number as a string, then divide 100 by that value. If the user enters "0", you get a `ZeroDivisionError`. If the user enters "abc", you get a `ValueError`. You need to catch both errors and respond with helpful messages.

Catching multiple exceptions in a single block of code makes your programs safer and more user-friendly.

### Handling Multiple Exceptions in a Single Try-Except Block

When you expect more than one type of error in a block of code, use multiple `except` clauses after a single `try` block. This structure allows you to respond differently depending on which exception occurs, keeping your code organized and easier to read.

```python
try:
    # Code that may raise multiple exceptions
    risky_operation()
except ValueError:
    print("A ValueError occurred.")
except ZeroDivisionError:
    print("Cannot divide by zero.")
```

**Key points:**
- Place all code that might raise exceptions inside one `try` block;
- Add a separate `except` clause for each exception type you want to handle;
- Each `except` clause only handles its specific exception type, so error messages and recovery steps stay clear and relevant.

This approach makes your code more maintainable and ensures that you provide meaningful feedback for each possible error.


import unittest
import user_code
import ast
import re   
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_valid_input(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("10", 5)
        _dynamic_test(
            self,
            result == 10.0,
            "Correct result for valid integer input",
            f"Expected 10.0, got {result}",
        )

    def test_zero_division(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("0", 5)
        _dynamic_test(
            self,
            isinstance(result, str) and "zero" in result.lower(),
            "Returns correct error message for division by zero",
            f"Expected ZeroDivisionError message, got {result}",
        )

    def test_value_error(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("notanumber", 5)
        _dynamic_test(
            self,
            isinstance(result, str) and "value" in result.lower(),
            "Returns correct error message for invalid integer input",
            f"Expected ValueError message, got {result}",
        )

    def test_negative_integer(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("-20", 5)
        _dynamic_test(
            self,
            result == -5.0,
            "Correct result for negative integer input",
            f"Expected -5.0, got {result}",
        )

    def test_float_string(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("3.5", 5)
        _dynamic_test(
            self,
            isinstance(result, str) and "value" in result.lower(),
            "Returns correct error message for non-integer string input",
            f"Expected ValueError message, got {result}",
        )

    def test_large_integer(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("1000", 5)
        _dynamic_test(
            self,
            abs(result - 0.1) < 1e-9,
            "Correct result for large integer input",
            f"Expected 0.1, got {result}",
        )

    def test_leading_trailing_spaces(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("   4   ", 5)
        _dynamic_test(
            self,
            result == 25.0,
            "Correct result for input string with spaces",
            f"Expected 25.0, got {result}",
        )

    def test_empty_string(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.safe_divide_from_string("", 5)
        _dynamic_test(
            self,
            isinstance(result, str) and "value" in result.lower(),
            "Returns correct error message for empty string input",
            f"Expected ValueError message, got {result}",
        )

    def test_divisor_argument_unused(self):
        import user_code
        importlib.reload(user_code)
        # The divisor argument should not affect the result
        result1 = user_code.safe_divide_from_string("4", 1)
        result2 = user_code.safe_divide_from_string("4", 9999)
        _dynamic_test(
            self,
            result1 == result2 == 25.0,
            "Divisor argument is not used in calculation",
            f"Expected both results to be 25.0, got {result1} and {result2}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

A beginner-friendly course introducing Python's error handling mechanisms, including try-except blocks, exception types, and best practices for writing robust code.

Learn what exceptions are in Python, why they occur, and how to handle them using basic try-except blocks.

Explore more advanced features of Python's exception handling, including else, finally, and handling multiple exceptions.

Learn how to define your own exceptions and follow best practices for robust error handling in Python.

Challenge: Catching Multiple Exceptions

Why Catch Multiple Exceptions

Handling Multiple Exceptions in a Single Try-Except Block

Solución