python - Python数据模型和内置函数有什么关系？

Question

当我在 Stack Overflow 上阅读 Python 答案时，我继续看到一些人告诉用户直接使用数据模型的特殊方法或属性。

然后我看到相互矛盾的建议（有时来自我自己）说不要这样做，而是直接使用内置函数和运算符。

这是为什么？Python数据模型和内置函数的特殊“dunder”方法和属性之间有什么关系？

我什么时候应该使用特殊名称？

score 46 · Accepted Answer

Python数据模型和内置函数之间有什么关系？

内置函数和运算符使用底层数据模型方法或属性。
内置函数和运算符具有更优雅的行为，并且通常更向前兼容。
数据模型的特殊方法是语义上的非公共接口。
内置函数和语言运算符专门用作由特殊方法实现的行为的用户界面。

因此，您应该尽可能使用内置函数和运算符，而不是数据模型的特殊方法和属性。

语义上的内部 API 比公共接口更有可能发生变化。虽然 Python 实际上并没有考虑任何“私有”并公开内部结构，但这并不意味着滥用该访问权限是一个好主意。这样做有以下风险：

在升级 Python 可执行文件或切换到 Python 的其他实现（如 PyPy、IronPython 或 Jython 或其他一些不可预见的实现）时，您可能会发现有更多重大更改。
您的同事可能会认为您的语言技能和责任心很差，并认为这是一种代码气味，使您和您的其他代码受到更严格的审查。
内置函数很容易拦截行为。使用特殊方法直接限制了 Python 进行自省和调试的能力。

深入

内置函数和运算符调用特殊方法并使用 Python 数据模型中的特殊属性。它们是隐藏对象内部的可读和可维护的饰面。一般来说，用户应该使用语言中给出的内置函数和运算符，而不是调用特殊方法或直接使用特殊属性。

与更原始的数据模型特殊方法相比，内置函数和运算符也可以具有回退或更优雅的行为。例如：

next(obj, default)允许您StopIteration在迭代器用完时提供默认值而不是引发，而obj.__next__()不会。
str(obj)回退到obj.__repr__()何时obj.__str__()不可用 - 而obj.__str__()直接调用会引发属性错误。
obj != other回退到not obj == otherPython 3 时 no __ne__- 调用obj.__ne__(other)不会利用这一点。

（如果需要或需要，内置函数也可以很容易地在模块的全局范围或builtins模块上被掩盖，以进一步自定义行为。）

将内置函数和运算符映射到数据模型

这是内置函数和运算符到它们使用或返回的相应特殊方法和属性的映射，带有注释 - 请注意，通常的规则是内置函数通常映射到同名的特殊方法，但这不够一致，不足以保证在下面给出这张地图：

builtins/     special methods/
operators  -> datamodel               NOTES (fb == fallback)

repr(obj)     obj.__repr__()          provides fb behavior for str
str(obj)      obj.__str__()           fb to __repr__ if no __str__
bytes(obj)    obj.__bytes__()         Python 3 only
unicode(obj)  obj.__unicode__()       Python 2 only
format(obj)   obj.__format__()        format spec optional.
hash(obj)     obj.__hash__()
bool(obj)     obj.__bool__()          Python 3, fb to __len__
bool(obj)     obj.__nonzero__()       Python 2, fb to __len__
dir(obj)      obj.__dir__()
vars(obj)     obj.__dict__            does not include __slots__
type(obj)     obj.__class__           type actually bypasses __class__ -
                                      overriding __class__ will not affect type
help(obj)     obj.__doc__             help uses more than just __doc__
len(obj)      obj.__len__()           provides fb behavior for bool
iter(obj)     obj.__iter__()          fb to __getitem__ w/ indexes from 0 on
next(obj)     obj.__next__()          Python 3
next(obj)     obj.next()              Python 2
reversed(obj) obj.__reversed__()      fb to __len__ and __getitem__
other in obj  obj.__contains__(other) fb to __iter__ then __getitem__
obj == other  obj.__eq__(other)
obj != other  obj.__ne__(other)       fb to not obj.__eq__(other) in Python 3
obj < other   obj.__lt__(other)       get >, >=, <= with @functools.total_ordering
complex(obj)  obj.__complex__()
int(obj)      obj.__int__()
float(obj)    obj.__float__()
round(obj)    obj.__round__()
abs(obj)      obj.__abs__()

