描述符指南

作者

雷蒙德·赫廷格

接触

<python at rcn dot com>

目录

• 描述符指南

  • 底漆

    • 简单的示例：返回常量的描述符

    • 动态查找

    • 托管属性

    • 自定义名称

    • 结束语

  • 完整的实例

    • 验证器类

    • 自定义验证器

    • 实际应用

  • 技术教程

    • 摘要

    • 定义和介绍

    • 描述符协议

    • 描述符调用概述

    • 从实例调用

    • 从类调用

    • 来自超级用户的调用

    • 调用逻辑摘要

    • 自动名称通知

    • ORM示例

  • 纯Python等效项

    • 属性

    • 函数和方法

    • 静电方法

    • 类方法

    • 成员对象和 __slots__

Descriptors 允许对象自定义属性查找、存储和删除。

本指南有四个主要部分：

1. “入门”给出了一个基本的概述，从简单的示例中慢慢地移动，一次添加一个功能。如果您不熟悉描述符，请从这里开始。

2. 第二部分展示了一个完整的、实用的描述符示例。如果你已经知道基础知识，那就从那里开始吧。

3. 第三部分提供了一个更具技术性的教程，详细介绍了描述符的工作机制。大多数人不需要这种级别的细节。

4. 最后一节提供了用C编写的内置描述符的纯Python等效项，如果您对函数如何转变为绑定方法或常用工具的实现感兴趣，请阅读本文 classmethod() ， staticmethod() ， property() ，以及 __slots__ 。

底漆

在本入门教程中，我们将从可能的最基本示例开始，然后逐个添加新功能。

简单的示例：返回常量的描述符

这个 Ten 类是始终返回常量的描述符 10 从ITS __get__() 方法：

class Ten:
    def __get__(self, obj, objtype=None):
        return 10

要使用描述符，必须将其作为类变量存储在另一个类中：

class A:
    x = 5                       # Regular class attribute
    y = Ten()                   # Descriptor instance

交互式会话显示了普通属性查找和描述符查找之间的区别：

>>> a = A()                     # Make an instance of class A
>>> a.x                         # Normal attribute lookup
5
>>> a.y                         # Descriptor lookup
10

在 a.x 属性查找时，点运算符查找键 x 以及它的价值 5 在班级字典里。在 a.y 查找时，点运算符查找一个描述符实例，该实例由其 __get__ 方法，并调用该方法，该方法返回 10 。

请注意，该值 10 既不存储在类字典中，也不存储在实例字典中。取而代之的是，它的价值 10 是按需计算的。

这个例子展示了一个简单的描述符是如何工作的，但是它不是很有用。对于检索常量，普通属性查找会更好。

在下一节中，我们将创建一些更有用的东西，即动态查找。

动态查找

有趣的描述符通常运行计算，而不是返回常量：

import os

class DirectorySize:

    def __get__(self, obj, objtype=None):
        return len(os.listdir(obj.dirname))

class Directory:

    size = DirectorySize()              # Descriptor instance

    def __init__(self, dirname):
        self.dirname = dirname          # Regular instance attribute

交互式会话显示查找是动态的-它每次都会计算不同的更新答案：：

>>> s = Directory('songs')
>>> g = Directory('games')
>>> s.size                              # The songs directory has twenty files
20
>>> g.size                              # The games directory has three files
3
>>> open('games/newfile').close()       # Add a fourth file to the directory
>>> g.size                              # File count is automatically updated
4

除了显示描述符如何运行计算外，此示例还揭示了参数的用途 __get__() 。这个 self 参数为 size ，一个实例 DirectorySize 。这个 obj 参数为 g 或 s ，一个实例 目录 。这是 obj 参数，该参数让 __get__() 方法学习目标目录。这个 对象类型 参数是类 目录 。

托管属性

描述符的一个常见用途是管理对实例数据的访问。描述符被分配给类字典中的公共属性，而实际数据作为私有属性存储在实例字典中。描述符的 __get__() 和 __set__() 方法在访问public属性时触发。

在下面的示例中， age 是public属性，并且 _age 是私有属性。访问公共属性时，描述符会记录查找或更新：

import logging

logging.basicConfig(level=logging.INFO)

class LoggedAgeAccess:

    def __get__(self, obj, objtype=None):
        value = obj._age
        logging.info('Accessing %r giving %r', 'age', value)
        return value

    def __set__(self, obj, value):
        logging.info('Updating %r to %r', 'age', value)
        obj._age = value

