搜尋

首頁 >後端開發 >Python教學 >Python黑魔法之描述符

Python黑魔法之描述符

高洛峰
高洛峰原創
2017-02-09 10:52:051328瀏覽

引言

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 &#39;__main__.MyClass&#39;>

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 &#39;__main__.MyClass&#39;>

描述符的原理

描述符觸發

上面這個例子中，我們分別從實例屬性和類別屬性的角度列舉了描述符的用法，下面我們來仔細分析一下內部的原理：

  • 如果是對實例屬性進行訪問，相當於調用了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

    • .

  • 它們的優先大小是：

    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']。

  • Property

    • 每次使用描述符的時候都會定義一個描述符類，看起來非常繁瑣。 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 Classf(*args)f(*args)
) staticmethod
classmeth

静态方法

对于静态方法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__来构造一个自己的集合类非常的常用，下面我们就通过一些例子来看一下它们的应用。

__getattr__

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 &#39; + dict.__repr__(self) + &#39;>'

我们来使用一下我们自定义的加强版字典：

>>> 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用于通过下标[]的形式来获取对象中的元素，下面我们通过重写__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

References

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 &#39;__main__.MyClass&#39;>

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 &#39;__main__.MyClass&#39;>

描述符的原理

描述符触发

上面这个例子中，我们分别从实例属性和类属性的角度列举了描述符的用法，下面我们来仔细分析一下内部的原理：

  • 如果是对实例属性进行访问，相当于调用了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']。

Property

每次使用描述符的时候都定义一个描述符类，这样看起来非常繁琐。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__来构造一个自己的集合类非常的常用，下面我们就通过一些例子来看一下它们的应用。

__getattr__

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 &#39; + dict.__repr__(self) + &#39;>'

我们来使用一下我们自定义的加强版字典：

>>> 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用于通过下标[]的形式来获取对象中的元素，下面我们通过重写__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中文网！
陳述：
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn
上一篇：Python全端之路系列函數下一篇：Python全端之路系列函數

相關文章

看更多