[Python Cheatsheet] 25. Metaclass - 클래스를 만드는 클래스

1
2
3
4
5
6
7

# 모든 클래스는 type의 인스턴스
class Foo:
    pass

print(type(Foo))        # <class 'type'>
print(type(Foo()))      # <class '__main__.Foo'>
print(isinstance(Foo, type))  # True

1
2
3
4
5
6
7
8
9

# type(name, bases, namespace)
Dog = type('Dog', (), {
    'species': 'Canis familiaris',
    'bark': lambda self: print('Woof!')
})

d = Dog()
d.bark()  # Woof!
print(Dog.species)  # Canis familiaris

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class MyMeta(type):
    def __new__(mcs, name, bases, namespace):
        print(f"Creating class: {name}")
        # 클래스 생성 전에 namespace 수정 가능
        namespace['created_by'] = 'MyMeta'
        return super().__new__(mcs, name, bases, namespace)

class MyClass(metaclass=MyMeta):
    pass

# 출력: Creating class: MyClass
print(MyClass.created_by)  # MyMeta

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Singleton(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=Singleton):
    def __init__(self):
        print("Connecting...")

db1 = Database()  # Connecting...
db2 = Database()  # (출력 없음 - 같은 인스턴스)
print(db1 is db2)  # True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class PluginMeta(type):
    registry = {}
    
    def __new__(mcs, name, bases, namespace):
        cls = super().__new__(mcs, name, bases, namespace)
        if name != 'Plugin':  # 베이스 클래스 제외
            mcs.registry[name] = cls
        return cls

class Plugin(metaclass=PluginMeta):
    pass

class JSONPlugin(Plugin):
    pass

class XMLPlugin(Plugin):
    pass

print(PluginMeta.registry)
# {'JSONPlugin': <class 'JSONPlugin'>, 'XMLPlugin': <class 'XMLPlugin'>}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Plugin:
    registry = {}
    
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        Plugin.registry[cls.__name__] = cls

class JSONPlugin(Plugin):
    pass

print(Plugin.registry)  # {'JSONPlugin': <class 'JSONPlugin'>}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Meta(type):
    def __prepare__(mcs, name, bases):
        """클래스 namespace 딕셔너리 반환 (Python 3+)"""
        print(f"1. __prepare__: {name}")
        return {}
    
    def __new__(mcs, name, bases, namespace):
        """클래스 객체 생성"""
        print(f"2. __new__: {name}")
        return super().__new__(mcs, name, bases, namespace)
    
    def __init__(cls, name, bases, namespace):
        """클래스 객체 초기화"""
        print(f"3. __init__: {name}")
        super().__init__(name, bases, namespace)
    
    def __call__(cls, *args, **kwargs):
        """인스턴스 생성 시 호출"""
        print(f"4. __call__: creating instance of {cls.__name__}")
        return super().__call__(*args, **kwargs)

class MyClass(metaclass=Meta):
    pass
# 출력: 1. __prepare__, 2. __new__, 3. __init__

obj = MyClass()
# 출력: 4. __call__: creating instance of MyClass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Meta1(type): pass
class Meta2(type): pass

class A(metaclass=Meta1): pass
class B(metaclass=Meta2): pass

# TypeError: metaclass conflict
# class C(A, B): pass

# 해결: 공통 메타클래스 상속
class Meta3(Meta1, Meta2): pass
class C(A, B, metaclass=Meta3): pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 과도한 사용 - 메타클래스
class ValidateMeta(type):
    def __new__(mcs, name, bases, namespace):
        if 'process' not in namespace:
            raise TypeError(f"{name} must define process()")
        return super().__new__(mcs, name, bases, namespace)

# 더 간단한 대안 - __init_subclass__
class Base:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        if not hasattr(cls, 'process'):
            raise TypeError(f"{cls.__name__} must define process()")