Python的方法分辨率神秘

Question

我不明白为什么这个程序失败。

#!/usr/bin/env python 
from __future__ import division, print_function 
from future_builtins import * 
import types 
import libui as ui 
from PyQt4 import QtCore 
import sip 

p = ui.QPoint() 
q = QtCore.QPoint() 

def _q_getattr(self, attr): 
    print("get %s" % attr) 
    value = getattr(sip.wrapinstance(self.myself(), QtCore.QPoint), attr) 
    print("get2 %s returned %s" % (attr, value)) 
    return value 

p.__getattr__ = types.MethodType(_q_getattr, p) 

print(p.__getattr__('x')()) # Works! Prints "0" 
print(p.x()) # AttributeError: 'QPoint' object has no attribute 'x' 

我用Boost.Python来创建libui，它暴露了类QPoint。我还包括PyQt4，它有一个暴露的QPoint。我试图完成这两种类型之间的映射。

我检查了p是一种新风格的类，为什么__getattr__被称为p.x()？

Answer 1

这与昨天的someone else has encountered有点类似。简而言之，似乎特殊方法（如__getattr__,__str__,__repr__,__call__等）在新式实例中不可覆盖，即您只能在其类型中定义它们。

下面是我对这个问题应该有希望为您的工作解决方案的适应性：

def _q_getattr(self, attr): 
    print("get %s" % attr) 
    return getattr(self, 'x') 

def override(p, methods): 
    oldType = type(p) 
    newType = type(oldType.__name__ + "_Override", (oldType,), methods) 
    p.__class__ = newType 

override(p, { '__getattr__': _q_getattr}) 
print(p.__getattr__('x')()) # Works! Prints "0" 
print(p.x())     # Should work! 

Answer 2

我建议你不要试图揭露QPoint升压蟒。你应该能够使用boost来注册转换器到/从python，它将使用SIP api函数将QPoint从/转换为python作为sip对象。

我已经做到了，但最近还不够详细。

Answer 3

这是如何整合PyQt4的和boost :: python的一个例子

首先我们必须定义包装/解包功能来处理裸指针

long int unwrap(QObject* ptr) { 
    return reinterpret_cast<long int>(ptr); 
} 

template <typename T> 
T* wrap(long int ptr) { 
    return reinterpret_cast<T*>(ptr); 
} 

后，我们必须注册所有类别我们要集成到

class_<QObject, QObject*, boost::noncopyable>("QObject", no_init) 
    .def("unwrap", unwrap) 
    .def("wrap", make_function(wrap<QObject>, return_value_policy<return_by_value>())) 
    .staticmethod("wrap"); 

class_<QWidget, bases<QObject>, QWidget*, boost::noncopyable>("QWidget") 
    .def("wrap", make_function(wrap<QWidget>, return_value_policy<return_by_value>())) 
    .staticmethod("wrap"); 

class_<QFrame, bases<QWidget>, QFrame*, boost::noncopyable>("QFrame") 
    .def("wrap", make_function(wrap<QFrame>, return_value_policy<return_by_value>())) 
    .staticmethod("wrap"); 

class_<QLabel, bases<QFrame>, QLabel*, boost::noncopyable>("QLabel") 
    .def("wrap", make_function(wrap<QLabel>, return_value_policy<return_by_value>())) 
    .staticmethod("wrap"); 

和例如，我们有一流的，与.. QLabel工作：

class worker: public QObject { 
... 
void add_label(QLabel*); 
}; 

我们必须将这个类到Python太：现在

class_<worker, bases<QObject>, worker*, boost::noncopyable>("worker") 
     .def("add_label", &worker::add_label); 

我们一个现成的互动，在C++ - 大小做这样的事情

worker* w = new worker; 
main_namespace["worker"] = boost::ref(w); 

蟒蛇：

from PyQt4.Qt import * 
import sip 
import mylib as MyLib 

#... 

#If you are using QApplication on C++-size you don't need to create another one 

lb = QLabel("label from PyQt4!") 

lb_ptr = sip.unwrapinstance(f) 

my_lb = MyLib.QLabel.wrap(lb_ptr) 

worker.add_label(my_lb) 

在其他情况下，如果你不想把你自己的Q对象发送给PyQt4：

QLabel* lb = new QLabel("C++ label"); 
main_namespace["lb"] = boost::ref(lb); 

蟒蛇：

from PyQt4.Qt import * 
import sip 
import mylib as MyLib 

#... 

my_lb_ptr = lb.unwrap() 

qt_lb = sip.wrapinstance(my_lb_ptr, QLabel) 

，这是我真正的小帮手：

from PyQt4.Qt import * 
import sip 

def toQt(object, type): 
    ptr = object.unwrap() 
    return sip.wrapinstance(ptr, type) 

def fromQt(object, type): 
    ptr = sip.unwrapinstance(object) 
    return type.wrap(ptr)