如果未实现，则该operator模块具有length_hint通过相应的特殊方法实现的回退：__len__

length_hint(obj)  obj.__length_hint__()

虚线查找

虚线查找是上下文相关的。如果没有特殊的方法实现，首先在类层次结构中查找数据描述符（如属性和插槽），然后在实例中__dict__（对于实例变量），然后在类层次结构中查找非数据描述符（如方法）。特殊方法实现以下行为：

obj.attr      obj.__getattr__('attr')       provides fb if dotted lookup fails
obj.attr      obj.__getattribute__('attr')  preempts dotted lookup
obj.attr = _  obj.__setattr__('attr', _)    preempts dotted lookup
del obj.attr  obj.__delattr__('attr')       preempts dotted lookup

描述符

描述符有点高级——随意跳过这些条目，稍后再回来——回忆一下描述符实例在类层次结构中（如方法、槽和属性）。数据描述符实现__set__或__delete__：

obj.attr        descriptor.__get__(obj, type(obj)) 
obj.attr = val  descriptor.__set__(obj, val)
del obj.attr    descriptor.__delete__(obj)

当类被实例化（定义）时，__set_name__如果任何描述符具有它来通知描述符其属性名称，则调用以下描述符方法。（这是 Python 3.6 中的新增功能。）cls同上type(obj)，'attr'代表属性名称：

class cls:
    @descriptor_type
    def attr(self): pass # -> descriptor.__set_name__(cls, 'attr')

项目（下标符号）

下标符号也是上下文相关的：

obj[name]         -> obj.__getitem__(name)
obj[name] = item  -> obj.__setitem__(name, item)
del obj[name]     -> obj.__delitem__(name)

如果没有找到键dict，__missing__则调用, 的子类的特殊情况：__getitem__

obj[name]         -> obj.__missing__(name)

运营商

运算符也有特殊的方法+, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |，例如：

obj + other   ->  obj.__add__(other), fallback to other.__radd__(obj)
obj | other   ->  obj.__or__(other), fallback to other.__ror__(obj)

和用于扩充赋值的就地运算符+=, -=, *=, @=, /=, //=, %=, **=, <<=, >>=, &=, ^=, |=，例如：

obj += other  ->  obj.__iadd__(other)
obj |= other  ->  obj.__ior__(other)

（如果未定义这些就地运算符，Python 会回退到，例如 for obj += otherto obj = obj + other）

和一元运算：

+obj          ->  obj.__pos__()
-obj          ->  obj.__neg__()
~obj          ->  obj.__invert__()

上下文管理器

上下文管理器定义__enter__，在进入代码块时调用（它的返回值，通常是 self，别名为as），和__exit__，保证在离开代码块时调用，带有异常信息。

with obj as enters_return_value: #->  enters_return_value = obj.__enter__()
    raise Exception('message')
                                 #->  obj.__exit__(Exception, 
                                 #->               Exception('message'), 
                                 #->               traceback_object)

如果__exit__得到一个异常然后返回一个假值，它会在离开方法时重新引发它。

如果没有例外，则改为__exit__获取None这三个参数，并且返回值没有意义：

with obj:           #->  obj.__enter__()
    pass
                    #->  obj.__exit__(None, None, None)

一些元类特殊方法

类似地，类可以具有支持抽象基类的特殊方法（来自它们的元类）：

isinstance(obj, cls) -> cls.__instancecheck__(obj)
issubclass(sub, cls) -> cls.__subclasscheck__(sub)

一个重要的收获是，虽然 Python 2 和 3 之间的内置函数喜欢next并且bool不会改变，但底层实现名称正在改变。

因此使用内置函数也提供了更多的前向兼容性。

