이펙티브 파이썬 6장 - 메타클래스와 애트리뷰트

Better way 44 세터와 게터 메서드 대신 평범한 애트리뷰트를 사용하라

setter, getter 메서드 활용이 아닌 애트리뷰트를 직접 활용하자

# 안 좋은 예시 - getter, setter 활용
class Person:
    def __init__(self):
        self._name = ''

    def get_name(self):
        return self._name

    def set_name(self, value):
        self._name = value

p = Person()
p.set_name('Sungchan')
print(p.get_name())

# 좋은 예시 - 애트리뷰트 활용
class Person:
    def __init__(self):
        self.name = ''

p = Person()
p.name = 'Sungchan'
print(p.name)

만약에 특정 애트리뷰트가 설정될 때, 특별한 기능을 수행한다면 @property를 활용하자

class Person:
    def __init__(self):
        self._age = 0

    @property # 애트리뷰트 값 조회 시, 해당 함수 호출
    def age(self):
        return self._age

    @age.setter # age 애트리뷰트 값 변경 시, 해당 함수 호출
    def age(self, value):
        if value < 0:
            raise ValueError("나이는 음수가 될 수 없습니다.")
        self._age = value

p = Person()
p.age = 25
print(p.age)  # 25

p.age = -3  # ValueError: 나이는 음수가 될 수 없습니다.

@property 사용시 주의점

I/O 또는 DB 조회와 같은 수행 시간이 오래 걸리거나 비용이 비싼 내용을 사용하지 않는다.
다른 객체를 조회하거나 포함하는 복잡한 코드를 작성하지 않는다.

-> 개발자가 인식하기 어려움, 일반 메소드를 사용하자

Better way 45 애트리뷰트를 리팩터링하는 대신 @property를 사용하라

상품의 가격과 할인 정책을 관리하는 객체가 있다.

가격과 할인 정책이 항상 연동되는 객체가 필요한다고 가정하자.

class Product:
    def __init__(self, price):
        self._price = price
        self._discount_rate = 0.1  # 기본 할인율 10%

    @property
    def price(self):
        return int(self._price * (1 - self._discount_rate))

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("가격은 음수가 될 수 없습니다.")
        self._price = value

    @property
    def discount_rate(self):
        return self._discount_rate

    @discount_rate.setter
    def discount_rate(self, value):
        if not 0 <= value <= 1:
            raise ValueError("할인율은 0~1 사이여야 합니다.")
        self._discount_rate = value

# 사용 예시
p = Product(10000)
print(p.price)  # 9000 (10% 할인)

p.discount_rate = 0.2
print(p.price)  # 8000 (20% 할인)

p.price = 20000
print(p.price)  # 16000 (20% 할인 적용된 새 가격)

Better way 46 재사용 가능한 @property 메서드를 만들려면 디스크립터를 사용하라

@propery의 단점으로는 재사용성이 어렵다.

각각의 property 마다 @propery, @property.setter 에 해당하는 메소드를 구현해야한다.

동일한 로직, 내용의 property를 활용할 때는 디스크립터를 사용하자.

# 안 좋은 예시 - propery 각각 구현
class Product:
    def __init__(self, price, weight):
        self._price = price
        self._weight = weight

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("가격은 음수일 수 없습니다.")
        self._price = value

    @property
    def weight(self): # price property 와 로직 중복
        return self._weight

    @weight.setter
    def weight(self, value): # price property 와 검증 로직 중복
        if value < 0:
            raise ValueError("무게는 음수일 수 없습니다.")
        self._weight = value

class Positive: # 디스크립터
    def __set_name__(self, owner, name):
        self.name = f"_{name}"

    def __get__(self, instance, owner): # 디스크립터로 사용하기 위해 __get__, __set__ 구현 필수 
        return getattr(instance, self.name)

    def __set__(self, instance, value): # 디스크립터로 사용하기 위해 __get__, __set__ 구현 필수 
        if value < 0:
            raise ValueError(f"{self.name[1:]}는(은) 음수일 수 없습니다.")
        setattr(instance, self.name, value)


class Product:
    price = Positive() # Positive 디스크립터 활용
    weight = Positive() # Positive 디스크립터 활용

    def __init__(self, price, weight):
        self.price = price
        self.weight = weight
        
p = Product(10000, 2.5)
print(p.price)   # 10000
print(p.weight)  # 2.5

p.price = 5000   # 정상
# p.weight = -1  # ValueError: weight는(은) 음수일 수 없습니다.

Better way 47 지연 계산 애트리뷰트가 필요하면 getattr, getattribute, setattr을 사용하라

