At this point, you have seen that **metaclasses** are powerful tools in Python that can intervene in the class creation process. One of the key features of **metaclasses** is their ability to modify or add attributes to the classes they create. By customizing the `__new__` or `__init__` methods of a metaclass, you can systematically inject new behavior or data into every class that uses your metaclass, ensuring consistency and reducing repetitive code. This is especially useful when you want all classes of a certain kind to share a specific attribute or property, as the metaclass can handle it automatically during class creation.


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_myclass_has_attribute(self):
        import user_code
        importlib.reload(user_code)
        MyClass = getattr(user_code, 'MyClass', None)
        has_attr = hasattr(MyClass, 'created_by_metaclass')
        value = getattr(MyClass, 'created_by_metaclass', None)
        _dynamic_test(
            self,
            has_attr and value is True,
            "MyClass has attribute 'created_by_metaclass' set to True",
            f"MyClass missing 'created_by_metaclass' or value is not True (got {value})",
        )

    def test_anotherclass_has_attribute(self):
        import user_code
        importlib.reload(user_code)
        AnotherClass = getattr(user_code, 'AnotherClass', None)
        has_attr = hasattr(AnotherClass, 'created_by_metaclass')
        value = getattr(AnotherClass, 'created_by_metaclass', None)
        _dynamic_test(
            self,
            has_attr and value is True,
            "AnotherClass has attribute 'created_by_metaclass' set to True",
            f"AnotherClass missing 'created_by_metaclass' or value is not True (got {value})",
        )

    def test_any_class_using_metaclass(self):
        code = """
class AddCreatedByMetaclass(type):
    def __new__(mcs, name, bases, namespace):
        # Write your code here
        return super().__new__(mcs, name, bases, namespace)
"""
        # Insert user solution for metaclass
        with open("user_code.py", "r") as f:
            user_code_lines = f.read().splitlines()
        for i, line in enumerate(user_code_lines):
            if line.strip().startswith('def __new__'):
                # Copy user __new__ body
                code_lines = user_code_lines[i:]
                code += '\\n' + '\\n'.join(code_lines)
                break
        code += """
class TestClass(metaclass=AddCreatedByMetaclass):
    pass
"""
        ns = {}
        try:
            exec(code, ns)
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "No exception when creating a class with AddCreatedByMetaclass",
                f"Exception occurred: {e}",
            )
            return
        TestClass = ns.get('TestClass', None)
        has_attr = hasattr(TestClass, 'created_by_metaclass')
        value = getattr(TestClass, 'created_by_metaclass', None)
        _dynamic_test(
            self,
            has_attr and value is True,
            "Any class using AddCreatedByMetaclass gets attribute set to True",
            f"TestClass missing 'created_by_metaclass' or value is not True (got {value})",
        )

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: Customizing Class Attributes

解答