我什么时候应该使用特殊名称？

在 Python 中，以下划线开头的名称在语义上是用户的非公共名称。下划线是创作者的表达方式，“放手，不要碰”。

这不仅是文化上的，而且在 Python 对 API 的处理中也是如此。当包__init__.py用于import *从子包中提供 API 时，如果子包不提供__all__，则排除以下划线开头的名称。子包__name__也将被排除在外。

IDE 自动完成工具在考虑以下划线开头的名称是非公开的时混合在一起。但是，当我输入对象的名称和句点时，我非常感谢没有看到__init__, __new__, __repr__, __str__,__eq__等（也没有任何用户创建的非公共接口）。

因此我断言：

特殊的“dunder”方法不是公共接口的一部分。避免直接使用它们。

那么什么时候使用它们呢？

主要用例是在实现您自己的自定义对象或内置对象的子类时。

尝试仅在绝对必要时使用它们。这里有些例子：

在函数或类上使用`name`特殊属性

当我们装饰一个函数时，我们通常会得到一个包装函数作为回报，它隐藏了关于函数的有用信息。我们会使用@wraps(fn)装饰器来确保我们不会丢失该信息，但是如果我们需要函数的名称，我们需要__name__直接使用属性：

from functools import wraps

def decorate(fn): 
    @wraps(fn)
    def decorated(*args, **kwargs):
        print('calling fn,', fn.__name__) # exception to the rule
        return fn(*args, **kwargs)
    return decorated

同样，当我需要方法中的对象类的名称（例如，用于 a __repr__）时，我会执行以下操作：

def get_class_name(self):
    return type(self).__name__
          # ^          # ^- must use __name__, no builtin e.g. name()
          # use type, not .__class__

使用特殊属性编写自定义类或子类内置

当我们想要定义自定义行为时，我们必须使用数据模型名称。

这是有道理的，因为我们是实现者，所以这些属性对我们来说不是私有的。

class Foo(object):
    # required to here to implement == for instances:
    def __eq__(self, other):      
        # but we still use == for the values:
        return self.value == other.value
    # required to here to implement != for instances:
    def __ne__(self, other): # docs recommend for Python 2.
        # use the higher level of abstraction here:
        return not self == other

但是，即使在这种情况下，我们也不使用self.value.__eq__(other.value)or not self.__eq__(other)（请参阅我的答案以证明后者会导致意外行为。）相反，我们应该使用更高级别的抽象。

我们需要使用特殊方法名称的另一点是，当我们处于子实现中，并且想要委托给父时。例如：

class NoisyFoo(Foo):
    def __eq__(self, other):
        print('checking for equality')
        # required here to call the parent's method
        return super(NoisyFoo, self).__eq__(other)

结论

特殊方法允许用户实现对象内部的接口。

尽可能使用内置函数和运算符。仅使用没有记录公共 API 的特殊方法。

score 11 · Accepted Answer

我将展示一些您显然没有想到的用法，评论您展示的示例，并根据您自己的答案反对隐私声明。

我同意您自己的回答，例如len(a)应该使用，而不是a.__len__(). 我会这样说：len存在所以我们可以使用它，__len__存在所以len可以使用它。或者，这在内部确实有效，因为len(a)实际上可以更快，至少例如对于列表和字符串：

>>> timeit('len(a)', 'a = [1,2,3]', number=10**8)
4.22549770486512
>>> timeit('a.__len__()', 'a = [1,2,3]', number=10**8)
7.957335462257106

>>> timeit('len(s)', 's = "abc"', number=10**8)
4.1480574509332655
>>> timeit('s.__len__()', 's = "abc"', number=10**8)
8.01780160432645

但是除了在我自己的类中定义这些方法供内置函数和运算符使用之外，我偶尔也会按如下方式使用它们：

假设我需要为某个函数提供一个过滤器函数，并且我想使用一个集合s作为过滤器。我不会创建额外的函数lambda x: x in s或def f(x): return x in s. 不，我已经有了一个可以使用的非常好的函数：集合的__contains__方法。它更简单，更直接。甚至更快，如图所示（忽略我把它保存在f这里，这只是为了这个计时演示）：

