이 랩에서는 Python 의 가장 강력하고 고급 기능 중 하나인 메타클래스 (metaclasses) 에 대해 배우게 됩니다. 메타클래스를 사용하면 클래스 생성을 사용자 정의하여 클래스가 정의되고 인스턴스화되는 방식을 제어할 수 있습니다. 실용적인 예제를 통해 메타클래스를 탐구할 것입니다.
이 랩의 목표는 메타클래스가 무엇이며 어떻게 작동하는지 이해하고, 실제 프로그래밍 문제를 해결하기 위해 메타클래스를 구현하며, Python 에서 메타클래스의 실용적인 응용 프로그램을 탐구하는 것입니다. 이 랩에서 수정되는 파일은 structure.py와 validate.py입니다.
메타클래스를 탐구하기 전에, 해결하려는 문제를 이해하는 것이 중요합니다. 프로그래밍에서 우리는 종종 속성에 특정 유형을 가진 구조를 생성해야 합니다. 이전 작업에서 우리는 유형 검사 (type-checked) 구조를 위한 시스템을 개발했습니다. 이 시스템을 사용하면 각 속성이 특정 유형을 가지며, 이러한 속성에 할당된 값이 해당 유형에 따라 검증되는 클래스를 정의할 수 있습니다.
다음은 이 시스템을 사용하여 Stock 클래스를 생성하는 예입니다.
from validate import String, PositiveInteger, PositiveFloat
from structure import Structure
class Stock(Structure):
name = String()
shares = PositiveInteger()
price = PositiveFloat()
@property
def cost(self):
return self.shares * self.price
def sell(self, nshares: PositiveInteger):
self.shares -= nshares이 코드에서 먼저 validate 모듈에서 검증자 유형 (String, PositiveInteger, PositiveFloat) 을 가져오고, structure 모듈에서 Structure 클래스를 가져옵니다. 그런 다음 Structure에서 상속받는 Stock 클래스를 정의합니다. Stock 클래스 내에서 특정 검증자 유형을 가진 속성을 정의합니다. 예를 들어, name 속성은 문자열이어야 하고, shares는 양의 정수여야 하며, price는 양의 부동 소수점 숫자여야 합니다.
그러나 이 접근 방식에는 문제가 있습니다. 파일 상단에서 모든 검증자 유형을 가져와야 합니다. 실제 시나리오에서 검증자 유형을 더 많이 추가할수록 이러한 가져오기가 매우 길어지고 관리하기 어려워질 수 있습니다. 이는 from validate import *를 사용하게 될 수 있는데, 이는 이름 충돌을 일으키고 코드를 덜 읽기 쉽게 만들 수 있으므로 일반적으로 권장되지 않는 방식입니다.
시작점을 이해하기 위해 Structure 클래스를 살펴보겠습니다. 편집기에서 structure.py 파일을 열고 내용을 검토해야 합니다. 이렇게 하면 메타클래스 기능을 추가하기 전에 기본 구조 처리가 어떻게 구현되는지 확인할 수 있습니다.
code structure.py파일을 열면 Structure 클래스의 기본 구현을 볼 수 있습니다. 이 클래스는 속성 초기화를 처리하지만 아직 메타클래스 기능이 없습니다.
다음으로, 검증자 클래스를 살펴보겠습니다. 이러한 클래스는 validate.py 파일에 정의되어 있습니다. 이미 디스크립터 (descriptor) 기능을 가지고 있으며, 이는 속성에 액세스하고 설정하는 방식을 제어할 수 있음을 의미합니다. 그러나 앞서 논의한 가져오기 문제를 해결하기 위해 이를 개선해야 합니다.
code validate.py이러한 검증자 클래스를 살펴보면 검증 프로세스가 어떻게 작동하는지, 그리고 코드를 개선하기 위해 어떤 변경을 해야 하는지 더 잘 이해할 수 있습니다.
Python 에서 검증자 (validators) 는 데이터가 특정 기준을 충족하는지 확인하는 데 도움이 되는 클래스입니다. 이 실험의 첫 번째 작업은 기본 Validator 클래스를 수정하여 모든 하위 클래스를 수집할 수 있도록 하는 것입니다. 왜 이렇게 해야 할까요? 모든 검증자 하위 클래스를 수집함으로써 모든 검증자 유형을 포함하는 네임스페이스 (namespace) 를 생성할 수 있습니다. 나중에 이 네임스페이스를 Structure 클래스에 주입하여 다양한 검증자를 더 쉽게 관리하고 사용할 수 있도록 할 것입니다.
이제 코드를 시작해 보겠습니다. validate.py 파일을 엽니다. 터미널에서 다음 명령을 사용하여 열 수 있습니다.
code validate.py파일이 열리면 Validator 클래스에 클래스 수준 딕셔너리와 __init_subclass__() 메서드를 추가해야 합니다. 클래스 수준 딕셔너리는 모든 검증자 하위 클래스를 저장하는 데 사용되며, __init_subclass__() 메서드는 현재 클래스의 하위 클래스가 정의될 때마다 호출되는 Python 의 특수 메서드입니다.
클래스 정의 바로 뒤에 다음 코드를 Validator 클래스에 추가합니다.
## Add this to the Validator class in validate.py
validators = {} ## Dictionary to collect all validator subclasses
@classmethod
def __init_subclass__(cls):
"""Register each validator subclass in the validators dictionary"""
Validator.validators[cls.__name__] = cls코드를 추가한 후 수정된 Validator 클래스는 다음과 같아야 합니다.
class Validator:
validators = {} ## Dictionary to collect all validator subclasses
@classmethod
def __init_subclass__(cls):
"""Register each validator subclass in the validators dictionary"""
Validator.validators[cls.__name__] = cls
def __set_name__(self, owner, name):
self.name = name
def __get__(self, instance, owner):
if instance is None:
return self
return instance.__dict__[self.name]
def __set__(self, instance, value):
self.validate(value)
instance.__dict__[self.name] = value
def validate(self, value):
pass이제 String 또는 PositiveInteger와 같은 새로운 검증자 유형이 정의될 때마다 Python 은 자동으로 __init_subclass__() 메서드를 호출합니다. 그런 다음 이 메서드는 클래스 이름을 키로 사용하여 새 검증자 하위 클래스를 validators 딕셔너리에 추가합니다.
코드가 작동하는지 테스트해 보겠습니다. validators 딕셔너리의 내용을 확인하는 간단한 Python 스크립트를 생성합니다. 터미널에서 다음 명령을 실행할 수 있습니다.
python3 -c "from validate import Validator; print(Validator.validators)"모든 것이 제대로 작동하면 다음과 유사한 출력이 표시되어 모든 검증자 유형과 해당 클래스를 보여줍니다.
{'Typed': <class 'validate.Typed'>, 'Positive': <class 'validate.Positive'>, 'NonEmpty': <class 'validate.NonEmpty'>, 'String': <class 'validate.String'>, 'Integer': <class 'validate.Integer'>, 'Float': <class 'validate.Float'>, 'PositiveInteger': <class 'validate.PositiveInteger'>, 'PositiveFloat': <class 'validate.PositiveFloat'>, 'NonEmptyString': <class 'validate.NonEmptyString'>}이제 모든 검증자 유형을 포함하는 딕셔너리가 있으므로 다음 단계에서 메타클래스를 생성하는 데 사용할 수 있습니다.
이제 다음에 할 일에 대해 이야기해 보겠습니다. 모든 검증자 유형을 수집하는 방법을 찾았습니다. 다음 단계는 메타클래스를 만드는 것입니다. 하지만 메타클래스란 정확히 무엇일까요? Python 에서 메타클래스는 특별한 종류의 클래스입니다. 그 인스턴스는 클래스 자체입니다. 즉, 메타클래스는 클래스가 생성되는 방식을 제어할 수 있습니다. 클래스 속성이 정의되는 네임스페이스를 관리할 수 있습니다.
이 상황에서 우리는 Structure 하위 클래스를 정의할 때 검증자 유형을 사용할 수 있도록 하는 메타클래스를 만들고 싶습니다. 매번 이러한 검증자 유형을 명시적으로 가져올 필요가 없도록 하려는 것입니다.
structure.py 파일을 다시 열어 시작해 보겠습니다. 다음 명령을 사용하여 열 수 있습니다.
code structure.py파일이 열리면 Structure 클래스 정의 앞에 몇 줄의 코드를 추가해야 합니다. 이 코드는 메타클래스를 정의합니다.
from validate import Validator
from collections import ChainMap
class StructureMeta(type):
@classmethod
def __prepare__(meta, clsname, bases):
"""Prepare the namespace for the class being defined"""
return ChainMap({}, Validator.validators)
@staticmethod
def __new__(meta, name, bases, methods):
"""Create the new class using only the local namespace"""
methods = methods.maps[0] ## Extract the local namespace
return super().__new__(meta, name, bases, methods)이제 메타클래스를 정의했으므로 이를 사용하도록 Structure 클래스를 수정해야 합니다. 이렇게 하면 Structure에서 상속받는 모든 클래스가 메타클래스의 기능을 활용할 수 있습니다.
class Structure(metaclass=StructureMeta):
_fields = []
def __init__(self, *args, **kwargs):
if len(args) > len(self._fields):
raise TypeError(f'Expected {len(self._fields)} arguments')
## Set all of the positional arguments
for name, val in zip(self._fields, args):
setattr(self, name, val)
## Set the remaining keyword arguments
for name, val in kwargs.items():
if name not in self._fields:
raise TypeError(f'Invalid argument: {name}')
setattr(self, name, val)
def __repr__(self):
values = [getattr(self, name) for name in self._fields]
args_str = ','.join(repr(val) for val in values)
return f'{type(self).__name__}({args_str})'이 코드가 하는 일을 자세히 살펴보겠습니다.
__prepare__() 메서드는 Python 의 특수 메서드입니다. 클래스가 생성되기 전에 호출됩니다. 이 메서드의 역할은 클래스 속성이 정의될 네임스페이스를 준비하는 것입니다. 여기서는 ChainMap을 사용합니다. ChainMap은 계층화된 딕셔너리를 생성하는 유용한 도구입니다. 이 경우 검증자 유형을 포함하여 클래스 네임스페이스에서 액세스할 수 있도록 합니다.
__new__() 메서드는 새 클래스를 생성하는 역할을 합니다. 로컬 네임스페이스만 추출합니다. 즉, ChainMap의 첫 번째 딕셔너리입니다. 네임스페이스에서 검증자 유형을 이미 사용할 수 있도록 했으므로 검증자 딕셔너리는 버립니다.
이 설정을 사용하면 Structure에서 상속받는 모든 클래스가 명시적으로 가져올 필요 없이 모든 검증자 유형에 액세스할 수 있습니다.
이제 구현을 테스트해 보겠습니다. 향상된 Structure 기본 클래스를 사용하여 Stock 클래스를 생성합니다.
cat > stock.py << EOF
from structure import Structure
class Stock(Structure):
name = String()
shares = PositiveInteger()
price = PositiveFloat()
@property
def cost(self):
return self.shares * self.price
def sell(self, nshares: PositiveInteger):
self.shares -= nshares
EOF메타클래스가 제대로 작동하면 검증자 유형을 가져오지 않고도 Stock 클래스를 정의할 수 있어야 합니다. 이는 메타클래스가 이미 네임스페이스에서 사용할 수 있도록 했기 때문입니다.
이제 메타클래스를 구현하고 Structure 클래스를 수정했으므로 구현을 테스트할 차례입니다. 테스트는 모든 것이 제대로 작동하는지 확인하는 데 도움이 되므로 매우 중요합니다. 테스트를 실행함으로써 잠재적인 문제를 조기에 파악하고 코드가 예상대로 작동하는지 확인할 수 있습니다.
먼저, 유닛 테스트를 실행하여 Stock 클래스가 예상대로 작동하는지 확인해 보겠습니다. 유닛 테스트는 코드의 개별 부분을 확인하는 작고 격리된 테스트입니다. 이 경우 Stock 클래스가 올바르게 작동하는지 확인하려고 합니다. 유닛 테스트를 실행하려면 터미널에서 다음 명령을 사용합니다.
python3 teststock.py모든 것이 제대로 작동하면 모든 테스트가 오류 없이 통과해야 합니다. 테스트가 성공적으로 실행되면 출력은 다음과 유사해야 합니다.
........
----------------------------------------------------------------------
Ran 6 tests in 0.001s
OK점은 통과된 각 테스트를 나타내고, 마지막 OK는 모든 테스트가 성공했음을 나타냅니다.
이제 실제 데이터와 테이블 형식 기능을 사용하여 Stock 클래스를 테스트해 보겠습니다. 이렇게 하면 Stock 클래스가 데이터와 상호 작용하는 방식과 테이블 형식이 작동하는 방식을 확인할 수 있는 보다 실제적인 시나리오를 얻을 수 있습니다. 터미널에서 다음 명령을 사용합니다.
python3 -c "
from stock import Stock
from reader import read_csv_as_instances
from tableformat import create_formatter, print_table
## Read portfolio data into Stock instances
portfolio = read_csv_as_instances('portfolio.csv', Stock)
print('Portfolio:')
print(portfolio)
## Format and print the portfolio data
print('\nFormatted table:')
formatter = create_formatter('text')
print_table(portfolio, ['name', 'shares', 'price'], formatter)
"이 코드에서는 먼저 필요한 클래스와 함수를 가져옵니다. 그런 다음 CSV 파일에서 데이터를 Stock 인스턴스로 읽습니다. 그 후 포트폴리오 데이터를 출력한 다음 테이블 형식으로 지정하고 형식화된 테이블을 출력합니다.
다음과 유사한 출력이 표시되어야 합니다.
Portfolio:
[Stock('AA',100,32.2), Stock('IBM',50,91.1), Stock('CAT',150,83.44), Stock('MSFT',200,51.23), Stock('GE',95,40.37), Stock('MSFT',50,65.1), Stock('IBM',100,70.44)]
Formatted table:
name shares price
---------- ---------- ----------
AA 100 32.2
IBM 50 91.1
CAT 150 83.44
MSFT 200 51.23
GE 95 40.37
MSFT 50 65.1
IBM 100 70.44잠시 시간을 내어 우리가 달성한 것을 생각해 보십시오.
Structure 하위 클래스의 네임스페이스에 주입하는 메타클래스를 구현했습니다. 이를 통해 하위 클래스는 이러한 검증자를 명시적으로 가져올 필요 없이 사용할 수 있습니다.최종 stock.py 파일은 메타클래스가 없었을 때보다 훨씬 깔끔합니다.
from structure import Structure
class Stock(Structure):
name = String()
shares = PositiveInteger()
price = PositiveFloat()
@property
def cost(self):
return self.shares * self.price
def sell(self, nshares: PositiveInteger):
self.shares -= nshares검증자 유형을 직접 가져올 필요가 없으므로 코드가 더 간결하고 유지 관리하기 쉽습니다. 이것은 메타클래스가 코드의 품질을 향상시킬 수 있는 좋은 예입니다.
이 랩에서는 Python 에서 메타클래스의 강력한 기능을 활용하는 방법을 배웠습니다. 먼저, 검증자 유형에 대한 import 를 관리하는 문제에 대해 이해했습니다. 그런 다음, Validator 클래스를 수정하여 하위 클래스를 자동으로 수집하고, 검증자 유형을 클래스 네임스페이스에 주입하는 StructureMeta 메타클래스를 만들었습니다. 마지막으로, Stock 클래스를 사용하여 구현을 테스트하여 명시적인 import 의 필요성을 없앴습니다.
고급 Python 기능인 메타클래스는 클래스 생성 프로세스를 사용자 정의할 수 있도록 합니다. 신중하게 사용해야 하지만, 이 랩에서 보여준 것처럼 특정 문제에 대한 우아한 솔루션을 제공합니다. 메타클래스를 사용함으로써, 검증된 속성을 가진 구조를 정의하는 코드를 단순화하고, 명시적인 검증자 유형 import 의 필요성을 제거했으며, 더 유지 관리하기 쉽고 우아한 API 를 만들었습니다. 이 메타클래스 기반 네임스페이스 주입 패턴은 단순화된 사용자 API 를 위해 다른 시나리오에도 적용할 수 있습니다.