You have seen how metaclasses can be used to implement the **singleton pattern**, ensuring that only a single instance of a class is ever created. This is especially useful for classes like loggers, where global state or resource management is important. By customizing the `__call__` method in a metaclass, you can intercept object instantiation and control instance creation in a way that regular classes cannot.


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_singleton_instance(self):
        import user_code
        importlib.reload(user_code)
        logger1 = user_code.Logger("AppLogger")
        logger2 = user_code.Logger("AnotherLogger")
        _dynamic_test(self, logger1 is logger2,
            "Logger returns the same instance",
            "Logger did not return the same instance for multiple instantiations.")

    def test_logger_name_first_instance(self):
        import user_code
        importlib.reload(user_code)
        logger1 = user_code.Logger("AppLogger")
        logger2 = user_code.Logger("AnotherLogger")
        expected_name = "AppLogger"
        _dynamic_test(self, logger1.name == expected_name and logger2.name == expected_name,
            "Logger name is set from first instantiation and remains unchanged",
            f"Logger name is not preserved from first instantiation. Got: logger1.name={logger1.name}, logger2.name={logger2.name}")

    def test_log_method_format(self):
        import user_code
        importlib.reload(user_code)
        logger = user_code.Logger("AppLogger")
        message = "Started"
        expected = f"[AppLogger] {message}"
        result = logger.log(message)
        _dynamic_test(self, result == expected,
            "Logger log method returns correct format",
            f"Logger log method returned '{result}', expected '{expected}'")

    def test_stdout_logging(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.logger1 = user_code.Logger("AppLogger")
            user_code.logger2 = user_code.Logger("AnotherLogger")
            print(user_code.logger1 is user_code.logger2)
            print(user_code.logger1.name)
            print(user_code.logger2.name)
            print(user_code.logger1.log("Started"))
        output = f.getvalue().splitlines()
        _dynamic_test(self, len(output) >= 4,
            "Output contains at least 4 lines",
            f"Expected at least 4 lines in output, got: {len(output)}")
        _dynamic_test(self, output[0] == "True",
            "First print confirms singleton (True)",
            f"First print should be 'True', got '{output[0]}'")
        _dynamic_test(self, output[1] == "AppLogger" and output[2] == "AppLogger",
            "Logger names printed are the first name",
            f"Logger names printed are not from the first instantiation: {output[1]}, {output[2]}")
        _dynamic_test(self, output[3] == "[AppLogger] Started",
            "Logger log output is correctly formatted",
            f"Logger log output incorrect: {output[3]}")

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: Singleton Logger

解答