[Python Cheatsheet] 26. Descriptor - 속성 접근 제어 프로토콜

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

class Descriptor:
    def __get__(self, obj, objtype=None):
        """obj.attr 접근 시 호출"""
        pass
    
    def __set__(self, obj, value):
        """obj.attr = value 할당 시 호출"""
        pass
    
    def __delete__(self, obj):
        """del obj.attr 삭제 시 호출"""
        pass

 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

class TypedAttribute:
    def __init__(self, name, expected_type):
        self.name = name
        self.expected_type = expected_type
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)
    
    def __set__(self, obj, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"{self.name} must be {self.expected_type.__name__}")
        obj.__dict__[self.name] = value

class Person:
    name = TypedAttribute('name', str)
    age = TypedAttribute('age', int)
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 30)
# p.age = "thirty"  # TypeError: age must be int

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

class TypedAttribute:
    def __init__(self, expected_type):
        self.expected_type = expected_type
    
    def __set_name__(self, owner, name):
        """클래스 정의 시 자동 호출 - 속성 이름 자동 설정"""
        self.name = name
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)
    
    def __set__(self, obj, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"{self.name} must be {self.expected_type.__name__}")
        obj.__dict__[self.name] = value

class Person:
    name = TypedAttribute(str)  # 이름 자동 설정
    age = TypedAttribute(int)

 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 LazyProperty:
    def __init__(self, func):
        self.func = func
    
    def __set_name__(self, owner, name):
        self.name = name
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        # 첫 접근 시 계산 후 인스턴스에 캐시
        value = self.func(obj)
        obj.__dict__[self.name] = value  # 비데이터라 이후 직접 반환
        return value

class DataAnalyzer:
    def __init__(self, data):
        self.data = data
    
    @LazyProperty
    def summary(self):
        print("Computing summary...")
        return {'mean': sum(self.data) / len(self.data)}

analyzer = DataAnalyzer([1, 2, 3, 4, 5])
print(analyzer.summary)  # Computing summary... {'mean': 3.0}
print(analyzer.summary)  # {'mean': 3.0} (캐시됨)

 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
28
29
30
31
32
33
34
35
36
37
38
39

class MyProperty:
    def __init__(self, fget=None, fset=None, fdel=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.fget is None:
            raise AttributeError("unreadable attribute")
        return self.fget(obj)
    
    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError("can't set attribute")
        self.fset(obj, value)
    
    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError("can't delete attribute")
        self.fdel(obj)
    
    def setter(self, fset):
        return type(self)(self.fget, fset, self.fdel)

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @MyProperty
    def radius(self):
        return self._radius
    
    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius must be positive")
        self._radius = value

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

class Range:
    def __init__(self, min_val=None, max_val=None):
        self.min_val = min_val
        self.max_val = max_val
    
    def __set_name__(self, owner, name):
        self.name = name
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)
    
    def __set__(self, obj, value):
        if self.min_val is not None and value < self.min_val:
            raise ValueError(f"{self.name} must be >= {self.min_val}")
        if self.max_val is not None and value > self.max_val:
            raise ValueError(f"{self.name} must be <= {self.max_val}")
        obj.__dict__[self.name] = value

class Product:
    price = Range(min_val=0)
    quantity = Range(min_val=0, max_val=1000)

1
2
3
4
5

obj.attr 접근 시:
1. 데이터 디스크립터 (type(obj).__dict__에서)
2. 인스턴스 __dict__
3. 비데이터 디스크립터 (type(obj).__dict__에서)
4. __getattr__ (정의된 경우)

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

# 잘못된 예 - 모든 인스턴스가 값 공유
class BadDescriptor:
    def __init__(self):
        self.value = None  # 클래스 레벨!
    
    def __get__(self, obj, objtype=None):
        return self.value
    
    def __set__(self, obj, value):
        self.value = value  # 모든 인스턴스에 영향

# 올바른 예 - 인스턴스 __dict__ 사용
class GoodDescriptor:
    def __set_name__(self, owner, name):
        self.name = name
    
    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)
    
    def __set__(self, obj, value):
        obj.__dict__[self.name] = value

1
2
3
4
5
6

class Descriptor:
    def __get__(self, obj, objtype=None):
        # 클래스에서 직접 접근 시 obj는 None
        if obj is None:
            return self  # 디스크립터 자체 반환
        return obj.__dict__.get(self.name)