获取 6.1

简介示例

Zope使用“扩展类”混合类实现获取。要使用获取，您的类必须继承自获取基类。例如

>>> import ExtensionClass, Acquisition

>>> class C(ExtensionClass.Base):
...     color = 'red'

>>> class A(Acquisition.Implicit):
...     def report(self):
...         print(self.color)
...
>>> a = A()
>>> c = C()
>>> c.a = a

>>> c.a.report()
red

>>> d = C()
>>> d.color = 'green'
>>> d.a = a

>>> d.a.report()
green

>>> try:
...     a.report()
... except AttributeError:
...     pass
... else:
...     raise AssertionError('AttributeError not raised.')

类A从Acquisition.Implicit继承了获取行为。对象a在通过对象c和d访问时“具有”这些对象的颜色，但它本身没有颜色。对象a从其环境中获取属性，其中其环境由到达a的访问路径定义。

获取包装器

当通过扩展类实例访问支持获取的对象时，会返回一个特殊对象，称为获取包装器。在上面的例子中，表达式c.a返回一个包含对c和a的引用的获取包装器。当在a中找不到属性时，正是这个包装器在c中执行属性查找。

获取包装器通过属性、、提供对包装对象的访问。继续上面的例子

>>> c.a.aq_parent is c
True
>>> c.a.aq_self is a
True

显式和隐式获取

支持两种获取风格：隐式获取和显式获取。

隐式获取

隐式获取之所以被称为隐式获取，是因为它在无法直接从对象或通过继承获得属性时，会自动从环境中搜索属性。

如果一个属性的名称不以下划线开头，它就可以隐式获取。

为了支持隐式获取，您的类应该继承自混合类Acquisition.Implicit。

显式获取

当使用显式获取时，不会自动从环境中获取属性。相反，必须使用方法。例如

>>> print(c.a.aq_acquire('color'))
red

为了支持显式获取，您的类应该继承自混合类Acquisition.Explicit。

控制获取

类（或实例）可以对获取进行逐属性控制。您应该从Acquisition.Explicit派生，并将所有应获取的属性设置为特殊值Acquisition.Acquired。将属性设置为该值还允许用获取的属性覆盖继承的属性。例如

>>> class C(Acquisition.Explicit):
...     id = 1
...     secret = 2
...     color = Acquisition.Acquired
...     __roles__ = Acquisition.Acquired

从包含对象中自动获取的唯一属性是颜色和__roles__。请注意，即使__roles__属性名称以下划线开头，它也会被获取。实际上，在Acquisition.Implicit对象中可以使用特殊的Acquisition.Acquired值来隐式获取看起来像私有对象的选定对象。

有时，您可能希望动态地将隐式获取的对象显式获取。您可以通过获取对象的aq_explicit属性来实现这一点。该属性为对象提供了一个显式的包装器，该包装器替换了原始的隐式包装器。

过滤获取

获取方法aq_acquire接受两个可选参数。第一个附加参数是一个“过滤”函数，当考虑是否获取对象时使用。第二个附加参数是在调用过滤函数时传递的额外数据对象，默认值为None。过滤函数使用五个参数调用

• 调用aq_acquire方法的对象

• 找到对象的对象

• 传递给aq_acquire的对象名称

• 找到的对象

• 传递给aq_acquire的额外数据

如果过滤函数返回一个真值对象，则返回找到的对象，否则，获取搜索继续。

以下是一个示例

>>> from Acquisition import Explicit

>>> class HandyForTesting(object):
...     def __init__(self, name):
...         self.name = name
...     def __str__(self):
...         return "%s(%s)" % (self.name, self.__class__.__name__)
...     __repr__=__str__
...
>>> class E(Explicit, HandyForTesting): pass
...
>>> class Nice(HandyForTesting):
...     isNice = 1
...     def __str__(self):
...         return HandyForTesting.__str__(self)+' and I am nice!'
...     __repr__ = __str__
...
>>> a = E('a')
>>> a.b = E('b')
>>> a.b.c = E('c')
>>> a.p = Nice('spam')
>>> a.b.p = E('p')

>>> def find_nice(self, ancestor, name, object, extra):
...     return hasattr(object,'isNice') and object.isNice

>>> print(a.b.c.aq_acquire('p', find_nice))
spam(Nice) and I am nice!

最后一行的过滤获取跳过了名为p的第一个属性，因为该属性不满足过滤函数中给出的条件。

在Zope中很少使用过滤获取。

从上下文中获取

通常获取允许对象从其容器中获取数据。然而，一个对象可以从不是其容器的对象中获取。

