## Combining else and except in try-except Blocks

Using **`try-except-else`** in Python allows you to clearly separate normal program logic from error handling. The **`except`** block handles exceptions if they occur, while the **`else`** block runs only when no exception is raised. This makes your code easier to read and maintain.

Consider a scenario where you want to convert a string to an integer. If the conversion fails, you need to handle the error. If it succeeds, you want to continue with normal logic. Placing the success logic in an **`else`** block ensures it only runs when no exceptions are raised, keeping your error handling and normal logic distinct.

**Benefits of using else with try-except:**

- Improves code clarity by separating error handling from normal logic;
- Prevents accidental execution of code that should only run when no errors occur;
- Makes your intent explicit to anyone reading your code.

This approach is especially helpful in larger programs where mixing error handling and normal logic can lead to confusion or subtle bugs.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_successful_conversion(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.convert_and_report('42')
        output = normalize_text(f.getvalue())
        expected = normalize_text('Conversion successful: 42')
        _dynamic_test(
            self,
            expected in output,
            "Prints correct success message for valid integer input",
            f"Expected output: '{expected}' not found in: '{output}'",
        )

    def test_failed_conversion(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.convert_and_report('abc')
        output = normalize_text(f.getvalue())
        expected = normalize_text('Conversion failed: invalid integer')
        _dynamic_test(
            self,
            expected in output,
            "Prints correct failure message for invalid integer input",
            f"Expected output: '{expected}' not found in: '{output}'",
        )

    def test_no_success_on_failure(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.convert_and_report('abc')
        output = normalize_text(f.getvalue())
        not_expected = normalize_text('Conversion successful:')
        _dynamic_test(
            self,
            not_expected not in output,
            "Does not print success message when conversion fails",
            f"Unexpected success message found in: '{output}'",
        )

    def test_no_failure_on_success(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.convert_and_report('42')
        output = normalize_text(f.getvalue())
        not_expected = normalize_text('Conversion failed: invalid integer')
        _dynamic_test(
            self,
            not_expected not in output,
            "Does not print failure message when conversion succeeds",
            f"Unexpected failure message found in: '{output}'",
        )

    def test_function_exists(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'convert_and_report', None)
        _dynamic_test(
            self,
            callable(func),
            "Function convert_and_report is defined",
            "Function convert_and_report is not defined",
        )

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: Combining else and except

Combining else and except in try-except Blocks

解答