>>> timeit('f(2); f(4)', 's = {1, 2, 3}; f = s.__contains__', number=10**8)
6.473739433621368
>>> timeit('f(2); f(4)', 's = {1, 2, 3}; f = lambda x: x in s', number=10**8)
19.940786514456924
>>> timeit('f(2); f(4)', 's = {1, 2, 3}\ndef f(x): return x in s', number=10**8)
20.445680107760325

因此，虽然我不直接调用魔术方法s.__contains__(x)，但我偶尔会在某处传递它们，例如some_function_needing_a_filter(s.__contains__). 而且我认为这非常好，并且比 lambda/def 替代方案更好。

我对您展示的示例的看法：

示例 1：当被问及如何获取列表的大小时，他回答items.__len__()。即使没有任何理由。我的结论是：这是错误的。应该是len(items)。
例2：先提一下d[key] = value！然后加上d.__setitem__(key, value)推理“如果你的键盘缺少方括号键”，这很少适用，我怀疑这很严重。我认为这只是最后一点的入门，提到这就是我们如何在我们自己的类中支持方括号语法。这又回到了使用方括号的建议。
例3：建议obj.__dict__。不好，就像__len__例子一样。但我怀疑他只是不知道vars(obj)，我可以理解，因为vars它不太常见/不为人知，而且名称确实与__dict__.
例4：建议__class__。应该是type(obj)。我怀疑它与__dict__故事相似，尽管我认为type它更知名。

关于隐私：在您自己的回答中，您说这些方法是“语义上私有的”。我强烈反对。单和双前导下划线是为此，但不是数据模型的特殊“dunder/magic”方法具有双前导+尾随下划线。

您用作参数的两件事是导入行为和 IDE 的自动完成。但是导入和这些特殊方法是不同的领域，我尝试过的一个 IDE（流行的 PyCharm）不同意你的看法。我用方法创建了一个类/对象，_foo然后__bar__自动完成没有提供_foo但确实提供了__bar__。无论如何，当我使用这两种方法时，PyCharm 只警告我_foo（称其为“受保护成员”），而不是关于__bar__.
PEP 8明确地为单前导下划线表示“弱“内部使用”指示符，并且明确地为双前导下划线它提到了名称 mangling，后来解释说它是用于“您不希望子类使用的属性”。但是关于双前导+尾随下划线的评论并没有这样说。
您自己链接到的数据模型页面说这些特殊方法名称是“Python 的运算符重载方法”。那里没有关于隐私的事情。私人/隐私/受保护的词甚至不会出现在该页面的任何地方。

我还建议阅读Andrew Montalenti关于这些方法的这篇文章，强调“dunder 约定是为核心 Python 团队保留的命名空间”和“永远不要发明自己的 dunders”，因为“核心 Python 团队保留了一个有点丑陋的自己的命名空间”。这都符合 PEP 8 的指令“永远不要发明 [dunder/magic] 名称；. 我认为 Andrew 是正确的 - 它只是核心团队的一个丑陋的名称空间。这是为了操作员重载，而不是隐私（不是安德鲁的观点，而是我的观点和数据模型页面的观点）。

除了 Andrew 的文章，我还查看了更多关于这些“魔术”/“dunder”方法的内容，我发现它们中没有一个是在谈论隐私。这不是它的目的。

同样，我们应该使用len(a)，而不是a.__len__()。但不是因为隐私。

python - Python数据模型和内置函数有什么关系？

2 回答 2

Python数据模型和内置函数之间有什么关系？

深入

将内置函数和运算符映射到数据模型

虚线查找

描述符

项目（下标符号）

运营商

上下文管理器

一些元类特殊方法

我什么时候应该使用特殊名称？

在函数或类上使用__name__特殊属性

使用特殊属性编写自定义类或子类内置

结论

Related

Reference

在函数或类上使用`name`特殊属性