如何在python中找到几种类型的最新共同祖先（基本类型）？

Question

我需要找到一组类的最后一个共同祖先，以便返回该类型。

上下文，我正在做一些相当复杂的元编程，涉及重载 numpy 功能。 （不要问）我有一个函数的可变数量的参数，我使用这些信息提取到一个集合中的类型（过滤掉一些不相关的类型）我需要找出最远的类型树其中所有类型共享相同的基本类型。我有一些第一次尝试，但我被多重继承等绊倒了。

第一关：

def lca_type(types):
    if len(types) == 1:
        return types.pop()
    filtered_types = set()
    for type in types:
        if not any(issubclass(type, x) for x in types):
            filtered_types.add(type)
    if len(filtered_types) == 1:
        return filtered_types.pop()
    # TODO: things get tricky here

考虑以下类层次结构：

class A(object):
    pass
class B(A):
    pass
class C(A):
    pass
class D(A):
    pass
class B1(B):
    pass
class B2(B):
    pass
class BC(C, B1):
    pass
class CD(C, D):
    pass
class D1(D):
    pass
class BD(B, D):
    pass
class B1_1(B1):
    pass

预期结果：

lca_type({A,BD}) == A
lca_type({C}) == C
lca_type({B1,B2}) == B
lca_type({{B1_1, D}) == A
lca_type({CD, BD}) == D
lca_type({B1_1, BC}) == B1

Answer 1

您可以使用每个类的mro 方法来获取祖先类的列表。将祖先列表映射到collections.Counter，这样您就可以在它们上使用& 运算符来获取共同祖先，同时保持键顺序，有效模拟获取有序集合的交集。然后从聚合的Counter对象的键中对祖先序列使用next函数来获取最近的祖先：

from functools import reduce
from operator import and_
from collections import Counter

def lca_type(classes):
    return next(iter(reduce(and_, (Counter(cls.mro()) for cls in classes))))

所以下面的表达式都是True:

lca_type({A, BD}) == A
lca_type({C}) == C
lca_type({B1, B2}) == B
lca_type({B1_1, D}) == A
lca_type({CD, BD}) == D
lca_type({B1_1, BC}) == B1
lca_type({B1_1, BC, BD}) == B

请注意，键顺序仅针对 Python 3.7+ 维护，因此对于以前的 Python 版本，您可以将 Counter 替换为 collections.OrderedDict 的子类，该子类重用 Counter 的属性：

from functools import reduce
from operator import and_
from collections import Counter, OrderedDict
import collections

collections.Counter = Counter = type('Counter', (OrderedDict,), dict(vars(Counter)))

def lca_type(classes):
    return next(iter(reduce(and_, (Counter(cls.mro()) for cls in classes))))

Answer 2

获取所有共同祖先的集合，使用朴素的最小算法找到最低的共同祖先，然后验证它实际上是最近的：

def lca_type(types):
    mros = [t.__mro__ for t in types]
    all_common_ancestors = set(mros[0]).intersection(*mros[1:])

    ancestor_iter = iter(all_common_ancestors)
    candidate = next(ancestor_iter)
    for next_candidate in ancestor_iter:
        if issubclass(next_candidate, candidate):
            candidate = next_candidate

    if all(issubclass(candidate, ancestor) for ancestor in all_common_ancestors):
        return candidate
    else:
        raise ValueError("No unambiguous lowest common ancestor")

使用简单的最小值可能看起来有问题，但实际上它很好，即使在多重继承中也是如此。如果有一个明确的最低共同祖先，那么它是all_common_ancestors 的每个元素（包括它自己）的子类，所以当我们到达它时，我们会将candidate 设置为最低共同祖先，然后再也不会改变candidate .如果没有明确的最低共同祖先，那么无论 candidate 在循环结束时结束，它都不会通过验证检查。

更棘手的部分是处理__subclasscheck__/__subclasshook__ 覆盖。我认为这个实现应该足够健壮，可以处理大多数常见的ABC案例，但是当任意__subclasscheck__实现定义图形时，最低共同祖先的整个概念变得很奇怪issubclass 甚至不是 DAG。