Python Language
속성 개체

비고

@property 데코레이터 사용하기

@property 데코레이터는 속성처럼 작동하는 클래스의 메소드를 정의하는 데 사용할 수 있습니다. 이것이 유용 할 수있는 한 가지 예는 초기 (값 비싼) 검색과 간단한 검색이 필요할 수있는 정보를 노출 할 때입니다.

주어진 몇몇 모듈 foobar.py :

class Foo(object):
    def __init__(self):
        self.__bar = None

    @property
    def bar(self):
        if self.__bar is None:
            self.__bar = some_expensive_lookup_operation()
        return self.__bar

그때

>>> from foobar import Foo
>>> foo = Foo()
>>> print(foo.bar)  # This will take some time since bar is None after initialization
42
>>> print(foo.bar)  # This is much faster since bar has a value now
42

읽기 / 쓰기 속성에 @property 데코레이터 사용

@property 를 사용하여 설정 및 가져 오기에 대한 사용자 정의 동작을 구현하려면이 패턴을 사용하십시오.

class Cash(object):
    def __init__(self, value):
        self.value = value
    @property
    def formatted(self):
        return '${:.2f}'.format(self.value)
    @formatted.setter
    def formatted(self, new):
        self.value = float(new[1:])

이것을 사용하려면 :

>>> wallet = Cash(2.50)
>>> print(wallet.formatted)
$2.50
>>> print(wallet.value)
2.5
>>> wallet.formatted = '$123.45'
>>> print(wallet.formatted)
$123.45
>>> print(wallet.value)
123.45

속성 객체의 getter, setter 또는 deleter를 재정의합니다.

속성이있는 클래스를 상속 하는 경우 상위 클래스 의 속성 객체 를 참조하여 하나 이상의 속성 getter , setter 또는 deleter 함수에 대한 새 구현을 제공 할 수 있습니다.

class BaseClass(object):
    @property
    def foo(self):
        return some_calculated_value()

    @foo.setter
    def foo(self, value):
        do_something_with_value(value)


class DerivedClass(BaseClass):
    @BaseClass.foo.setter
    def foo(self, value):
        do_something_different_with_value(value)

이전에 기본 클래스에없는 setter 또는 deleter를 추가 할 수도 있습니다.

데코레이터없이 속성 사용하기

데코레이터 구문 (@ 포함)을 사용하는 것이 편리하지만 조금은 숨겨 둡니다. 데코레이터없이 속성을 직접 사용할 수 있습니다. 다음 파이썬 3.x 예제는 이것을 보여준다 :

class A:
    p = 1234
    def getX (self):
        return self._x

    def setX (self, value):
        self._x = value
            
    def getY (self):
        return self._y

    def setY (self, value):
        self._y = 1000 + value    # Weird but possible
        
    def getY2 (self):
        return self._y

    def setY2 (self, value):
        self._y = value
        
    def getT    (self):
        return self._t

    def setT (self, value):
        self._t = value
        
    def getU (self):
        return self._u + 10000

    def setU (self, value):
        self._u = value - 5000
            
    x, y, y2 = property (getX, setX), property (getY, setY), property (getY2, setY2)
    t = property (getT, setT)
    u = property (getU, setU)
    
A.q = 5678

class B:
    def getZ (self):
        return self.z_
    
    def setZ (self, value):
        self.z_ = value
        
    z = property (getZ, setZ)
    
class C:
    def __init__ (self):
        self.offset = 1234

    def getW (self):
        return self.w_ + self.offset
        
    def setW (self, value):
        self.w_ = value - self.offset
        
    w = property (getW, setW)
    
a1 = A ()
a2 = A ()

a1.y2 = 1000
a2.y2 = 2000

a1.x = 5
a1.y = 6

a2.x = 7
a2.y = 8

a1.t = 77
a1.u = 88
    
print (a1.x, a1.y, a1.y2)
print (a2.x, a2.y, a2.y2)
print (a1.p, a2.p, a1.q, a2.q)

print (a1.t, a1.u)

b = B ()
c = C ()

b.z = 100100
c.z = 200200
c.w = 300300

print (a1.x, b.z, c.z, c.w)

c.w = 400400
c.z = 500500
b.z = 600600

print (a1.x, b.z, c.z, c.w)