class Person:

    age = LoggedAgeAccess()             # Descriptor instance

    def __init__(self, name, age):
        self.name = name                # Regular instance attribute
        self.age = age                  # Calls __set__()

    def birthday(self):
        self.age += 1                   # Calls both __get__() and __set__()

交互式会话显示对托管属性的所有访问 age 已记录，但Regular属性 name 未记录：

>>> mary = Person('Mary M', 30)         # The initial age update is logged
INFO:root:Updating 'age' to 30
>>> dave = Person('David D', 40)
INFO:root:Updating 'age' to 40

>>> vars(mary)                          # The actual data is in a private attribute
{'name': 'Mary M', '_age': 30}
>>> vars(dave)
{'name': 'David D', '_age': 40}

>>> mary.age                            # Access the data and log the lookup
INFO:root:Accessing 'age' giving 30
30
>>> mary.birthday()                     # Updates are logged as well
INFO:root:Accessing 'age' giving 30
INFO:root:Updating 'age' to 31

>>> dave.name                           # Regular attribute lookup isn't logged
'David D'
>>> dave.age                            # Only the managed attribute is logged
INFO:root:Accessing 'age' giving 40
40

此示例的一个主要问题是，专用名称 _age 是硬连线在 LoggedAgeAccess 班级。这意味着每个实例只能有一个记录的属性，并且其名称不可更改。在下一个示例中，我们将解决该问题。

自定义名称

当一个类使用描述符时，它可以通知每个描述符使用了哪个变量名。

在此示例中， Person 类有两个描述符实例， name 和 age 。当 Person 类定义后，它会回调 __set_name__() 在……里面 LoggedAccess 这样就可以记录字段名，为每个描述符赋予自己的名称 public_name 和 private_name ：

import logging

logging.basicConfig(level=logging.INFO)

class LoggedAccess:

    def __set_name__(self, owner, name):
        self.public_name = name
        self.private_name = '_' + name

    def __get__(self, obj, objtype=None):
        value = getattr(obj, self.private_name)
        logging.info('Accessing %r giving %r', self.public_name, value)
        return value

    def __set__(self, obj, value):
        logging.info('Updating %r to %r', self.public_name, value)
        setattr(obj, self.private_name, value)

class Person:

    name = LoggedAccess()                # First descriptor instance
    age = LoggedAccess()                 # Second descriptor instance

    def __init__(self, name, age):
        self.name = name                 # Calls the first descriptor
        self.age = age                   # Calls the second descriptor

    def birthday(self):
        self.age += 1

交互式会话显示， Person 类已调用 __set_name__() 以便记录字段名称。在这里我们称其为 vars() 要在不触发描述符的情况下查找描述符，请执行以下操作：

>>> vars(vars(Person)['name'])
{'public_name': 'name', 'private_name': '_name'}
>>> vars(vars(Person)['age'])
{'public_name': 'age', 'private_name': '_age'}

新类现在记录对这两个类的访问 name 和 age ：

>>> pete = Person('Peter P', 10)
INFO:root:Updating 'name' to 'Peter P'
INFO:root:Updating 'age' to 10
>>> kate = Person('Catherine C', 20)
INFO:root:Updating 'name' to 'Catherine C'
INFO:root:Updating 'age' to 20

两个人 人 实例仅包含专用名称：：

>>> vars(pete)
{'_name': 'Peter P', '_age': 10}
>>> vars(kate)
{'_name': 'Catherine C', '_age': 20}

结束语

A descriptor 是我们所称的任何定义了 __get__() ， __set__() ，或 __delete__() 。

或者，描述符可以具有 __set_name__() 方法。这仅在描述符需要知道创建它的类或分配给它的类变量的名称的情况下使用。(即使类不是描述符，也会调用此方法(如果存在)。)

描述符在属性查找期间由点“操作符”调用。如果间接访问描述符，则使用 vars(some_class)[descriptor_name] ，则返回描述符实例，而不调用它。

描述符仅在用作类变量时才起作用。当放入实例中时，它们没有任何效果。

描述符的主要动机是提供一个钩子，允许存储在类变量中的对象控制属性查找期间发生的事情。

传统上，调用类控制查找期间发生的事情。描述符颠倒了这种关系，并允许被查找的数据在该问题上有发言权。

整个语言中都使用描述符。这就是函数变成绑定方法的方式。常见工具，如 classmethod() ， staticmethod() ， property() ，以及 functools.cached_property() 都实现为描述符。

