Python：如何调用super（）方法？ 我有一个模块，其中两个C++类被暴露，它们都有一个方法：代码>代码（）：< /p>：

现在我想调用

d.foo（）

调用

MyClassA.foo（）

以及

MyClassB.foo（）

。但是，

Derived.mro（）

看起来不错：

[<class '__main__.Derived'>, <class 'my_module.MyClassA'>, <class 'my_module.MyClassB'>, <class 'Boost.Python.instance'>, <class 'object'>]

[，]

。。只调用

MyClassA.foo（）

---

<>如何使C++方法调用它们的代码>超级（）/<代码>方法？这对Sy-IntIsx（）/Cuth>是否有效？

< P> C++层没有直接访问MRO信息Python，用于通过代码>超/代码>来自动调用超类调用。如果您对Python的C++知识进行了C++代码的污染，您可以直接创建一个对象：“代码> pySuffyType （必须调用两个参数；不启用ARG <代码>超级< /代码>的魔法是不可用的），使用Python代码和C++代码，这将严重地变得丑陋。

在实践中，使用Boosi.Python的最佳建议可能是（C++ 11专用的头文件工具，它不依赖于整个Boost生态系统，也有类似的用途），推荐的方法是显式调用C++级父类方法，而不是通过<代码>超级< /C> >隐式地调用。简单地没有合理的方法将C++和Python方法合并到多重继承中，这不会导致用Python特定代码毫无意义地污染非Python代码。code>pybind11的方法是：

class Derived(MyClassA, MyClassB):
    # Must define __init__ even though you only defer to parent classes,
    # or only MyClassA will be created
    def __init__(self):
        MyClassA.__init__(self)
        MyClassB.__init__(self)
    def foo(self):
        MyClassA.foo(self)
        MyClassB.foo(self)

---

C++层没有直接访问MRO信息Python，用于通过代码>超/代码>自动实现超类调用。如果您对Python的C++知识进行了C++代码的污染，您可以直接创建一个对象：“代码> pySuffyType （必须调用两个参数；不启用ARG <代码>超级< /代码>的魔法是不可用的），使用Python代码和C++代码，这将严重地变得丑陋。

在实践中，使用Boosi.Python的最佳建议可能是（C++ 11专用的头文件工具，它不依赖于整个Boost生态系统，也有类似的用途），推荐的方法是显式调用C++级父类方法，而不是通过<代码>超级< /C> >隐式地调用。简单地没有合理的方法将C++和Python方法合并到多重继承中，这不会导致用Python特定代码毫无意义地污染非Python代码。code>pybind11的方法是：

class Derived(MyClassA, MyClassB):
    # Must define __init__ even though you only defer to parent classes,
    # or only MyClassA will be created
    def __init__(self):
        MyClassA.__init__(self)
        MyClassB.__init__(self)
    def foo(self):
        MyClassA.foo(self)
        MyClassB.foo(self)

我目前的方法（改编自answer）需要某种包装器来手动处理

super（）

-调用。生成的类不再需要任何特殊处理：

C++代码：

struct MyClassA{
    void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};

struct MyClassB{
    void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};

BOOST_PYTHON_MODULE(my_module){
    class_<MyClassA>("MyClassACpp", init<>()).def("foo", &MyClassA::foo);
    class_<MyClassB>("MyClassBCpp", init<>()).def("foo", &MyClassB::foo);
}

from my_module import MyClassACpp, MyClassBCpp

def call_super(cls, instance, method, *args):
    mro = instance.__class__.mro()
    for next_class in mro[mro.index(cls) + 1:]:
        if not hasattr(next_class, method):
            continue
        if next_class.__module__ in {'Boost.Python', 'builtins'}:
            continue
        getattr(next_class, method)(instance, *args)
        if next_class.__module__ != 'my_module':
            break

class MyClassA(MyClassACpp):
    def __init__(self):
        call_super(MyClassA, self, '__init__')
        print('MyClassA.__init__()')

    def foo(self):
        call_super(MyClassA, self, 'foo')