我们之前看到的许多示例都显示了使用getattr语义建立获取上下文。例如，a.b是a上下文中对b的引用。

您还可以使用__of__方法手动设置获取上下文。例如

>>> from Acquisition import Implicit
>>> class C(Implicit): pass
...
>>> a = C()
>>> b = C()
>>> a.color = "red"
>>> print(b.__of__(a).color)
red

在这种情况下，a不包含b，但它使用__of__方法将b放入b的上下文中。

以下是一个更细微的示例，展示了如何构建包含非容器对象的获取上下文

>>> from Acquisition import Implicit

>>> class C(Implicit):
...     def __init__(self, name):
...         self.name = name

>>> a = C("a")
>>> a.b = C("b")
>>> a.b.color = "red"
>>> a.x = C("x")

>>> print(a.b.x.color)
red

即使b不包含x，x也可以从b获取颜色属性。这是因为在这种情况下，尽管x不是b的容器，但它是在b的上下文中访问的。

在这里，获取上下文是由用于访问另一个对象的对象定义的。

上下文之前的包含

如果在上述示例中，假设a和b都有一个颜色属性

>>> a = C("a")
>>> a.color = "green"
>>> a.b = C("b")
>>> a.b.color = "red"
>>> a.x = C("x")

>>> print(a.b.x.color)
green

为什么a.b.x.color获取的是a的颜色而不是b的颜色？答案是对象在其上下文中从容器中获取数据，然后才从非容器中获取。

为了理解为什么，让我们用__of__方法的表达式来考虑这个示例

a.x -> x.__of__(a)

a.b -> b.__of__(a)

a.b.x -> x.__of__(a).__of__(b.__of__(a))

请注意，包装器中的属性查找是通过首先在包装对象中查找属性，然后在父对象中查找来完成的。所以上面的表达式是从左到右进行的。

这些规则的结果是，在上下文之前通过包含关系查找属性。

该规则也适用于更复杂的例子。例如，a.b.c.d.e.f.g.attribute 将首先在 g 及其所有容器中搜索属性。（容器是按照从最内层父级到最外层容器的顺序进行搜索的。）如果属性在 g 或其任何容器中未找到，则搜索将移动到 f 及其所有容器，依此类推。

其他属性和方法

您可以使用特殊的 aq_inner 方法来访问仅由包含关系包装的对象。因此，在上面的例子中，a.b.x.aq_inner 等同于 a.x。

您可以使用 aq_chain 方法来查找对象的获取上下文，如下所示

>>> [obj.name for obj in a.b.x.aq_chain]
['x', 'b', 'a']

您可以使用 aq_inContextOf 方法来查找一个对象是否在另一个对象的包含上下文中。例如

>>> a.b.aq_inContextOf(a)
True

获取模块函数

除了直接在对象上使用获取属性和方法之外，您还可以使用在 Acquisition 模块中定义的类似函数。这些函数的优势在于，在调用之前，您不需要检查对象是否有该方法或属性。

aq_acquire(object, name [, filter, extra, explicit, default, containment])

获取具有给定名称的对象。

此函数可用于显式获取，以及获取通常不会获取的名称。

该函数接受多个可选参数

filter

用于决定是否获取对象的调用对象的可调用过滤器对象。

过滤器使用五个参数进行调用

• 调用aq_acquire方法的对象

• 找到对象的对象

• 传递给aq_acquire的对象名称

• 找到的对象

• 传递给 aq_acquire 的额外参数。

如果过滤函数返回一个真值对象，则返回找到的对象，否则，获取搜索继续。

extra

作为过滤器的最后一个参数传递的额外数据。

explicit

一个标志（布尔值），指示是否应使用显式获取。默认值为 true。如果标志为 true，则获取将无论搜索获取层次结构中遇到的包装器是显式还是隐式包装器都进行。如果标志为 false，则不搜索显式包装器的父级。

此参数在您想要应用过滤器而不覆盖显式包装器时很有用。

default

如果无法获取值，则返回的默认值。

containment

一个标志，指示是否应将搜索限制在包含层次结构内。

此外，还可以作为关键字提供参数。

aq_base(object)

返回所有包装都已被移除的对象。

aq_chain(object [, containment])

返回一个包含对象及其获取父级的列表。可选参数 containment 控制是否使用包含或访问层次结构。

aq_get(object, name [, default, containment])

获取属性，名称。可以提供默认值，以及一个限制搜索到包含层次结构的标志。

aq_inner(object)

返回除最内层包装之外的所有包装都被移除的对象。

aq_parent(object)

返回对象的获取父级或如果对象未包装，则返回 None。