完整的实例

在此示例中，我们创建了一个实用而强大的工具，用于定位出出了名的难以找到数据损坏错误的位置。

验证器类

验证器是托管属性访问的描述符。在存储任何数据之前，它会验证新值是否满足各种类型和范围限制。如果不满足这些限制，它会引发一个例外，以从源头上防止数据损坏。

这 Validator 类既是一个 abstract base class 和托管属性描述符：

from abc import ABC, abstractmethod

class Validator(ABC):

    def __set_name__(self, owner, name):
        self.private_name = '_' + name

    def __get__(self, obj, objtype=None):
        return getattr(obj, self.private_name)

    def __set__(self, obj, value):
        self.validate(value)
        setattr(obj, self.private_name, value)

    @abstractmethod
    def validate(self, value):
        pass

自定义验证器需要从 Validator ，并且必须提供 validate() 方法根据需要测试各种限制。

自定义验证器

以下是三个实用的数据验证实用程序：

1. OneOf 验证值是否为一组受限选项之一。

2. Number 验证值是否为 int 或 float 。它还可以验证值是否在给定的最小值或最大值之间。

3. String 验证值是否为 str 。它还可以验证给定的最小或最大长度。它可以验证用户定义的 predicate 也是。

class OneOf(Validator):

    def __init__(self, *options):
        self.options = set(options)

    def validate(self, value):
        if value not in self.options:
            raise ValueError(f'Expected {value!r} to be one of {self.options!r}')

