소개
설명자(설명자)는 Python 언어의 심오하지만 중요한 마법입니다. 설명자는 Python 언어의 커널에서 널리 사용됩니다. 장난. 이 기사에서는 설명자의 정의와 몇 가지 일반적인 시나리오를 설명하고 기사 마지막 부분에 속성 액세스와 관련된 세 가지 매직 메서드인 __getattr__, __getattribute__ 및 __getitem__을 추가할 것입니다.
descr__get__(self, obj, objtype=None) --> value descr.__set__(self, obj, value) --> None descr.__delete__(self, obj) --> None
객체 속성이 위의 세 가지 메서드 중 하나를 정의하는 한 이 클래스는 설명자 클래스라고 부를 수 있습니다.
다음 예에서는 RevealAcess 클래스를 만들고 __get__ 메서드를 구현합니다. 이제 이 클래스를 설명자 클래스라고 부를 수 있습니다.
class RevealAccess(object): def __get__(self, obj, objtype): print('self in RevealAccess: {}'.format(self)) print('self: {}\nobj: {}\nobjtype: {}'.format(self, obj, objtype)) class MyClass(object): x = RevealAccess() def test(self): print('self in MyClass: {}'.format(self))
EX1 인스턴스 속성
다음으로 __get__ 메서드의 각 매개 변수의 의미를 살펴보겠습니다. 다음 예에서 self는 RevealAccess 클래스의 인스턴스 x이고 obj는 MyClass 클래스 인스턴스 m, objtype은 이름에서 알 수 있듯이 MyClass 클래스 자체입니다. 출력 문에서 볼 수 있듯이 m.x 액세스 설명자 x는 __get__ 메서드를 호출합니다.
>>> m = MyClass() >>> m.test() self in MyClass: <__main__.MyClass object at 0x7f19d4e42160> >>> m.x self in RevealAccess: <__main__.RevealAccess object at 0x7f19d4e420f0> self: <__main__.RevealAccess object at 0x7f19d4e420f0> obj: <__main__.MyClass object at 0x7f19d4e42160> objtype: <class '__main__.MyClass'>
EX2 클래스 속성
클래스를 통해 x 속성에 직접 액세스하는 경우 obj 연결은 직접 None이며 이는 MyClass의 인스턴스가 없기 때문에 이해하기 쉽습니다.
>>> MyClass.x self in RevealAccess: <__main__.RevealAccess object at 0x7f53651070f0> self: <__main__.RevealAccess object at 0x7f53651070f0> obj: None objtype: <class '__main__.MyClass'>
위의 예에서는 각각 인스턴스 속성과 클래스 속성의 관점에서 설명자의 사용법을 나열했습니다. 내부 원칙 분석:
인스턴스 속성에 액세스하는 경우 obj.d를 type(obj ).__dict__['d'로 변환하는 object.__getattribute__()를 호출하는 것과 같습니다. ].__get__(obj, 유형(obj)).
클래스 속성에 액세스하는 경우 cls.d를 cls.__dict__['d'].__get__( 없음, cls)를 Python 코드로 변환하면 다음과 같습니다.
def __getattribute__(self, key): "Emulate type_getattro() in Objects/typeobject.c" v = object.__getattribute__(self, key) if hasattr(v, '__get__'): return v.__get__(None, self) return v
__getattribute__ 매직 메서드에 대해 간략하게 설명하겠습니다. 이 메서드는 객체의 속성에 액세스할 때 무조건 호출됩니다. __getattr과 __getitem__의 차이점과 같은 세부 사항에 대한 추가 보충 자료는 기사 끝에 있지만 지금은 자세히 다루지 않겠습니다.
먼저 설명자는 두 가지 유형으로 구분됩니다.
객체가 __get__() 및 __set__() 메서드를 모두 정의하는 경우 , 이 설명자를 데이터 설명자라고 합니다.
객체가 __get__() 메서드만 정의하는 경우 이 설명자를 비데이터 설명자라고 합니다.
속성에 액세스할 때 네 가지 상황이 있습니다.
데이터 설명자
인스턴스 사전
비데이터 설명자
__getattr__()
우선순위 크기는
data descriptor > instance dict > non-data descriptor > __getattr__()
이게 무슨 뜻인가요? 즉, 동일한 이름을 가진 데이터 디스크립터->d와 인스턴스 속성->d가 인스턴스 객체 obj에 나타나면 obj.d가 속성 d에 액세스할 때 데이터 디스크립터의 우선순위가 더 높기 때문에 Python은 이를 호출합니다. obj.__dict__['d']를 호출하는 대신 type(obj).__dict__['d'].__get__(obj, type(obj)). 그러나 설명자가 데이터가 아닌 설명자인 경우 Python은 obj.__dict__['d']를 호출합니다.
설명자를 사용할 때마다 설명자 클래스를 정의하는 것은 매우 번거로운 작업 같습니다. Python은 속성에 데이터 설명자를 추가하는 간결한 방법을 제공합니다.
property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget, fset 및 fdel은 각각 클래스의 getter, setter 및 deleter 메서드입니다. 다음 예를 사용하여 속성 사용 방법을 설명합니다.
class Account(object): def __init__(self): self._acct_num = None def get_acct_num(self): return self._acct_num def set_acct_num(self, value): self._acct_num = value def del_acct_num(self): del self._acct_num acct_num = property(get_acct_num, set_acct_num, del_acct_num, '_acct_num property.')
acct가 Account의 인스턴스인 경우 acct.acct_num은 getter를 호출하고 acct.acct_num = value는 setter를 호출하며 del acct_num.acct_num 삭제자를 호출합니다.
>>> acct = Account() >>> acct.acct_num = 1000 >>> acct.acct_num 1000
Python은 간단한 애플리케이션 시나리오를 위한 속성을 생성하는 데 사용할 수 있는 @property 데코레이터도 제공합니다. 속성 개체에는 해당 데코레이팅된 함수의 접근자 함수를 통해 속성의 복사본을 만드는 데 사용할 수 있는 getter, setter 및 delete 데코레이터 메서드가 있습니다.
class Account(object): def __init__(self): self._acct_num = None @property # the _acct_num property. the decorator creates a read-only property def acct_num(self): return self._acct_num @acct_num.setter # the _acct_num property setter makes the property writeable def set_acct_num(self, value): self._acct_num = value @acct_num.deleter def del_acct_num(self): del self._acct_num
속성을 읽기 전용으로 설정하려면 setter 메소드를 제거하면 됩니다.
런타임에 속성을 추가할 수 있습니다:
class Person(object): def addProperty(self, attribute): # create local setter and getter with a particular attribute name getter = lambda self: self._getProperty(attribute) setter = lambda self, value: self._setProperty(attribute, value) # construct property attribute and add it to the class setattr(self.__class__, attribute, property(fget=getter, \ fset=setter, \ doc="Auto-generated method")) def _setProperty(self, attribute, value): print("Setting: {} = {}".format(attribute, value)) setattr(self, '_' + attribute, value.title()) def _getProperty(self, attribute): print("Getting: {}".format(attribute)) return getattr(self, '_' + attribute)
설명자를 사용하여 구현을 시뮬레이션할 수 있습니다. Python의 @staticmethod 및 @classmethod. 먼저 아래 표를 살펴보겠습니다.
Transformation | Called from an Object | Called from a Class |
---|---|---|
function | f(obj, *args) | f(*args) |
staticmethod | f(*args) | f(*args) |
classmethod | f(type(obj), *args) | f(klass, *args) |
对于静态方法f。c.f和C.f是等价的,都是直接查询object.__getattribute__(c, ‘f’)或者object.__getattribute__(C, ’f‘)。静态方法一个明显的特征就是没有self变量。
静态方法有什么用呢?假设有一个处理专门数据的容器类,它提供了一些方法来求平均数,中位数等统计数据方式,这些方法都是要依赖于相应的数据的。但是类中可能还有一些方法,并不依赖这些数据,这个时候我们可以将这些方法声明为静态方法,同时这也可以提高代码的可读性。
使用非数据描述符来模拟一下静态方法的实现:
class StaticMethod(object): def __init__(self, f): self.f = f def __get__(self, obj, objtype=None): return self.f
我们来应用一下:
class MyClass(object): @StaticMethod def get_x(x): return x print(MyClass.get_x(100)) # output: 100
Python的@classmethod和@staticmethod的用法有些类似,但是还是有些不同,当某些方法只需要得到类的引用而不关心类中的相应的数据的时候就需要使用classmethod了。
使用非数据描述符来模拟一下类方法的实现:
class ClassMethod(object): def __init__(self, f): self.f = f def __get__(self, obj, klass=None): if klass is None: klass = type(obj) def newfunc(*args): return self.f(klass, *args) return newfunc
首次接触Python魔术方法的时候,我也被__get__, __getattribute__, __getattr__, __getitem__之间的区别困扰到了,它们都是和属性访问相关的魔术方法,其中重写__getattr__,__getitem__来构造一个自己的集合类非常的常用,下面我们就通过一些例子来看一下它们的应用。
Python默认访问类/实例的某个属性都是通过__getattribute__来调用的,__getattribute__会被无条件调用,没有找到的话就会调用__getattr__。如果我们要定制某个类,通常情况下我们不应该重写__getattribute__,而是应该重写__getattr__,很少看见重写__getattribute__的情况。
从下面的输出可以看出,当一个属性通过__getattribute__无法找到的时候会调用__getattr__。
In [1]: class Test(object): ...: def __getattribute__(self, item): ...: print('call __getattribute__') ...: return super(Test, self).__getattribute__(item) ...: def __getattr__(self, item): ...: return 'call __getattr__' ...: In [2]: Test().a call __getattribute__ Out[2]: 'call __getattr__'
对于默认的字典,Python只支持以obj['foo']形式来访问,不支持obj.foo的形式,我们可以通过重写__getattr__让字典也支持obj['foo']的访问形式,这是一个非常经典常用的用法:
class Storage(dict): """ A Storage object is like a dictionary except `obj.foo` can be used in addition to `obj['foo']`. """ def __getattr__(self, key): try: return self[key] except KeyError as k: raise AttributeError(k) def __setattr__(self, key, value): self[key] = value def __delattr__(self, key): try: del self[key] except KeyError as k: raise AttributeError(k) def __repr__(self): return '<Storage ' + dict.__repr__(self) + '>'
我们来使用一下我们自定义的加强版字典:
>>> s = Storage(a=1) >>> s['a'] 1 >>> s.a 1 >>> s.a = 2 >>> s['a'] 2 >>> del s.a >>> s.a ... AttributeError: 'a'
getitem用于通过下标[]的形式来获取对象中的元素,下面我们通过重写__getitem__来实现一个自己的list。
class MyList(object): def __init__(self, *args): self.numbers = args def __getitem__(self, item): return self.numbers[item] my_list = MyList(1, 2, 3, 4, 6, 5, 3) print my_list[2]
这个实现非常的简陋,不支持slice和step等功能,请读者自行改进,这里我就不重复了。
下面是参考requests库中对于__getitem__的一个使用,我们定制了一个忽略属性大小写的字典类。
程序有些复杂,我稍微解释一下:由于这里比较简单,没有使用描述符的需求,所以使用了@property装饰器来代替,lower_keys的功能是将实例字典中的键全部转换成小写并且存储在字典self._lower_keys中。重写了__getitem__方法,以后我们访问某个属性首先会将键转换为小写的方式,然后并不会直接访问实例字典,而是会访问字典self._lower_keys去查找。赋值/删除操作的时候由于实例字典会进行变更,为了保持self._lower_keys和实例字典同步,首先清除self._lower_keys的内容,以后我们重新查找键的时候再调用__getitem__的时候会重新新建一个self._lower_keys。
class CaseInsensitiveDict(dict): @property def lower_keys(self): if not hasattr(self, '_lower_keys') or not self._lower_keys: self._lower_keys = dict((k.lower(), k) for k in self.keys()) return self._lower_keys def _clear_lower_keys(self): if hasattr(self, '_lower_keys'): self._lower_keys.clear() def __contains__(self, key): return key.lower() in self.lower_keys def __getitem__(self, key): if key in self: return dict.__getitem__(self, self.lower_keys[key.lower()]) def __setitem__(self, key, value): dict.__setitem__(self, key, value) self._clear_lower_keys() def __delitem__(self, key): dict.__delitem__(self, key) self._lower_keys.clear() def get(self, key, default=None): if key in self: return self[key] else: return default
我们来调用一下这个类:
>>> d = CaseInsensitiveDict() >>> d['ziwenxie'] = 'ziwenxie' >>> d['ZiWenXie'] = 'ZiWenXie' >>> print(d) {'ZiWenXie': 'ziwenxie', 'ziwenxie': 'ziwenxie'} >>> print(d['ziwenxie']) ziwenxie # d['ZiWenXie'] => d['ziwenxie'] >>> print(d['ZiWenXie']) ziwenxie
HOWTO-GUIDE
DOCUMENTATION
IBM-DEVELOPWORKS
ZHIHU
REQUESTS
WEBPY
本文为作者原创,转载请先与作者联系。 首发于我的博客
Descriptors(描述符)是Python语言中一个深奥但很重要的一个黑魔法,它被广泛应用于Python语言的内核,熟练掌握描述符将会为Python程序员的工具箱添加一个额外的技巧。本文我将讲述描述符的定义以及一些常见的场景,并且在文末会补充一下__getattr__,__getattribute__, __getitem__这三个同样涉及到属性访问的魔术方法。
descr__get__(self, obj, objtype=None) --> value descr.__set__(self, obj, value) --> None descr.__delete__(self, obj) --> None
只要一个object attribute(对象属性)定义了上面三个方法中的任意一个,那么这个类就可以被称为描述符类。
下面这个例子中我们创建了一个RevealAcess类,并且实现了__get__方法,现在这个类可以被称为一个描述符类。
class RevealAccess(object): def __get__(self, obj, objtype): print('self in RevealAccess: {}'.format(self)) print('self: {}\nobj: {}\nobjtype: {}'.format(self, obj, objtype)) class MyClass(object): x = RevealAccess() def test(self): print('self in MyClass: {}'.format(self))
EX1实例属性
接下来我们来看一下__get__方法的各个参数的含义,在下面这个例子中,self即RevealAccess类的实例x,obj即MyClass类的实例m,objtype顾名思义就是MyClass类自身。从输出语句可以看出,m.x访问描述符x会调用__get__方法。
>>> m = MyClass() >>> m.test() self in MyClass: <__main__.MyClass object at 0x7f19d4e42160> >>> m.x self in RevealAccess: <__main__.RevealAccess object at 0x7f19d4e420f0> self: <__main__.RevealAccess object at 0x7f19d4e420f0> obj: <__main__.MyClass object at 0x7f19d4e42160> objtype: <class '__main__.MyClass'>
EX2类属性
如果通过类直接访问属性x,那么obj接直接为None,这还是比较好理解,因为不存在MyClass的实例。
>>> MyClass.x self in RevealAccess: <__main__.RevealAccess object at 0x7f53651070f0> self: <__main__.RevealAccess object at 0x7f53651070f0> obj: None objtype: <class '__main__.MyClass'>
上面这个例子中,我们分别从实例属性和类属性的角度列举了描述符的用法,下面我们来仔细分析一下内部的原理:
如果是对实例属性进行访问,相当于调用了object.__getattribute__(),它将obj.d转译成了type(obj).__dict__['d'].__get__(obj, type(obj))。
如果是对类属性进行访问,相当于调用了type.__getattribute__(),它将cls.d转译成了cls.__dict__['d'].__get__(None, cls),转换成Python代码就是:
def __getattribute__(self, key): "Emulate type_getattro() in Objects/typeobject.c" v = object.__getattribute__(self, key) if hasattr(v, '__get__'): return v.__get__(None, self) return v
简单讲一下__getattribute__魔术方法,这个方法在我们访问一个对象的属性的时候会被无条件调用,详细的细节比如和__getattr, __getitem__的区别我会在文章的末尾做一个额外的补充,我们暂时并不深究。
首先,描述符分为两种:
如果一个对象同时定义了__get__()和__set__()方法,则这个描述符被称为data descriptor。
如果一个对象只定义了__get__()方法,则这个描述符被称为non-data descriptor。
我们对属性进行访问的时候存在下面四种情况:
data descriptor
instance dict
non-data descriptor
__getattr__()
它们的优先级大小是:
data descriptor > instance dict > non-data descriptor > __getattr__()
这是什么意思呢?就是说如果实例对象obj中出现了同名的data descriptor->d 和 instance attribute->d,obj.d对属性d进行访问的时候,由于data descriptor具有更高的优先级,Python便会调用type(obj).__dict__['d'].__get__(obj, type(obj))而不是调用obj.__dict__['d']。但是如果描述符是个non-data descriptor,Python则会调用obj.__dict__['d']。
每次使用描述符的时候都定义一个描述符类,这样看起来非常繁琐。Python提供了一种简洁的方式用来向属性添加数据描述符。
property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget、fset和fdel分别是类的getter、setter和deleter方法。我们通过下面的一个示例来说明如何使用Property:
class Account(object): def __init__(self): self._acct_num = None def get_acct_num(self): return self._acct_num def set_acct_num(self, value): self._acct_num = value def del_acct_num(self): del self._acct_num acct_num = property(get_acct_num, set_acct_num, del_acct_num, '_acct_num property.')
如果acct是Account的一个实例,acct.acct_num将会调用getter,acct.acct_num = value将调用setter,del acct_num.acct_num将调用deleter。
>>> acct = Account() >>> acct.acct_num = 1000 >>> acct.acct_num 1000
Python也提供了@property装饰器,对于简单的应用场景可以使用它来创建属性。一个属性对象拥有getter,setter和deleter装饰器方法,可以使用它们通过对应的被装饰函数的accessor函数创建属性的拷贝。
class Account(object): def __init__(self): self._acct_num = None @property # the _acct_num property. the decorator creates a read-only property def acct_num(self): return self._acct_num @acct_num.setter # the _acct_num property setter makes the property writeable def set_acct_num(self, value): self._acct_num = value @acct_num.deleter def del_acct_num(self): del self._acct_num
如果想让属性只读,只需要去掉setter方法。
我们可以在运行时添加property属性:
class Person(object): def addProperty(self, attribute): # create local setter and getter with a particular attribute name getter = lambda self: self._getProperty(attribute) setter = lambda self, value: self._setProperty(attribute, value) # construct property attribute and add it to the class setattr(self.__class__, attribute, property(fget=getter, \ fset=setter, \ doc="Auto-generated method")) def _setProperty(self, attribute, value): print("Setting: {} = {}".format(attribute, value)) setattr(self, '_' + attribute, value.title()) def _getProperty(self, attribute): print("Getting: {}".format(attribute)) return getattr(self, '_' + attribute)
>>> user = Person() >>> user.addProperty('name') >>> user.addProperty('phone') >>> user.name = 'john smith' Setting: name = john smith >>> user.phone = '12345' Setting: phone = 12345 >>> user.name Getting: name 'John Smith' >>> user.__dict__ {'_phone': '12345', '_name': 'John Smith'}
我们可以使用描述符来模拟Python中的@staticmethod和@classmethod的实现。我们首先来浏览一下下面这张表:
Transformation | Called from an Object | Called from a Class |
---|---|---|
function | f(obj, *args) | f(*args) |
staticmethod | f(*args) | f(*args) |
classmethod | f(type(obj), *args) | f(klass, *args) |
对于静态方法f。c.f和C.f是等价的,都是直接查询object.__getattribute__(c, ‘f’)或者object.__getattribute__(C, ’f‘)。静态方法一个明显的特征就是没有self变量。
静态方法有什么用呢?假设有一个处理专门数据的容器类,它提供了一些方法来求平均数,中位数等统计数据方式,这些方法都是要依赖于相应的数据的。但是类中可能还有一些方法,并不依赖这些数据,这个时候我们可以将这些方法声明为静态方法,同时这也可以提高代码的可读性。
使用非数据描述符来模拟一下静态方法的实现:
class StaticMethod(object): def __init__(self, f): self.f = f def __get__(self, obj, objtype=None): return self.f
我们来应用一下:
class MyClass(object): @StaticMethod def get_x(x): return x print(MyClass.get_x(100)) # output: 100
Python的@classmethod和@staticmethod的用法有些类似,但是还是有些不同,当某些方法只需要得到类的引用而不关心类中的相应的数据的时候就需要使用classmethod了。
使用非数据描述符来模拟一下类方法的实现:
class ClassMethod(object): def __init__(self, f): self.f = f def __get__(self, obj, klass=None): if klass is None: klass = type(obj) def newfunc(*args): return self.f(klass, *args) return newfunc
首次接触Python魔术方法的时候,我也被__get__, __getattribute__, __getattr__, __getitem__之间的区别困扰到了,它们都是和属性访问相关的魔术方法,其中重写__getattr__,__getitem__来构造一个自己的集合类非常的常用,下面我们就通过一些例子来看一下它们的应用。
Python默认访问类/实例的某个属性都是通过__getattribute__来调用的,__getattribute__会被无条件调用,没有找到的话就会调用__getattr__。如果我们要定制某个类,通常情况下我们不应该重写__getattribute__,而是应该重写__getattr__,很少看见重写__getattribute__的情况。
从下面的输出可以看出,当一个属性通过__getattribute__无法找到的时候会调用__getattr__。
In [1]: class Test(object): ...: def __getattribute__(self, item): ...: print('call __getattribute__') ...: return super(Test, self).__getattribute__(item) ...: def __getattr__(self, item): ...: return 'call __getattr__' ...: In [2]: Test().a call __getattribute__ Out[2]: 'call __getattr__'
对于默认的字典,Python只支持以obj['foo']形式来访问,不支持obj.foo的形式,我们可以通过重写__getattr__让字典也支持obj['foo']的访问形式,这是一个非常经典常用的用法:
class Storage(dict): """ A Storage object is like a dictionary except `obj.foo` can be used in addition to `obj['foo']`. """ def __getattr__(self, key): try: return self[key] except KeyError as k: raise AttributeError(k) def __setattr__(self, key, value): self[key] = value def __delattr__(self, key): try: del self[key] except KeyError as k: raise AttributeError(k) def __repr__(self): return '<Storage ' + dict.__repr__(self) + '>'
我们来使用一下我们自定义的加强版字典:
>>> s = Storage(a=1) >>> s['a'] 1 >>> s.a 1 >>> s.a = 2 >>> s['a'] 2 >>> del s.a >>> s.a ... AttributeError: 'a'
getitem用于通过下标[]的形式来获取对象中的元素,下面我们通过重写__getitem__来实现一个自己的list。
class MyList(object): def __init__(self, *args): self.numbers = args def __getitem__(self, item): return self.numbers[item] my_list = MyList(1, 2, 3, 4, 6, 5, 3) print my_list[2]
这个实现非常的简陋,不支持slice和step等功能,请读者自行改进,这里我就不重复了。
下面是参考requests库中对于__getitem__的一个使用,我们定制了一个忽略属性大小写的字典类。
程序有些复杂,我稍微解释一下:由于这里比较简单,没有使用描述符的需求,所以使用了@property装饰器来代替,lower_keys的功能是将实例字典中的键全部转换成小写并且存储在字典self._lower_keys中。重写了__getitem__方法,以后我们访问某个属性首先会将键转换为小写的方式,然后并不会直接访问实例字典,而是会访问字典self._lower_keys去查找。赋值/删除操作的时候由于实例字典会进行变更,为了保持self._lower_keys和实例字典同步,首先清除self._lower_keys的内容,以后我们重新查找键的时候再调用__getitem__的时候会重新新建一个self._lower_keys。
class CaseInsensitiveDict(dict): @property def lower_keys(self): if not hasattr(self, '_lower_keys') or not self._lower_keys: self._lower_keys = dict((k.lower(), k) for k in self.keys()) return self._lower_keys def _clear_lower_keys(self): if hasattr(self, '_lower_keys'): self._lower_keys.clear() def __contains__(self, key): return key.lower() in self.lower_keys def __getitem__(self, key): if key in self: return dict.__getitem__(self, self.lower_keys[key.lower()]) def __setitem__(self, key, value): dict.__setitem__(self, key, value) self._clear_lower_keys() def __delitem__(self, key): dict.__delitem__(self, key) self._lower_keys.clear() def get(self, key, default=None): if key in self: return self[key] else: return default
我们来调用一下这个类:
>>> d = CaseInsensitiveDict() >>> d['ziwenxie'] = 'ziwenxie' >>> d['ZiWenXie'] = 'ZiWenXie' >>> print(d) {'ZiWenXie': 'ziwenxie', 'ziwenxie': 'ziwenxie'} >>> print(d['ziwenxie']) ziwenxie # d['ZiWenXie'] => d['ziwenxie'] >>> print(d['ZiWenXie']) ziwenxie
更多Python黑魔法之描述符相关文章请关注PHP中文网!