aq_self(object)

返回除一层包装之外的所有包装都被移除的对象，除非对象未包装，在这种情况下，返回对象。

在大多数情况下，使用这些模块函数而不是直接使用获取属性和方法更为方便。

获取与方法

支持获取的对象的 Python 方法可以使用获取的属性。当在包装有获取包装器的对象上调用 Python 方法时，将包装器作为第一个参数传递给该方法。此规则也适用于用户定义的方法类型和纯混合类中定义的 C 方法。

不幸的是，扩展基类中定义了其自己的数据结构的C方法目前无法使用获取的属性。这是因为包装对象不符合这些方法期望的数据结构。实际上，你很少会遇到这个问题。

结论

获取提供了一种强大方式，可以在对象之间动态共享信息。Zope使用获取来支持其许多关键特性，包括安全性、对象发布和DTML变量查找。获取还提供了一种优雅的解决方案，用于解决许多问题的循环引用问题。虽然获取很强大，但在你的应用程序中使用获取时应该小心。细节可能变得复杂，尤其是在从上下文获取和从包含关系获取之间的差异。

6.1 (2024-09-16)

• 添加对Python 3.13的最终支持。

6.0 (2024-05-30)

• 放弃对Python 3.7的支持。

• 在GHA上构建Windows轮子。

5.2 (2024-02-13)

• 自3.13a3起添加对Python 3.13的初步支持。

5.1 (2023-10-05)

• 添加对Python 3.12的支持。

5.0 (2023-03-24)

• 为Python 3.11构建Linux二进制轮子。

• 放弃对Python 2.7、3.5和3.6的支持。

• 自3.12a5起添加对Python 3.12的初步支持。

4.13 (2022-11-17)

• 添加在macOS上构建arm64轮子的支持。

4.12 (2022-11-03)

• 添加对最终Python 3.11版本的支持。

4.11 (2022-09-16)

• 自3.11.0rc1起添加对Python 3.11的支持。