class Number(Validator):

    def __init__(self, minvalue=None, maxvalue=None):
        self.minvalue = minvalue
        self.maxvalue = maxvalue

    def validate(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError(f'Expected {value!r} to be an int or float')
        if self.minvalue is not None and value < self.minvalue:
            raise ValueError(
                f'Expected {value!r} to be at least {self.minvalue!r}'
            )
        if self.maxvalue is not None and value > self.maxvalue:
            raise ValueError(
                f'Expected {value!r} to be no more than {self.maxvalue!r}'
            )

class String(Validator):

    def __init__(self, minsize=None, maxsize=None, predicate=None):
        self.minsize = minsize
        self.maxsize = maxsize
        self.predicate = predicate

    def validate(self, value):
        if not isinstance(value, str):
            raise TypeError(f'Expected {value!r} to be an str')
        if self.minsize is not None and len(value) < self.minsize:
            raise ValueError(
                f'Expected {value!r} to be no smaller than {self.minsize!r}'
            )
        if self.maxsize is not None and len(value) > self.maxsize:
            raise ValueError(
                f'Expected {value!r} to be no bigger than {self.maxsize!r}'
            )
        if self.predicate is not None and not self.predicate(value):
            raise ValueError(
                f'Expected {self.predicate} to be true for {value!r}'
            )

实际应用

下面是如何在实际类中使用数据验证器：

class Component:

    name = String(minsize=3, maxsize=10, predicate=str.isupper)
    kind = OneOf('wood', 'metal', 'plastic')
    quantity = Number(minvalue=0)

    def __init__(self, name, kind, quantity):
        self.name = name
        self.kind = kind
        self.quantity = quantity

描述符可防止创建无效实例：

>>> Component('Widget', 'metal', 5)      # Blocked: 'Widget' is not all uppercase
Traceback (most recent call last):
    ...
ValueError: Expected <method 'isupper' of 'str' objects> to be true for 'Widget'

>>> Component('WIDGET', 'metle', 5)      # Blocked: 'metle' is misspelled
Traceback (most recent call last):
    ...
ValueError: Expected 'metle' to be one of {'metal', 'plastic', 'wood'}

>>> Component('WIDGET', 'metal', -5)     # Blocked: -5 is negative
Traceback (most recent call last):
    ...
ValueError: Expected -5 to be at least 0
>>> Component('WIDGET', 'metal', 'V')    # Blocked: 'V' isn't a number
Traceback (most recent call last):
    ...
TypeError: Expected 'V' to be an int or float

>>> c = Component('WIDGET', 'metal', 5)  # Allowed:  The inputs are valid

技术教程

下面是关于描述符如何工作的机制和细节的更具技术性的教程。

摘要

定义描述符，总结协议，并显示如何调用描述符。提供一个示例，说明对象关系映射的工作原理。

学习描述符不仅可以访问更大的工具集，还可以更深入地理解Python是如何工作的。

定义和介绍

通常，描述符是具有描述符协议中的方法之一的属性值。这些方法是 __get__() ， __set__() ，以及 __delete__() 。如果为属性定义了这些方法中的任何一个，则称其为 descriptor 。

属性访问的默认行为是从对象的字典中获取、设置或删除属性。例如, a.x 具有以以下字符开头的查找链 a.__dict__['x'] ，那么 type(a).__dict__['x'] ，并继续执行以下方法解析顺序 type(a) 。如果查找的值是定义描述符方法之一的对象，那么Python可以覆盖默认行为并调用描述符方法。这在优先链中发生的位置取决于定义了哪些描述符方法。

描述符是一种功能强大的通用协议。它们是属性、方法、静电方法、类方法和 super() 。它们在整个Python本身中使用。描述符简化了底层C代码，并为日常Python程序提供了一组灵活的新工具。

描述符协议

descr.__get__(self, obj, type=None) -> value

descr.__set__(self, obj, value) -> None

descr.__delete__(self, obj) -> None

这就是一切。定义这些方法中的任何一个，对象都被视为描述符，并且可以在作为属性被查找时覆盖默认行为。

如果对象定义了 __set__() 或 __delete__() ，则将其视为数据描述符。描述符仅定义 __get__() 称为非数据描述符(它们通常用于方法，但也可能有其他用途)。

数据描述符和非数据描述符在如何根据实例字典中的条目计算覆盖方面有所不同。如果实例的字典中有与数据描述符同名的条目，则数据描述符优先。如果实例的字典中有一个条目与非数据描述符同名，则字典条目优先。

要创建只读数据描述符，请同时定义 __get__() 和 __set__() 与 __set__() 饲养一个 AttributeError 当被召唤时。定义 __set__() 引发占位符的异常的方法足以使其成为数据描述符。

描述符调用概述

可以使用以下命令直接调用描述符 desc.__get__(obj) 或 desc.__get__(None, cls) 。

但更常见的是从属性访问自动调用描述符。

表达式 obj.x 查找属性 x 的命名空间链中 obj 。如果搜索在实例外部找到描述符 __dict__ ，ITS __get__() 方法是根据下面列出的优先规则调用的。

调用的细节取决于是否 obj 是SUPER的对象、类或实例。

从实例调用

实例查找扫描赋予数据描述符最高优先级的命名空间链，然后是实例变量，然后是非数据描述符，然后是类变量，最后是类变量 __getattr__() 如果提供的话。

如果找到 a.x ，然后使用以下命令调用它： desc.__get__(a, type(a)) 。

点线查找的逻辑在 object.__getattribute__() 。下面是一个纯Python等效项：

def object_getattribute(obj, name):
    "Emulate PyObject_GenericGetAttr() in Objects/object.c"
    null = object()
    objtype = type(obj)
    cls_var = getattr(objtype, name, null)
    descr_get = getattr(type(cls_var), '__get__', null)
    if descr_get is not null:
        if (hasattr(type(cls_var), '__set__')
            or hasattr(type(cls_var), '__delete__')):
            return descr_get(cls_var, obj, objtype)     # data descriptor
    if hasattr(obj, '__dict__') and name in vars(obj):
        return vars(obj)[name]                          # instance variable
    if descr_get is not null:
        return descr_get(cls_var, obj, objtype)         # non-data descriptor
    if cls_var is not null:
        return cls_var                                  # class variable
    raise AttributeError(name)

有趣的是，属性查找不会调用 object.__getattribute__() 直接去吧。相反，点运算符和 getattr() 函数通过帮助器函数执行属性查找：

def getattr_hook(obj, name):
    "Emulate slot_tp_getattr_hook() in Objects/typeobject.c"
    try:
        return obj.__getattribute__(name)
    except AttributeError:
        if not hasattr(type(obj), '__getattr__'):
            raise
    return type(obj).__getattr__(obj, name)             # __getattr__

所以如果 __getattr__() 存在，则在任何时候都会调用它。 __getattribute__() 加薪 AttributeError (直接或在某个描述符调用中)。

此外，如果用户调用 object.__getattribute__() 直接地， __getattr__() 钩子被完全绕过。

从类调用

点分查找的逻辑，例如 A.x 是在 type.__getattribute__() 。这些步骤与 object.__getattribute__() 但是实例字典查找被通过类的 method resolution order 。

如果找到描述符，则使用 desc.__get__(None, A) 。

完整的C实现可以在 type_getattro() 和 _PyType_Lookup() 在……里面 Objects/typeobject.c 。

来自超级用户的调用

超级虚线查找的逻辑在 __getattribute__() 由返回的对象的方法 super() 。

虚线查找，如 super(A, obj).m 搜索 obj.__class__.__mro__ 对于基类， B 紧随其后 A 然后返回 B.__dict__['m'].__get__(obj, A) 。如果不是描述符， m 原封不动地返回。

完整的C实现可以在 super_getattro() 在……里面 Objects/typeobject.c 。纯Python等效项可在 Guido's Tutorial 。

调用逻辑摘要

描述符的机制嵌入在 __getattribute__() 方法： object ， type ，以及 super() 。

要记住的要点是：

• 描述符由 __getattribute__() 方法。

• 类从 object ， type ，或 super() 。

• 覆盖 __getattribute__() 防止自动描述符调用，因为所有描述符逻辑都在该方法中。

• object.__getattribute__() 和 type.__getattribute__() 给…打不同的电话 __get__() 。第一个包括实例，也可能包括类。第二个放进去 None 用于实例，并且始终包括类。

• 数据描述符始终覆盖实例字典。

• 非数据描述符可以由实例字典覆盖。

自动名称通知

有时，需要描述符知道它被分配给了哪个类变量名。创建新类时， type 元类扫描新类的字典。如果任何条目是描述符，并且如果它们定义 __set_name__() ，则使用两个参数调用该方法。这个 所有者 是使用描述符的类，而 name 是向其分配描述符的类变量。

实现的详细信息在 type_new() 和 set_names() 在……里面 Objects/typeobject.c 。

由于更新逻辑在 type.__new__() ，则只在创建类时发出通知。如果随后将描述符添加到类中， __set_name__() 将需要手动调用。

ORM示例

下面的代码是一个简化的框架，显示了如何使用数据描述符来实现 object relational mapping 。

其基本思想是将数据存储在外部数据库中。Python实例只保存数据库表的键。描述符负责查找或更新：

class Field:

    def __set_name__(self, owner, name):
        self.fetch = f'SELECT {name} FROM {owner.table} WHERE {owner.key}=?;'
        self.store = f'UPDATE {owner.table} SET {name}=? WHERE {owner.key}=?;'

    def __get__(self, obj, objtype=None):
        return conn.execute(self.fetch, [obj.key]).fetchone()[0]

    def __set__(self, obj, value):
        conn.execute(self.store, [value, obj.key])
        conn.commit()

我们可以使用 Field 要定义的类 models 它们描述了数据库中每个表的架构：

class Movie:
    table = 'Movies'                    # Table name
    key = 'title'                       # Primary key
    director = Field()
    year = Field()

    def __init__(self, key):
        self.key = key

class Song:
    table = 'Music'
    key = 'title'
    artist = Field()
    year = Field()
    genre = Field()

    def __init__(self, key):
        self.key = key

要使用这些模型，请首先连接到数据库：：

>>> import sqlite3
>>> conn = sqlite3.connect('entertainment.db')

交互式会话显示如何从数据库检索数据以及如何更新数据：

>>> Movie('Star Wars').director
'George Lucas'
>>> jaws = Movie('Jaws')
>>> f'Released in {jaws.year} by {jaws.director}'
'Released in 1975 by Steven Spielberg'

>>> Song('Country Roads').artist
'John Denver'

>>> Movie('Star Wars').director = 'J.J. Abrams'
>>> Movie('Star Wars').director
'J.J. Abrams'

纯Python等效项

描述符协议很简单，并且提供了令人兴奋的可能性。有几个用例非常常见，它们已预先打包到内置工具中。属性、绑定方法、静电方法、类方法和 __slots__ 都基于描述符协议。

属性

呼叫 property() 是构建数据描述符的一种简洁方式，该描述符在访问属性时触发函数调用。其签名是：：

property(fget=None, fset=None, fdel=None, doc=None) -> property

文档显示了定义托管属性的典型用法 x ：

class C:
    def getx(self): return self.__x
    def setx(self, value): self.__x = value
    def delx(self): del self.__x
    x = property(getx, setx, delx, "I'm the 'x' property.")

要了解如何 property() 是按照描述符协议实现的，下面是一个纯Python等效项：

class Property:
    "Emulate PyProperty_Type() in Objects/descrobject.c"

    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
        if doc is None and fget is not None:
            doc = fget.__doc__
        self.__doc__ = doc
        self._name = ''

    def __set_name__(self, owner, name):
        self._name = name

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.fget is None:
            raise AttributeError(f'unreadable attribute {self._name}')
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError(f"can't set attribute {self._name}")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError(f"can't delete attribute {self._name}")
        self.fdel(obj)

    def getter(self, fget):
        prop = type(self)(fget, self.fset, self.fdel, self.__doc__)
        prop._name = self._name
        return prop

    def setter(self, fset):
        prop = type(self)(self.fget, fset, self.fdel, self.__doc__)
        prop._name = self._name
        return prop

    def deleter(self, fdel):
        prop = type(self)(self.fget, self.fset, fdel, self.__doc__)
        prop._name = self._name
        return prop

这个 property() 每当用户界面授予属性访问权限，然后随后的更改需要方法的干预时，内置功能都会起到帮助作用。

例如，电子表格类可以通过以下方式授予对单元格值的访问权限 Cell('b10').value 。对程序的后续改进要求在每次访问时重新计算单元；但是，程序员不希望影响直接访问该属性的现有客户端代码。解决方案是将对value属性的访问包装在属性数据描述符中：

class Cell:
    ...

    @property
    def value(self):
        "Recalculate the cell before returning value"
        self.recalc()
        return self._value

要么是内置的 property() 或者我们的 Property() 在本例中，等效项将起作用。

函数和方法

Python面向对象的特性是建立在基于函数的环境之上的。使用非数据描述符，可以无缝地合并这两个描述符。

类字典中存储的函数在调用时会转换为方法。方法与常规函数的唯一不同之处在于，对象实例优先于其他参数。按照惯例，该实例称为 self 但是可以被称为 this 或任何其他变量名。

方法可以使用以下命令手动创建 types.MethodType 大致相当于：

class MethodType:
    "Emulate Py_MethodType in Objects/classobject.c"

    def __init__(self, func, obj):
        self.__func__ = func
        self.__self__ = obj

    def __call__(self, *args, **kwargs):
        func = self.__func__
        obj = self.__self__
        return func(obj, *args, **kwargs)

为了支持方法的自动创建，函数包括 __get__() 在属性访问期间绑定方法的方法。这意味着函数是非数据描述符，在从实例进行点分查找期间返回绑定方法。它的工作原理是这样的：

class Function:
    ...

    def __get__(self, obj, objtype=None):
        "Simulate func_descr_get() in Objects/funcobject.c"
        if obj is None:
            return self
        return MethodType(self, obj)

在解释器中运行以下类将显示函数描述符的实际工作方式：

class D:
    def f(self, x):
         return x

该函数有一个 qualified name 属性以支持自检：

>>> D.f.__qualname__
'D.f'

通过类字典访问函数不会调用 __get__() 。相反，它只返回底层函数对象：：

>>> D.__dict__['f']
<function D.f at 0x00C45070>

来自类调用的点访问 __get__() 它只返回未更改的底层函数：：

>>> D.f
<function D.f at 0x00C45070>

有趣的行为发生在从实例进行点访问期间。带点的查找调用 __get__() 它返回绑定的方法对象：：

>>> d = D()
>>> d.f
<bound method D.f of <__main__.D object at 0x00B18C90>>

在内部，绑定方法存储基础函数和绑定实例：：

>>> d.f.__func__
<function D.f at 0x00C45070>

>>> d.f.__self__
<__main__.D object at 0x1012e1f98>

如果你曾经想知道在哪里 self 以常规方法或从哪里来 cls 来自类中的方法，就是这样！

静电方法

非数据描述符提供了一种简单的机制，用于改变将函数绑定到方法中的通常模式。

简单地说，函数有一个 __get__() 方法，以便它们在作为属性访问时可以转换为方法。非数据描述符将 obj.f(*args) 呼叫进入 f(obj, *args) 。呼叫 cls.f(*args) 变成了 f(*args) 。

此图表总结了绑定及其两个最有用的变体：

变换	从对象调用	从类调用
功能	f（OBJ） * 参数）	f（ * 参数）
静态法	f（ * 参数）	f（ * 参数）
分类法	F（类型（OBJ）， * 参数）	F(CLS，*参数)

静态方法返回基础函数而不进行更改。调用任一 c.f 或 C.f 相当于直接查找 object.__getattribute__(c, "f") 或 object.__getattribute__(C, "f") . 因此，从对象或类中可以相同地访问函数。

静态方法的好候选方法是不引用 self

例如，一个统计数据包可能包含一个用于实验数据的容器类。该类提供了计算平均值、平均值、中位数和其他依赖于数据的描述性统计数据的正常方法。然而，可能有一些有用的函数在概念上是相关的，但不依赖于数据。例如， erf(x) 是在统计工作中出现的方便的转换例程，但不直接依赖于特定的数据集。它可以从对象或类调用： s.erf(1.5) --> .9332 或 Sample.erf(1.5) --> .9332 .

由于静电方法返回底层函数而不做任何更改，因此示例调用并不令人兴奋：

class E:
    @staticmethod
    def f(x):
        print(x)

>>> E.f(3)
3
>>> E().f(3)
3

使用非数据描述符协议，纯Python版本的 staticmethod() 将如下所示：

class StaticMethod:
    "Emulate PyStaticMethod_Type() in Objects/funcobject.c"

    def __init__(self, f):
        self.f = f

    def __get__(self, obj, objtype=None):
        return self.f

类方法

与静电方法不同，类方法在调用函数之前预先考虑对参数列表的类引用。无论调用方是对象还是类，此格式都是相同的：

class F:
    @classmethod
    def f(cls, x):
        return cls.__name__, x

>>> F.f(3)
('F', 3)
>>> F().f(3)
('F', 3)

只要方法只需要一个类引用，而不依赖于存储在特定实例中的数据，此行为就很有用。类方法的一个用途是创建替代类构造函数。例如，类方法 dict.fromkeys() 从键列表创建新词典。纯Python等效项为：

class Dict(dict):
    @classmethod
    def fromkeys(cls, iterable, value=None):
        "Emulate dict_fromkeys() in Objects/dictobject.c"
        d = cls()
        for key in iterable:
            d[key] = value
        return d

现在，可以按如下方式构建新的唯一键字典：

>>> d = Dict.fromkeys('abracadabra')
>>> type(d) is Dict
True
>>> d
{'a': None, 'b': None, 'r': None, 'c': None, 'd': None}

使用非数据描述符协议，纯Python版本的 classmethod() 将如下所示：

class ClassMethod:
    "Emulate PyClassMethod_Type() in Objects/funcobject.c"

    def __init__(self, f):
        self.f = f

    def __get__(self, obj, cls=None):
        if cls is None:
            cls = type(obj)
        if hasattr(obj, '__get__'):
            return self.f.__get__(cls)
        return MethodType(self.f, cls)

的代码路径 hasattr(obj, '__get__') 是在Python3.9中添加的，使得 classmethod() 以支持链式装饰器。例如，类方法和属性可以链接在一起：

class G:
    @classmethod
    @property
    def __doc__(cls):
        return f'A doc for {cls.__name__!r}'

>>> G.__doc__
"A doc for 'G'"

成员对象和 __slots__

当类定义 __slots__ ，它用固定长度的槽值数组替换实例字典。从用户的角度来看，这有几个影响：

1.提供即时检测因属性分配拼写错误而导致的错误。仅在中指定的属性名称 __slots__ 允许：

class Vehicle:
    __slots__ = ('id_number', 'make', 'model')

>>> auto = Vehicle()
>>> auto.id_nubmer = 'VYE483814LQEX'
Traceback (most recent call last):
    ...
AttributeError: 'Vehicle' object has no attribute 'id_nubmer'

2.帮助创建不可变对象，其中描述符管理对存储在 __slots__ ：

class Immutable:

    __slots__ = ('_dept', '_name')          # Replace the instance dictionary

    def __init__(self, dept, name):
        self._dept = dept                   # Store to private attribute
        self._name = name                   # Store to private attribute

    @property                               # Read-only descriptor
    def dept(self):
        return self._dept

    @property
    def name(self):                         # Read-only descriptor
        return self._name

>>> mark = Immutable('Botany', 'Mark Watney')
>>> mark.dept
'Botany'
>>> mark.dept = 'Space Pirate'
Traceback (most recent call last):
    ...
AttributeError: can't set attribute
>>> mark.location = 'Mars'
Traceback (most recent call last):
    ...
AttributeError: 'Immutable' object has no attribute 'location'

3.节省内存。在64位Linux版本上，具有两个属性的实例占用48个字节 __slots__ 和152个字节，没有。这 flyweight design pattern 可能只在要创建大量实例时才重要。

4.阻止工具，如 functools.cached_property() 它们需要实例字典才能正常运行：

from functools import cached_property

class CP:
    __slots__ = ()                          # Eliminates the instance dict

    @cached_property                        # Requires an instance dict
    def pi(self):
        return 4 * sum((-1.0)**n / (2.0*n + 1.0)
                       for n in reversed(range(100_000)))

>>> CP().pi
Traceback (most recent call last):
  ...
TypeError: No '__dict__' attribute on 'CP' instance to cache 'pi' property.

无法创建完全相同的纯Python插件版本 __slots__ 因为它需要直接访问C结构并控制对象内存分配。但是，我们可以构建一个最忠实的模拟，其中插槽的实际C结构由私有 _slotvalues 列表。对该私有结构的读取和写入由成员描述符管理：

null = object()

class Member:

    def __init__(self, name, clsname, offset):
        'Emulate PyMemberDef in Include/structmember.h'
        # Also see descr_new() in Objects/descrobject.c
        self.name = name
        self.clsname = clsname
        self.offset = offset

    def __get__(self, obj, objtype=None):
        'Emulate member_get() in Objects/descrobject.c'
        # Also see PyMember_GetOne() in Python/structmember.c
        value = obj._slotvalues[self.offset]
        if value is null:
            raise AttributeError(self.name)
        return value

    def __set__(self, obj, value):
        'Emulate member_set() in Objects/descrobject.c'
        obj._slotvalues[self.offset] = value

    def __delete__(self, obj):
        'Emulate member_delete() in Objects/descrobject.c'
        value = obj._slotvalues[self.offset]
        if value is null:
            raise AttributeError(self.name)
        obj._slotvalues[self.offset] = null

    def __repr__(self):
        'Emulate member_repr() in Objects/descrobject.c'
        return f'<Member {self.name!r} of {self.clsname!r}>'

这个 type.__new__() 方法负责将成员对象添加到类变量：

class Type(type):
    'Simulate how the type metaclass adds member objects for slots'

    def __new__(mcls, clsname, bases, mapping):
        'Emuluate type_new() in Objects/typeobject.c'
        # type_new() calls PyTypeReady() which calls add_methods()
        slot_names = mapping.get('slot_names', [])
        for offset, name in enumerate(slot_names):
            mapping[name] = Member(name, clsname, offset)
        return type.__new__(mcls, clsname, bases, mapping)

这个 object.__new__() 方法负责创建具有槽的实例，而不是实例字典。下面是一个用纯Python进行的粗略模拟：

class Object:
    'Simulate how object.__new__() allocates memory for __slots__'

    def __new__(cls, *args):
        'Emulate object_new() in Objects/typeobject.c'
        inst = super().__new__(cls)
        if hasattr(cls, 'slot_names'):
            empty_slots = [null] * len(cls.slot_names)
            object.__setattr__(inst, '_slotvalues', empty_slots)
        return inst

    def __setattr__(self, name, value):
        'Emulate _PyObject_GenericSetAttrWithDict() Objects/object.c'
        cls = type(self)
        if hasattr(cls, 'slot_names') and name not in cls.slot_names:
            raise AttributeError(
                f'{type(self).__name__!r} object has no attribute {name!r}'
            )
        super().__setattr__(name, value)

    def __delattr__(self, name):
        'Emulate _PyObject_GenericSetAttrWithDict() Objects/object.c'
        cls = type(self)
        if hasattr(cls, 'slot_names') and name not in cls.slot_names:
            raise AttributeError(
                f'{type(self).__name__!r} object has no attribute {name!r}'
            )
        super().__delattr__(name)

要在真实类中使用模拟，只需从 Object 并将 metaclass 至 Type ：

class H(Object, metaclass=Type):
    'Instance variables stored in slots'

    slot_names = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y

此时，元类已经加载了 x 和 y ：：

>>> from pprint import pp
>>> pp(dict(vars(H)))
{'__module__': '__main__',
 '__doc__': 'Instance variables stored in slots',
 'slot_names': ['x', 'y'],
 '__init__': <function H.__init__ at 0x7fb5d302f9d0>,
 'x': <Member 'x' of 'H'>,
 'y': <Member 'y' of 'H'>}

创建实例时，它们有一个 slot_values 属性存储位置列表：

>>> h = H(10, 20)
>>> vars(h)
{'_slotvalues': [10, 20]}
>>> h.x = 55
>>> vars(h)
{'_slotvalues': [55, 20]}

拼写错误或未分配的属性将引发异常：

>>> h.xz
Traceback (most recent call last):
    ...
AttributeError: 'H' object has no attribute 'xz'