class MyClassB(MyClassBCpp):
    def __init__(self):
        call_super(MyClassB, self, '__init__')
        print('MyClassB.__init__()')

    def foo(self):
        call_super(MyClassB, self, 'foo')

class Derived(MyClassA, MyClassB):
    def foo(self):
        super().foo()

d = Derived()
d.foo()

MyClassA.__init__()
MyClassB.__init__()
MyClassA::foo()
MyClassB::foo()

用法：

struct MyClassA{
    void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};

struct MyClassB{
    void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};

BOOST_PYTHON_MODULE(my_module){
    class_<MyClassA>("MyClassACpp", init<>()).def("foo", &MyClassA::foo);
    class_<MyClassB>("MyClassBCpp", init<>()).def("foo", &MyClassB::foo);
}

from my_module import MyClassACpp, MyClassBCpp

def call_super(cls, instance, method, *args):
    mro = instance.__class__.mro()
    for next_class in mro[mro.index(cls) + 1:]:
        if not hasattr(next_class, method):
            continue
        if next_class.__module__ in {'Boost.Python', 'builtins'}:
            continue
        getattr(next_class, method)(instance, *args)
        if next_class.__module__ != 'my_module':
            break

class MyClassA(MyClassACpp):
    def __init__(self):
        call_super(MyClassA, self, '__init__')
        print('MyClassA.__init__()')

    def foo(self):
        call_super(MyClassA, self, 'foo')

class MyClassB(MyClassBCpp):
    def __init__(self):
        call_super(MyClassB, self, '__init__')
        print('MyClassB.__init__()')

    def foo(self):
        call_super(MyClassB, self, 'foo')

class Derived(MyClassA, MyClassB):
    def foo(self):
        super().foo()

d = Derived()
d.foo()

MyClassA.__init__()
MyClassB.__init__()
MyClassA::foo()
MyClassB::foo()

输出：

struct MyClassA{
    void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};

struct MyClassB{
    void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};

BOOST_PYTHON_MODULE(my_module){
    class_<MyClassA>("MyClassACpp", init<>()).def("foo", &MyClassA::foo);
    class_<MyClassB>("MyClassBCpp", init<>()).def("foo", &MyClassB::foo);
}

from my_module import MyClassACpp, MyClassBCpp

def call_super(cls, instance, method, *args):
    mro = instance.__class__.mro()
    for next_class in mro[mro.index(cls) + 1:]:
        if not hasattr(next_class, method):
            continue
        if next_class.__module__ in {'Boost.Python', 'builtins'}:
            continue
        getattr(next_class, method)(instance, *args)
        if next_class.__module__ != 'my_module':
            break

class MyClassA(MyClassACpp):
    def __init__(self):
        call_super(MyClassA, self, '__init__')
        print('MyClassA.__init__()')

    def foo(self):
        call_super(MyClassA, self, 'foo')

class MyClassB(MyClassBCpp):
    def __init__(self):
        call_super(MyClassB, self, '__init__')
        print('MyClassB.__init__()')

    def foo(self):
        call_super(MyClassB, self, 'foo')

class Derived(MyClassA, MyClassB):
    def foo(self):
        super().foo()

d = Derived()
d.foo()

MyClassA.__init__()
MyClassB.__init__()
MyClassA::foo()
MyClassB::foo()

我目前的方法（改编自answer）需要某种包装器来手动处理

super（）

-调用。生成的类不再需要任何特殊处理：

C++代码：

struct MyClassA{
    void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};

struct MyClassB{
    void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};

BOOST_PYTHON_MODULE(my_module){
    class_<MyClassA>("MyClassACpp", init<>()).def("foo", &MyClassA::foo);
    class_<MyClassB>("MyClassBCpp", init<>()).def("foo", &MyClassB::foo);
}

from my_module import MyClassACpp, MyClassBCpp

