DokumentePreiseBlog
Kontaktieren Sie uns
AnmeldenKOSTENLOS anmelden
Back to Tech Articles

Python 디스크립터를 Get, Set, Delete 프로토콜을 통해 파헤치기

Aug. 20, 2025
# Misc

Wenhao Wang

Dev Intern · Leapcell

Dieser Beitrag ist auch in English, 日本語 und Deutsch verfügbar
Cover of "Python 디스크립터를 Get, Set, Delete 프로토콜을 통해 파헤치기"

소개

Python의 세계에서 속성에 접근하거나 메서드를 호출하는 것처럼 겉보기에는 단순한 작업들 뒤에는 강력하지만 종종 과소평가되는 메커니즘, 즉 디스크립터 프로토콜이 숨어 있습니다. 디스크립터는 Python이 객체 속성을 처리하는 방식을 매우 동적이고 유연하게 만드는 침묵의 설계자입니다. @property 데코레이터가 어떻게 작동하는지, 또는 바인딩되지 않은 메서드와 바인딩된 메서드가 self 인수를 어떻게 관리하는지 궁금한 적이 있습니까? 그 답은 종종 디스크립터로 거슬러 올라갑니다. 이 프로토콜을 이해하는 것은 단순히 Python의 내부를 분석하는 것 이상입니다. 그것은 더 표현력이 풍부하고, 강력하며, Python스러운 코드를 작성하는 능력을 얻는 것입니다. 이 글에서는 기본 __get__, __set__, __delete__ 메서드를 탐구하여 Python 디스크립터의 미스터리를 풀고, 그 원리, 구현 및 실제 응용 프로그램을 보여줄 것입니다.

디스크립터 이해하기

핵심 프로토콜에 뛰어들기 전에 디스크립터가 무엇인지 정의해 봅시다. Python에서 __get__, __set__ 또는 __delete__ 메서드 중 하나를 구현하는 객체를 디스크립터라고 합니다. 이러한 메서드는 특별한데, 이러한 메서드를 가진 객체가 클래스 속성에 할당될 때 Python은 해당 클래스의 인스턴스에 대한 속성 접근을 디스크립터의 메서드로 위임하기 때문입니다. 이 위임은 디스크립터 프로토콜의 초석입니다.

디스크립터에는 두 가지 주요 유형이 있습니다.

  • 데이터 디스크립터: __get__와 __set__을 모두 정의하는 객체입니다. 데이터를 읽고 쓸 수 있기 때문에 "데이터"라고 합니다.
  • 비데이터 디스크립터: __get__만 정의하는 객체입니다. 주로 검색에 사용되며 인스턴스 딕셔너리에서 속성 값을 직접 수정할 수 없습니다.

데이터 디스크립터와 비데이터 디스크립터의 구분은 속성 조회 순서에 영향을 미치므로 중요합니다. 데이터 디스크립터는 인스턴스 딕셔너리에 우선권을 가지는 반면, 비데이터 디스크립터는 인스턴스 딕셔너리에 의해 재정의될 수 있습니다.

이제 디스크립터 프로토콜의 세 가지 기둥인 __get__, __set__, __delete__를 살펴보겠습니다.

__get__ 메서드

__get__ 메서드는 속성에 접근할 때 호출됩니다. 일반적으로 시그니처는 __get__(self, instance, owner)이며, 여기서:

  • self: 디스크립터 인스턴스 자체입니다.
  • instance: 속성에 접근한 클래스의 인스턴스입니다. 속성에 클래스에서 직접 접근하는 경우 (MyClass.attribute 등), instance는 None이 됩니다.
  • owner: 디스크립터를 소유한 클래스 (예: MyClass)입니다.

예제를 통해 설명해 보겠습니다.

class MyDescriptor:
    def __init__(self, value=None):
        self._value = value

    def __get__(self, instance, owner):
        if instance is None:
            print(f"클래스 '{owner.__name__}'에서 디스크립터에 직접 접근:")
            return self
        print(f"인스턴스 '{instance}'에서 속성 가져오기 (값: {self._value})")
        return self._value

    def __set__(self, instance, value):
        print(f"인스턴스 '{instance}'에 대한 속성 설정: '{value}'")
        self._value = value

