Now that you have learned how to define custom metaclasses, you can use their `__new__` or `__init__` methods to run code every time a new class is created. By placing a `print` statement in either of these methods, you can observe when and how Python constructs classes that use your metaclass. This is a powerful technique for debugging, inspecting, or instrumenting class creation in complex codebases, as it gives you visibility into the metaclass machinery at work.

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

class TestTask(unittest.TestCase):
    def test_prints_class_names(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        # Reload the module to capture class creation prints
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        expected1 = normalize_text("Creating class: MyClass")
        expected2 = normalize_text("Creating class: AnotherClass")
        _dynamic_test(
            self,
            expected1 in output,
            f"Output includes line: {expected1}",
            f"Expected output: '{expected1}' not found in: '{output}'",
        )
        _dynamic_test(
            self,
            expected2 in output,
            f"Output includes line: {expected2}",
            f"Expected output: '{expected2}' not found in: '{output}'",
        )

    def test_prints_on_class_creation_only(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        # Class creation prints should only occur at import time, not instance creation
        with redirect_stdout(f):
            # Instance creation
            obj1 = user_code.MyClass()
            obj2 = user_code.AnotherClass()
        output = normalize_text(f.getvalue())
        expected1 = normalize_text("Creating class: MyClass")
        expected2 = normalize_text("Creating class: AnotherClass")
        _dynamic_test(
            self,
            expected1 not in output and expected2 not in output,
            "No class creation print on instance creation",
            f"Did not expect output on instance creation, but got: '{output}'",
        )

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()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

A beginner-friendly, hands-on course that unravels the mysteries of Python metaclasses. Learn what metaclasses are, how they work, and how to use them to create powerful, flexible, and maintainable code. Each section blends clear theory with practical, real-world tasks to ensure deep understanding.

Explore the foundational concepts of metaclasses, their relationship with classes and objects, and why they matter in Python.

Learn how to define your own metaclasses, customize class creation, and explore practical use cases.

Discover practical applications of metaclasses, including plugin systems, singletons, and API enforcement.

Challenge: Logging Class Creation

解答