Heim > Artikel > Backend-Entwicklung > Magische Deskriptoren in Python
Deskriptoren (Deskriptoren) sind eine tiefgreifende, aber wichtige schwarze Magie in der Python-Sprache. Sie werden häufig im Kern der Python-Sprache verwendet. Die Beherrschung von Deskriptoren hilft Python. Fügt ein Extra hinzu Trick für den Werkzeugkasten des Programmierers. In diesem Artikel werde ich über die Definition von Deskriptoren und einige gängige Szenarien sprechen und am Ende des Artikels werde ich , __getattr
, __getattribute__
diese drei __getitem__
magischen Methoden hinzufügen beinhalten den Attributzugriff.
descr__get__(self, obj, objtype=None) --> value descr.__set__(self, obj, value) --> None descr.__delete__(self, obj) --> NoneSolange ein
(Objektattribut) eine der oben genannten drei Methoden definiert, kann diese Klasse als Deskriptorklasse bezeichnet werden. object attribute
-Klasse und implementieren die RevealAcess
-Methode. Jetzt kann diese Klasse als Deskriptorklasse bezeichnet werden. __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-Instanzattribute
Als nächstes werfen wir einen Blick auf die Bedeutung der einzelnen Parameter der-Methode, __get__
ist die Instanz x der RevealAccess-Klasse, self
ist die Instanz m der MyClass-Klasse und obj
ist, wie der Name schon sagt, die MyClass-Klasse selbst. Wie aus der Ausgabeanweisung ersichtlich ist, ruft der objtype
-Zugriffsdeskriptor m.x
die x
-Methode auf. __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-Klassenattribut
Wenn auf das Attribut direkt über die Klasse zugegriffen wird, ist die x
-Verbindung direkt None, was einfacher ist zu verstehen, weil Es gibt keine Instanz von MyClass. obj
>>> MyClass.x self in RevealAccess: <__main__.RevealAccess object at 0x7f53651070f0> self: <__main__.RevealAccess object at 0x7f53651070f0> obj: None objtype: <class '__main__.MyClass'>Prinzip des DeskriptorsDeskriptor-TriggerIm obigen Beispiel haben wir die Verwendung von Deskriptoren aus der Perspektive von Instanzattributen bzw. Klassenattributen aufgezählt Schauen Sie sich die internen Prinzipien genauer an:
zugreifen, wird tatsächlich die Methode __getattribute__ des Basisklassenobjekts aufgerufen. In dieser Methode wird obj .d in . 实例属性
type(obj).__dict__['d'].__get__(obj, type(obj))
übersetzt, hier ist das Objekt von __get__( ). Keine, weil es keine Instanz gibt. 类属性
cls.__dict__['d'].__get__(None, cls)
, __getattribute__
Ich werde am Ende des Artikels eine zusätzliche Ergänzung machen, aber wir werden uns vorerst nicht näher damit befassen. __getattr
__getitem__
Deskriptorpriorität
data descriptor
non-data descriptor
data descriptor > instance dict > non-data descriptor > __getattr__()und
mit demselben Namen im Instanzobjekt obj erscheinen und data descriptor->d
auf das Attribut instance attribute->d
zugreift, ruft Python obj.d
auf, da der Datendeskriptor eine höhere Priorität hat Stattdessen wird obj.__dict__['d'] aufgerufen. Wenn der Deskriptor jedoch kein Datendeskriptor ist, ruft Python d
auf. type(obj).__dict__['d'].__get__(obj, type(obj))
obj.__dict__['d']
Eigenschaft
property(fget=None, fset=None, fdel=None, doc=None) -> property attributeWenn acct eine Instanz von Account ist, ruft acct.acct_num den Getter auf, acct.acct_num = value ruft den Setter auf, del acct_num. acct_num delete wird aufgerufen.
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.')Python stellt außerdem den
>>> acct = Account() >>> acct.acct_num = 1000 >>> acct.acct_num 1000Decorator zur Verfügung, mit dem Attribute für einfache Anwendungsszenarien erstellt werden können. Ein Eigenschaftsobjekt verfügt über Getter-, Setter- und Lösch-Dekoratormethoden, mit denen über die Zugriffsfunktionen der entsprechenden dekorierten Funktionen Kopien der Eigenschaft erstellt werden können.
@property
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
Deskriptoren zur Laufzeit erstellen
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)Statische Methoden und Klassenmethoden
>>> 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'}
in Python zu simulieren. Schauen wir uns zunächst die folgende Tabelle an: @staticmethod
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
Das obige ist der detaillierte Inhalt vonMagische Deskriptoren in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!