Measuring how long a function takes to execute is a common requirement when you want to optimize your code or simply understand its performance. In Python, the `time` module provides functions for working with time-related tasks. When creating a timing decorator, you can use `time.time()` to record the current time before the function runs and again after it finishes. By subtracting the start time from the end time, you obtain the elapsed time, which you can then print or log. This technique is especially useful for benchmarking or profiling your code without modifying the original function logic.


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_prints_function_name(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.slow_add(1, 2)
            user_code.fast_multiply(3, 4)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "function 'slow_add' executed in" in output and "function 'fast_multiply' executed in" in output,
            "Decorator prints the name of the decorated function.",
            f"Function names not found in output: {output}",
        )

    def test_prints_elapsed_time_format(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.slow_add(2, 3)
        output = f.getvalue()
        import re
        match = re.search(r"executed in ([0-9]+\.[0-9]{6}) seconds", output)
        _dynamic_test(
            self,
            bool(match),
            "Elapsed time is printed in seconds with six decimal places.",
            f"Elapsed time format incorrect or not found in output: {output}",
        )

    def test_returns_result(self):
        import user_code
        importlib.reload(user_code)
        result_add = user_code.slow_add(4, 5)
        result_mul = user_code.fast_multiply(2, 6)
        _dynamic_test(
            self,
            result_add == 9 and result_mul == 12,
            "Decorator returns the same result as the original function.",
            f"Expected results 9 and 12, got {result_add} and {result_mul}.",
        )

    def test_works_without_delay(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.fast_multiply(7, 8)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "function 'fast_multiply' executed in" in output and result == 56,
            "Decorator works correctly for functions without delays.",
            f"Output or result incorrect for fast_multiply: output={output}, result={result}",
        )

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

Master the art of Python decorators, from foundational concepts to advanced applications. This course guides you through the mechanics, use cases, and best practices of decorators, empowering you to write more expressive and reusable Python code.

Explore the foundational concepts of Python decorators, including their syntax, how they work, and why they're useful.

Delve deeper into decorators by exploring arguments, chaining, and built-in decorators.

Explore Python's built-in decorators and practical use cases for custom decorators.

Apply your knowledge of decorators in a series of hands-on coding challenges.

Challenge: Timing Decorator

Oplossing

Challenge: Timing Decorator

Oplossing