class MyClass:
    descriptor_attr = MyDescriptor(10)

# 클래스에서 접근
print(MyClass.descriptor_attr)

# 인스턴스를 생성하고 접근
obj = MyClass()
print(obj.descriptor_attr)

# 출력:
# 클래스 'MyClass'에서 디스크립터에 직접 접근:
# <__main__.MyDescriptor object at 0x...> # 클래스에서 접근하면 디스크립터 객체 자체가 반환됩니다.
# 인스턴스 '<__main__.MyClass object at 0x...>'에서 속성 가져오기 (값: 10)
# 10

MyClass.descriptor_attr에 접근하면 instance가 None으로 __get__가 호출되어 디스크립터 객체 자체가 반환됩니다. obj.descriptor_attr에 접근하면 instance가 obj로 __get__가 호출되어 디스크립터가 해당 인스턴스에 특정 값을 반환하거나 여기서와 같이 공통 값을 반환할 수 있습니다.

__set__ 메서드

__set__ 메서드는 속성에 값이 할당될 때 호출됩니다. 시그니처는 __set__(self, instance, value)이며, 여기서:

  • self: 디스크립터 인스턴스입니다.
  • instance: 속성이 설정된 클래스의 인스턴스입니다.
  • value: 속성에 할당되는 값입니다.

이전 예제를 계속 진행해 보겠습니다.

# ... (위와 동일한 MyDescriptor 및 MyClass 정의) ...

obj = MyClass()
print(f"초기 obj.descriptor_attr: {obj.descriptor_attr}")

obj.descriptor_attr = 20 # MyDescriptor.__set__ 호출
print(f"업데이트된 obj.descriptor_attr: {obj.descriptor_attr}")

# 출력:
# 초기 obj.descriptor_attr: 10
# 인스턴스 '<__main__.MyClass object at 0x...>'에 대한 속성 설정: '20'
# 업데이트된 obj.descriptor_attr: 20

여기서 obj.descriptor_attr = 20이 실행되면 MyDescriptor의 __set__ 메서드가 호출되어 할당된 값을 가로채고 잠재적으로 수정하거나 유효성을 검사할 수 있습니다. 이것이 프로퍼티가 읽기/쓰기 제어를 구현하는 방식입니다.

__delete__ 메서드

__delete__ 메서드는 del 키워드를 사용하여 속성이 삭제될 때 호출됩니다. 시그니처는 __delete__(self, instance)이며, 여기서:

  • self: 디스크립터 인스턴스입니다.
  • instance: 속성이 삭제된 클래스의 인스턴스입니다.

__delete__를 포함하도록 예제를 확장해 보겠습니다.

class MyDescriptor:
    def __init__(self, value=None):
        self._value = value
        self.data = {} # 인스턴스별 값을 저장

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return self.data.get(instance, self._value) # 인스턴스에 설정되지 않은 경우 기본값으로 대체

    def __set__(self, instance, value):
        self.data[instance] = value
        print(f"인스턴스 '{instance}'에 대한 속성 설정: '{value}'")

    def __delete__(self, instance):
        if instance in self.data:
            del self.data[instance]
            print(f"인스턴스 '{instance}'에 대한 속성 삭제")
        else:
            print(f"인스턴스 '{instance}'에 대한 속성을 삭제할 수 없습니다. 속성을 찾을 수 없습니다.")


class MyClass:
    descriptor_attr = MyDescriptor(10)

obj = MyClass()
print(f"초기 obj.descriptor_attr: {obj.descriptor_attr}") # __get__ 사용, 기본값으로 대체

obj.descriptor_attr = 20 # __set__ 사용
print(f"obj.descriptor_attr 설정 후: {obj.descriptor_attr}") # 인스턴스 저장소의 __get__ 사용

del obj.descriptor_attr # __delete__ 호출
print(f"삭제 후 obj.descriptor_attr 접근 시도: {obj.descriptor_attr}") # __get__ 사용, 기본값으로 대체

# 출력:
# 초기 obj.descriptor_attr: 10
# 인스턴스 '<__main__.MyClass object at 0x...>'에 대한 속성 설정: '20'
# obj.descriptor_attr 설정 후: 20
# 인스턴스 '<__main__.MyClass object at 0x...>'에 대한 속성 삭제
# 삭제 후 obj.descriptor_attr 접근 시도: 10