def call_super(cls, instance, method, *args):
    mro = instance.__class__.mro()
    for next_class in mro[mro.index(cls) + 1:]:
        if not hasattr(next_class, method):
            continue
        if next_class.__module__ in {'Boost.Python', 'builtins'}:
            continue
        getattr(next_class, method)(instance, *args)
        if next_class.__module__ != 'my_module':
            break

class MyClassA(MyClassACpp):
    def __init__(self):
        call_super(MyClassA, self, '__init__')
        print('MyClassA.__init__()')

    def foo(self):
        call_super(MyClassA, self, 'foo')

class MyClassB(MyClassBCpp):
    def __init__(self):
        call_super(MyClassB, self, '__init__')
        print('MyClassB.__init__()')

    def foo(self):
        call_super(MyClassB, self, 'foo')

class Derived(MyClassA, MyClassB):
    def foo(self):
        super().foo()

d = Derived()
d.foo()

MyClassA.__init__()
MyClassB.__init__()
MyClassA::foo()
MyClassB::foo()

用法：

struct MyClassA{
    void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};

struct MyClassB{
    void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};

BOOST_PYTHON_MODULE(my_module){
    class_<MyClassA>("MyClassACpp", init<>()).def("foo", &MyClassA::foo);
    class_<MyClassB>("MyClassBCpp", init<>()).def("foo", &MyClassB::foo);
}

from my_module import MyClassACpp, MyClassBCpp

def call_super(cls, instance, method, *args):
    mro = instance.__class__.mro()
    for next_class in mro[mro.index(cls) + 1:]:
        if not hasattr(next_class, method):
            continue
        if next_class.__module__ in {'Boost.Python', 'builtins'}:
            continue
        getattr(next_class, method)(instance, *args)
        if next_class.__module__ != 'my_module':
            break

class MyClassA(MyClassACpp):
    def __init__(self):
        call_super(MyClassA, self, '__init__')
        print('MyClassA.__init__()')

    def foo(self):
        call_super(MyClassA, self, 'foo')

class MyClassB(MyClassBCpp):
    def __init__(self):
        call_super(MyClassB, self, '__init__')
        print('MyClassB.__init__()')

    def foo(self):
        call_super(MyClassB, self, 'foo')

class Derived(MyClassA, MyClassB):
    def foo(self):
        super().foo()

d = Derived()
d.foo()

MyClassA.__init__()
MyClassB.__init__()
MyClassA::foo()
MyClassB::foo()

输出：

struct MyClassA{
    void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};

struct MyClassB{
    void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};

BOOST_PYTHON_MODULE(my_module){
    class_<MyClassA>("MyClassACpp", init<>()).def("foo", &MyClassA::foo);
    class_<MyClassB>("MyClassBCpp", init<>()).def("foo", &MyClassB::foo);
}

from my_module import MyClassACpp, MyClassBCpp

def call_super(cls, instance, method, *args):
    mro = instance.__class__.mro()
    for next_class in mro[mro.index(cls) + 1:]:
        if not hasattr(next_class, method):
            continue
        if next_class.__module__ in {'Boost.Python', 'builtins'}:
            continue
        getattr(next_class, method)(instance, *args)
        if next_class.__module__ != 'my_module':
            break

class MyClassA(MyClassACpp):
    def __init__(self):
        call_super(MyClassA, self, '__init__')
        print('MyClassA.__init__()')

    def foo(self):
        call_super(MyClassA, self, 'foo')

class MyClassB(MyClassBCpp):
    def __init__(self):
        call_super(MyClassB, self, '__init__')
        print('MyClassB.__init__()')

    def foo(self):
        call_super(MyClassB, self, 'foo')

class Derived(MyClassA, MyClassB):
    def foo(self):
        super().foo()

d = Derived()
d.foo()

MyClassA.__init__()
MyClassB.__init__()
MyClassA::foo()
MyClassB::foo()