메서드	호출 시점	용도
__getattribute__	모든 속성 접근 시 무조건 호출	속성 접근 전처리, 감시, 로깅 등
__getattr__	속성이 존재하지 않을 때만 호출	동적 속성 생성, 지연 계산 등
__setattr__	모든 속성 설정 시 호출	값 검증, 자동 로그, 내부 저장 방식 변경 등

class DynamicAttrs: # 애트리뷰트가 없으면 동적으로 애트리뷰트를 추가하는 클래스
    def __init__(self):
        self.existing = 42

    def __getattribute__(self, name): # 애트리뷰트 접근 시 - 무조건 호출
        print(f"[getattribute] {name} 접근 시도")
        return super().__getattribute__(name)  # 무한 재귀 방지!

    def __getattr__(self, name): # 애트리뷰트가 존재하지 않을 때
        print(f"[getattr] {name} 속성이 존재하지 않아 동적으로 생성")
        value = f"{name}을 위한 값" # 임시 변수 값 생성 
        setattr(self, name, value) # 애트리뷰트 추가
        return value

    def __setattr__(self, name, value): # 애트리뷰트 값 수정 시 호출
        print(f"[setattr] {name} 설정: {value}")
        super().__setattr__(name, value)
        
        

obj = DynamicAttrs()

# 존재하는 속성 접근
print(obj.existing)
# => [getattribute] existing 접근 시도
# => 42

# 존재하지 않는 속성 접근 → getattr 작동
print(obj.missing)
# => [getattribute] missing 접근 시도
# => [getattr] missing 속성이 존재하지 않아 동적으로 생성
# => missing을 위한 값

# 다시 접근 시 → 이미 존재하므로 getattr은 호출되지 않음
print(obj.missing)
# => [getattribute] missing 접근 시도
# => missing을 위한 값

Better way 48 __init_subclass__를 사용해 하위 클래스를 검증하라

상속받는 하위 클래스가 특정 규칙을 따르도록 강제하고 싶을 때, __init_subclass__를 활용할 수 있다.

추상 메소드를 선언하고 하위 클래스에서 구현하는 것보다 유연한다는 장점이 있다.

믹스인 하여 사용하기도 훨씬 좋다.

두 가지 부모 클래스가 있다.

1. 다각형이 유효한지 검사 (sides >= 3)

2. 색이 파란색을 썼는지 검사 (color == 'blue')

class Polygon: # sides 가 3개 이상인지 확인
    def __init_subclass__(cls):
        super().__init_subclass__()
        if not hasattr(cls, 'sides'):
            raise TypeError(f"{cls.__name__}는 'sides' 속성을 정의해야 합니다.")
        if cls.sides < 3:
            raise ValueError(f"{cls.__name__}는 최소 3개의 변을 가져야 합니다.")
            
class Triangle(Polygon):
    sides = 3  # ✅ 유효

class Line(Polygon):
    sides = 1  # ❌ ValueError: Line는 최소 3개의 변을 가져야 합니다.

믹스인 예시

class BlueShape:
    def __init_subclass__(cls):
        super().__init_subclass__()
        if not hasattr(cls, 'color'):
            raise TypeError(f"{cls.__name__}는 'color' 속성을 정의해야 합니다.")
        if cls.color != 'blue':
            raise ValueError(f"{cls.__name__}는 color가 반드시 'blue'여야 합니다.")


class BlueSquare(Polygon, BlueShape): # 믹스인하여 두 가지 클래스 검증 가능
    sides = 4
    color = 'blue'  # ✅ 유효

class RedSquare(Polygon, BlueShape): # 믹스인하여 두 가지 클래스 검증 가능
    sides = 4
    color = 'red'  # ❌ ValueError: RedSquare는 color가 반드시 'blue'여야 합니다.

Better way 49 __init_subclass__를 사용해 클래스 확장을 등록하라

플러그인, 명령어, 핸들러 등을 만들 때, 상속으로 하면 자동으로 등록되는 구조를 구현할 수 있다.

class CommandBase: # 명령어 집합
    registry = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        name = cls.__name__.lower().replace("command", "")
        CommandBase.registry[name] = cls
        
class HelloCommand(CommandBase): # CommandBase를 상속 -> CommandBase.registry에 등록
    def run(self): 
        print("안녕하세요!")

class ExitCommand(CommandBase): # CommandBase를 상속 -> CommandBase.registry에 등록
    def run(self):
        print("종료합니다.")

# 등록된 커맨드 확인
print(CommandBase.registry)
# {'hello': <class '__main__.HelloCommand'>, 'exit': <class '__main__.ExitCommand'>}