이 향상된 예제에서 MyDescriptor는 data를 사용하여 인스턴스별로 값을 저장하도록 만들었습니다. del obj.descriptor_attr가 호출되면 MyDescriptor.__delete__가 호출되어 속성을 인스턴스의 내부 저장소에서 제거하는 등 정리 작업을 수행할 수 있습니다. obj.descriptor_attr를 다시 접근하면 인스턴스별 저장소가 사라졌기 때문에 디스크립터 초기화 중에 제공된 기본값으로 다시 대체됩니다.

실제 응용 프로그램

디스크립터는 단순한 학문적 호기심이 아닙니다. 그것은 많은 Python 기능이 작동하는 방식의 기초입니다.

  1. @property 데코레이터: @property 데코레이터는 아마도 가장 흔한 사용 사례일 것입니다. 클래스 메서드를 속성으로 변환하여 구문을 변경하지 않고도 클래스 멤버에 대한 제어된 접근(getter, setter, deleter)을 제공합니다.

    class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property # 이것은 디스크립터입니다!
    def radius(self):
        print("반지름 가져오기...")
        return self._radius

    @radius.setter # 이것도 디스크립터입니다!
    def radius(self, value):
        if value < 0:
            raise ValueError("반지름은 음수일 수 없습니다.")
        print(f"반지름을 {value}로 설정...")
        self._radius = value

c = Circle(5)
print(c.radius)
c.radius = 10
# c.radius = -1 # setter 때문에 ValueError 발생

  2. 바인딩된 메서드 및 바인딩되지 않은 메서드: 클래스 내에 정의된 모든 함수는 디스크립터가 됩니다. MyClass.method에 접근하면 디스크립터 자체(Python 2에서는 바인딩되지 않은 메서드, Python 3에서는 일반 함수)입니다. obj.method에 접근하면 디스크립터의 __get__ 메서드가 호출되어 obj를 함수(self)의 첫 번째 인수로 바인딩하여 바인딩된 메서드를 생성합니다.

  3. ORM 필드: SQLAlchemy와 같은 객체 관계형 Mappers (ORM)는 종종 데이터베이스 필드를 나타내기 위해 디스크립터를 사용합니다. 이를 통해 속성 접근을 가로채고, 필요할 때 데이터베이스에서 데이터를 로드하고, 영속성을 위한 변경 사항을 추적할 수 있습니다.

  4. 유형 검증: 사용자 정의 디스크립터는 유형 검사 또는 값 제약 조건을 강제하여 객체 내의 데이터 무결성을 보장할 수 있습니다.

    class Typed:
    def __init__(self, type_name, default=None):
        self.type_name = type_name
        self.default = default
        self.data = {} # 인스턴스별 값 저장

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return self.data.get(instance, self.default)

    def __set__(self, instance, value):
        if not isinstance(value, self.type_name):
            raise TypeError(f"{self.type_name.__name__} 예상, {type(value).__name__} 얻음")
        self.data[instance] = value

class Person:
    name = Typed(str, "Anonymous")
    age = Typed(int, 0)

p = Person()
print(p.name)
p.name = "Alice"
p.age = 30
# p.age = "thirty" # TypeError 발생
print(f"{p.name}는 {p.age}살입니다.")

결론

__get__, __set__, __delete__ 메서드로 구체화된 Python 디스크립터 프로토콜은 속성 접근을 사용자 정의하는 강력하고 우아한 방법을 제공합니다. 이러한 메서드가 클래스 및 인스턴스 속성 조회와 어떻게 상호 작용하는지 이해함으로써 개발자는 객체 동작에 대한 더 깊은 제어를 잠금 해제하여 강력하고 고도로 유연한 시스템을 구축할 수 있습니다. 디스크립터는 Python의 정교한 속성 관리를 지원하는 숨겨진 영웅이며, 많은 사랑받는 기능을 가능하게 합니다. 그것들은 Python의 확장 가능한 디자인에 대한 진정한 증거입니다.

Share this article

HackerNews

More Posts from Leapcell

Popular Posts