• 在编译Linux轮子的代码时，从-Ofast切换到-O3。(#64)

4.10 (2021-12-07)

• 修复了影响带有过滤器类的aq_acquire的PURE_PYTHON版本中的错误。

• 改进接口文档。

• 添加对Python 3.10的支持。

4.9 (2021-08-19)

• 在CPython中，当需要PURE_PYTHON时不再省略编译C代码。只需在运行时评估它即可。(#53)

4.8 (2021-07-20)

• 对PURE_PYTHON版本进行了各种修复，例如使Acquired成为一个字符串（如Zope所需），避免无限__cmp__循环。（#51，#48）

• 创建aarch64轮子。

4.7 (2020-10-07)

• 添加对Python 3.8和3.9的支持。

4.6 (2019-04-24)

• 放弃对Python 3.4的支持。

• 添加对Python 3.8a3的支持。

• 添加对在由ImplicitAcquisitionWrapper包装的对象上调用bytes()的支持。（#38）

4.5 (2018-10-05)

• 使用当前API避免弃用警告。

• 添加对Python 3.7的支持。

4.4.4 (2017-11-24)

• 添加Appveyor配置来自动化Windows eggs的构建。

4.4.3 (2017-11-23)

• 修复了当C扩展在使用时可能崩溃的极少数可能性。请参阅问题21。

4.4.2 (2017-05-12)

• 修复C胶囊名称以解决导入错误。

• 确保我们的依赖项与我们对C扩展的期望相匹配。

4.4.1 (2017-05-04)

• 在Python 3.4下修复C代码，其中缺少Py_XSETREF。

4.4.0 (2017-05-04)

• 在Python 3下启用C扩展。

• 放弃对Python 3.3的支持。

4.3.0 (2017-01-20)

• 使测试与ExtensionClass 4.2.0兼容。

• 放弃对Python 2.6和3.2的支持。

• 添加对Python 3.5和3.6的支持。

4.2.2 (2015-05-19)

• 使纯Python获取对象像C实现一样协同使用超类__getattribute__方法。请参阅https://github.com/zopefoundation/Acquisition/issues/7。

• 纯Python隐式获取包装器允许包装对象使用 object.__getattribute__(self, name)。这与C实现不同，但对于与 persistent 等纯Python库的兼容性很重要。请参阅 https://github.com/zopefoundation/Acquisition/issues/9。

4.2.1 (2015-04-23)

• 在C扩展中修正了几个悬垂指针的使用，可能修复了几个解释器崩溃。请参阅 https://github.com/zopefoundation/Acquisition/issues/5。

4.2 (2015-04-04)

• 添加了对PyPy、PyPy3以及Python 3.2、3.3和3.4的支持。

4.1 (2014-12-18)

• 将对 ExtensionClass 的依赖性提升到当前版本。

4.0.3 (2014-11-02)

• 当测试在源签出之外运行时，跳过readme.rst测试。

4.0.2 (2014-11-02)

• 在发布版中包含 *.rst 文件。

4.0.1 (2014-10-30)

• 容忍Unicode属性名称（仅ASCII）。LP #143358。

• 使模块级 aq_acquire API 遵循 default 参数。LP #1387363。

• 如果从 __getitem__ 切换成功，则不要对 __iter__ 抛出属性错误。LP #1155760。

4.0 (2013-02-24)

• 已将分类器添加到项目元数据中。

4.0a1 (2011-12-13)

• 如果具有 __parent__ 指针的对象指向一个反过来又指向原始对象的包装器，则引发 RuntimeError: 在获取包装器中检测到递归。LP #623665。

• 防止在从从显式或隐式基类派生的类型中访问 __parent__ 时创建包装器。

2.13.9 (2015-02-17)

• 容忍Unicode属性名称（仅ASCII）。LP #143358。

• 使模块级 aq_acquire API 遵循 default 参数。LP #1387363。

• 如果从 __getitem__ 切换成功，则不要对 __iter__ 抛出属性错误。LP #1155760。

2.13.8 (2011-06-11)

• 修复了在64位平台上提供 explicit 参数时Acquisition包装器的aq_acquire方法的段错误。感谢LP #675064提供的解决方案提示。代码传递了一个整数而不是函数中的指针。

2.13.7 (2011-03-02)

• 修复了bug：当对象未实现 __unicode__ 时，调用 unicode(wrapped) 将调用 __str__ 并使用未包装的 self。

2.13.6 (2011-02-19)

• 将 aq_explicit 添加到 IAcquisitionWrapper。

• 修复了bug：unicode(wrapped) 没有在包装对象上调用 __unicode__ 方法。

2.13.5 (2010-09-29)

• 修复了在64位Python上Windows机器上失败的单元测试。

2.13.4 (2010-08-31)

• LP 623665：修复了Acquisition.h中的错别字。

2.13.3 (2010-04-19)

• 使用标准库中的doctest模块，不再依赖于zope.testing。

2.13.2 (2010-04-04)

• 为两个包装器类都提供 __getnewargs__ 方法，这会导致ZODB优化失败并仅使用 _p_oid 创建持久引用。这恰好是包装对象的持久oid。这使得这些对象可以正确持久化，即使它们在包装状态下传递给ZODB。

• 添加了对http://dev.plone.org/plone/ticket/10318的失败测试。这显示了AQ包装器可以使用特定的cPickle、pickle协议一和具有 inst_persistent_id 钩子的自定义Pickler类的组合进行pickle的情况。不幸的是，这正是ZODB3使用的组合。

2.13.1 (2010-02-23)

• 更新以包括ExtensionClass 2.13.0。

• 将隐式获取包装器（ImplicitAcquisitionWrapper）和显式获取包装器（ExplicitAcquisitionWrapper）的 tp_name 修复为与它们的Python可见名称匹配，从而具有正确的 __name__。

• 扩展我们扩展类型的 tp_name 以包含完全限定名称。这确保类正确设置了它们的 __module__。

2.13.0 (2010-02-14)

• 在Acquisition中添加了对方法缓存的支持。由Yoshinori K. Okuji提供的补丁。请参阅 https://bugs.launchpad.net/zope2/+bug/486182。

2.12.4 (2009-10-29)

• 修复迭代代理，使其能够传递包含在 self 中的获取包装到 __iter__ 以及 __getitem__ 中（这修复了 https://bugs.launchpad.net/zope2/+bug/360761）。

• 添加对 __getslice__ 代理的测试，包括开放式切片。

2.12.3 (2009-08-08)

• 在 Py_BuildValue 调用中增加了更多 64 位修复。

• 修复了更多 64 位问题：使用正确的整数大小进行切片操作。

2.12.2 (2009-08-02)

• 修复了 Python 2.5.x / 2.6.x 的 64 位兼容性问题。有关详细信息，请参阅 https://pythonlang.cn/dev/peps/pep-0353/。

2.12.1 (2009-04-15)

• 迭代代理更新：对于 __iter__ 的代理不应依赖于对象本身具有 __iter__，还应通过 __getitem__ 支持回退迭代（这修复了 https://bugs.launchpad.net/zope2/+bug/360761）。

2.12 (2009-01-25)

• 作为独立软件包发布。