# 커맨드 실행
CommandBase.registry['hello']().run()  # 안녕하세요!
CommandBase.registry['exit']().run()   # 종료합니다.

Better way 51 합성 가능한 클래스 확장이 필요하면 메타클래스보다는 클래스 데코레이터를 사용하라

비교 항목	클래스 데코레이터 (Python)	메타클래스 (Python)	어노테이션 (Java)
적용 대상	클래스 전체	클래스 전체	클래스, 메서드, 필드 등
사용 방식	@decorator	metaclass=...	@AnnotationName
사용 시점	클래스 정의 후 - 클래스 전체가 만들어진 다음 @decorator(cls) 호출	클래스 정의 중 - type.__new__ 이나 __init__ 에서 클래스 생성 과정에서 관여	컴파일 시 / 런타임 시
기능 변경 방식	메서드 추가, 속성 변경 등 동적 확장	클래스 생성 방식 변경	리플렉션 기반 처리 (프레임워크가 해석함)
합성 가능성	O (여러 개 중첩 가능)	X (하나만 사용 가능)	O (여러 어노테이션 가능)

클래스 내 메서드의 동작을 로깅하는 클래스 데코레이터

def enhance_class(cls): # 클래스 데코레이터, 메소드 동작을 로깅함
    # 모든 메서드에 로깅 추가
    for attr_name, attr_value in cls.__dict__.items():
        if callable(attr_value):
            def wrapper(func):
                def wrapped(self, *args, **kwargs):
                    print(f"[LOG] {func.__name__} called")
                    return func(self, *args, **kwargs)
                return wrapped
            setattr(cls, attr_name, wrapper(attr_value))

    # 클래스에 공통 속성 추가
    cls.created_by = "system"
    return cls

@enhance_class
class User:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}")
        

u = User("pasa")
u.greet()
print(u.created_by)


# 출력
# [LOG] __init__ called
# [LOG] greet called
# Hello, pasa
# system

정리

비교	클래스 데코레이터	메타클래스
호출 시점	클래스 정의 후	클래스 정의 중
개입 대상	완성된 클래스 객체	클래스 생성 프로세스
유연성	간단한 확장, 합성에 유리	구조적인 제어에 강력
난이도	낮음	높음

저작자표시 비영리 변경금지

'🐍 Python' 카테고리의 다른 글

이펙티브 파이썬 7장 - 동시성과 병렬성 (0)	2025.04.01
이펙티브 파이썬 5장 - 클래스와 인터페이스 (0)	2025.03.21
이펙티브 파이썬 4장 - 컴프리헨션과 제너레이터 (0)	2025.03.18
이펙티브 파이썬 3장 - 함수 (0)	2025.03.17
이펙티브 파이썬 2장 - 리스트와 딕셔너리 (0)	2025.03.12

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

dev.py

이펙티브 파이썬 6장 - 메타클래스와 애트리뷰트

Better way 44 세터와 게터 메서드 대신 평범한 애트리뷰트를 사용하라

Better way 45 애트리뷰트를 리팩터링하는 대신 @property를 사용하라

Better way 46 재사용 가능한 @property 메서드를 만들려면 디스크립터를 사용하라

Better way 47 지연 계산 애트리뷰트가 필요하면 getattr, getattribute, setattr을 사용하라

Better way 48 __init_subclass__를 사용해 하위 클래스를 검증하라

Better way 49 __init_subclass__를 사용해 클래스 확장을 등록하라

Better way 51 합성 가능한 클래스 확장이 필요하면 메타클래스보다는 클래스 데코레이터를 사용하라

'🐍 Python' 카테고리의 다른 글

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역

이펙티브 파이썬 6장 - 메타클래스와 애트리뷰트

Better way 44 세터와 게터 메서드 대신 평범한 애트리뷰트를 사용하라

Better way 45 애트리뷰트를 리팩터링하는 대신 @property를 사용하라

Better way 46 재사용 가능한 @property 메서드를 만들려면 디스크립터를 사용하라

Better way 47 지연 계산 애트리뷰트가 필요하면 __getattr__, __getattribute__, __setattr__을 사용하라

Better way 48 __init_subclass__를 사용해 하위 클래스를 검증하라

Better way 49 __init_subclass__를 사용해 클래스 확장을 등록하라

Better way 51 합성 가능한 클래스 확장이 필요하면 메타클래스보다는 클래스 데코레이터를 사용하라

'🐍 Python' 카테고리의 다른 글

관련글

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역

Better way 47 지연 계산 애트리뷰트가 필요하면 getattr, getattribute, setattr을 사용하라