程序博客网 > js div style

Python中的 type() 和 __class__

来源：互联网 发布：js div style 编辑：程序博客网 时间：2024/06/04 20:24

来源：http://yunyuan.github.io/python/2014/08/19/python-type-class/


最近在公司内部的问答系统上有同事问了一个问题：Python中的type()和__class__有什么差别？

  1. >>> class Foo(object):
  2.     pass
  4. >>> class Bar(object):
  5.     pass
  7. >>> class Brion(object):
  8.     pass
  10. >>> class ASML(object):
  11.     __class__ = Foo
  14.     
  15. >>> b = Bar()
  16. >>> a = ASML()

Case 1

  1. >>> b.__class__, type(b)
  2. (<class '__main__.Bar'>, <class '__main__.Bar'>)
  3. >>>
  4. >>> b.__class__ = Foo
  5. >>>
  6. >>> b.__class__, type(b)
  7. (<class '__main__.Foo'>, <class '__main__.Foo'>)

Case 2

  1. >>> a.__class__, type(a)
  2. (<class '__main__.Foo'>, <class '__main__.ASML'>)
  3. >>>
  4. >>> a.__class__ = Brion
  5. >>>
  6. >>> a.__class__, type(a)
  7. (<class '__main__.Brion'>, <class '__main__.ASML'>)

大家看出Case 1和Case 2的差别了吧。问题来了：
1. type(obj)到底做了些什么事情？
2. 为什么a在改变__class__后，type(a)还是ASML呢？

为了解决这些问题，我们需要深入Python源代码。以下源代码来自Python 2.7.8。

Python Object

Python中一切皆对象。所有对象的数据结构都以一个PyObject_HEAD开头。

object.h

  1. typedef struct _object {
  2.     PyObject_HEAD
  3. } PyObject;
  5. /* PyObject_HEAD defines the initial segment of every PyObject. */
  6. #define PyObject_HEAD                   \
  7.     _PyObject_HEAD_EXTRA                \
  8.     Py_ssize_t ob_refcnt;               \
  9.     struct _typeobject *ob_type;

这里的ob_refcnt是用来做引用计数的，而ob_type则是对象所对应的type对象。

type对象包含了很多关于对象的元信息：类型名字(tp_name)，创建该类型对象时分配内存空间大小的信息(tp_basicsize和tp_itemsize)，一些操作信息(tp_call,tp_new等)，还有其他如__mro__(tp_mro), __bases__(tp_bases)等。

object.h

  1. typedef struct _typeobject {
  2.     PyObject_VAR_HEAD
  3.     const char *tp_name; /* For printing, in format "<module>.<name>" */
  4.     Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
  6.     ...
  8.     /* More standard operations (here for binary compatibility) */
  9.     ternaryfunc tp_call;
  10.     ...
  12.     /* Attribute descriptor and subclassing stuff */
  13.     PyObject *tp_dict;
  14.     newfunc tp_new;
  15.     PyObject *tp_bases;
  16.     PyObject *tp_mro; /* method resolution order */
  17.     PyObject *tp_subclasses;
  18.     ...
  20.     ...
  22. } PyTypeObject;

对于对象f = Foo()来说，它的ob_type就是Foo, 而Foo的ob_type则是type。

type(obj)到底做了些什么事情

上面提到的每个对象都有的ob_type其实就是type(obj)返回的对象。

我们看下运行type(obj)时调用到的一系列函数。

abstract.c

  1. PyObject *
  2. PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw)
  3. {
  4.     ternaryfunc call;
  6.     if ((call = func->ob_type->tp_call) != NULL) {
  7.         PyObject *result;
  8.         if (Py_EnterRecursiveCall(" while calling a Python object"))
  9.             return NULL;
  10.         result = (*call)(func, arg, kw);
  11.         ...
  12.         return result;
  13.     }
  14.     ...
  15.     return NULL;
  16. }

这里的func是obj的ob_type，以f = Foo()为例的话就是Foo。那func->ob_type当然就是type了。

typeobject.c

  1. PyTypeObject PyType_Type = {
  2.     PyVarObject_HEAD_INIT(&PyType_Type, 0)
  3.     "type",                                     /* tp_name */
  4.     ...
  5.     (ternaryfunc)type_call,                     /* tp_call */
  6.     ...
  7.     type_new,                                   /* tp_new */
  8.     ...
  9. }

从上面PyType_Type的定义可以看到type的tp_call就是type_call函数：

typeobject.c

  1. static PyObject *
  2. type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
  3. {
  4.     PyObject *obj;
  6.     if (type->tp_new == NULL) {
  7.         PyErr_Format(PyExc_TypeError,
  8.                      "cannot create '%.100s' instances",
  9.                      type->tp_name);
  10.         return NULL;
  11.     }
  13.     obj = type->tp_new(type, args, kwds);
  14.     if (obj != NULL) {
  15.         /* Ugly exception: when the call was type(something),
  16.            don't call tp_init on the result. */
  17.         if (type == &PyType_Type &&
  18.             PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
  19.             (kwds == NULL ||
  20.              (PyDict_Check(kwds) && PyDict_Size(kwds) == 0)))
  21.             return obj;                         // Yun: type(obj) returns from here
  22.         /* If the returned object is not an instance of type,
  23.            it won't be initialized. */
  24.         if (!PyType_IsSubtype(obj->ob_type, type))
  25.             return obj;
  26.         type = obj->ob_type;
  27.         if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_CLASS) &&
  28.             type->tp_init != NULL &&
  29.             type->tp_init(obj, args, kwds) < 0) {
  30.             Py_DECREF(obj);
  31.             obj = NULL;
  32.         }
  33.     }
  34.     return obj;                              // Yun: type(cls, bases, dict) returns from here

type_call中先调用tp_new指向的函数(type_new)，然后再做分支。对type(obj)调用来说就是直接返回tp_new得到的对象。而对type(cls, bases, dict)来说还会调用tp_init指向的函数，这在自定义metaclass时会用到。

typeobject.c

  1. static PyObject *
  2. type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
  3. {
  4.     ...
  6.     /* Special case: type(x) should return x->ob_type */
  7.     {
  8.         const Py_ssize_t nargs = PyTuple_GET_SIZE(args);
  9.         const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_Size(kwds);
  11.         if (PyType_CheckExact(metatype) && nargs == 1 && nkwds == 0) {
  12.             PyObject *x = PyTuple_GET_ITEM(args, 0);
  13.             Py_INCREF(Py_TYPE(x));
  14.             return (PyObject *) Py_TYPE(x);
  15.         }
  17.         ...
  18.     }
  20.     ...
  21. }

object.h

  1. #define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)

可见type(obj)其实就是返回对象的ob_type。

为什么a在改变__class__后，type(a)还是ASML呢

要回答这个问题，我们要先回顾下通过obj.xxx查找对象的 attribute 时的搜索顺序：
1. type对象及其基类的__dict__。如果是 data descriptor，返回这个 data descriptor的 __get__ 结果
2. obj的__dict__
3. 第一步中找到的如果是 non-data descriptor， 返回这个 non-data descriptor的 __get__ 结果
4. type对象中的__dict__，也就是直接返回第一步中找到的对象

obj.__class__就是一个 attribute 查找。

typeobject.c

  1. static PyGetSetDef object_getsets[] = {
  2.     {"__class__", object_get_class, object_set_class,
  3.      PyDoc_STR("the object's class")},
  4.     {0}
  5. };
  7. PyTypeObject PyBaseObject_Type = {
  8.     PyVarObject_HEAD_INIT(&PyType_Type, 0)
  9.     "object",                                   /* tp_name */
  10.     ...
  11.     PyObject_GenericGetAttr,                    /* tp_getattro */
  12.     PyObject_GenericSetAttr,                    /* tp_setattro */
  13.     ...
  14.     object_getsets,                             /* tp_getset */
  15.     ...
  16. };

来看下f = Foo(); f.__class__;中的函数调用链：

object.c

  1. PyObject *
  2. PyObject_GetAttr(PyObject *v, PyObject *name)
  3. {
  4.     PyTypeObject *tp = Py_TYPE(v);
  6.     ...
  8.     if (tp->tp_getattro != NULL)
  9.         return (*tp->tp_getattro)(v, name);
  11.     ...
  12.     return NULL;
  13. }

这里的v就是f, 而tp就是Foo, tp->tp_getattro就是PyObject_GenericGetAttr函数。

object.c

  1. PyObject *
  2. PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
  3. {
  4.     return _PyObject_GenericGetAttrWithDict(obj, name, NULL);
  5. }
  7. PyObject *
  8. _PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name, PyObject *dict)
  9. {
  10.     PyTypeObject *tp = Py_TYPE(obj);
  11.     PyObject *descr = NULL;
  12.     PyObject *res = NULL;
  13.     
  14.     ...
  15.     descr = _PyType_Lookup(tp, name);
  17.     Py_XINCREF(descr);
  19.     f = NULL;
  20.     if (descr != NULL &&
  21.         PyType_HasFeature(descr->ob_type, Py_TPFLAGS_HAVE_CLASS)) {
  22.         f = descr->ob_type->tp_descr_get;
  23.         if (f != NULL && PyDescr_IsData(descr)) {
  24.             res = f(descr, obj, (PyObject *)obj->ob_type);
  25.             Py_DECREF(descr);
  26.             goto done;
  27.         }
  28.     }
  30.     ...
  31.     return res;
  32. }
  34. PyObject *
  35. _PyType_Lookup(PyTypeObject *type, PyObject *name)
  36. {
  37.     Py_ssize_t i, n;
  38.     PyObject *mro, *res, *base, *dict;
  39.     unsigned int h;
  41.     ...
  43.     /* Look in tp_dict of types in MRO */
  44.     mro = type->tp_mro;
  46.     ...
  48.     res = NULL;
  49.     assert(PyTuple_Check(mro));
  50.     n = PyTuple_GET_SIZE(mro);
  51.     for (i = 0; i < n; i++) {
  52.         base = PyTuple_GET_ITEM(mro, i);
  53.         if (PyClass_Check(base))
  54.             dict = ((PyClassObject *)base)->cl_dict;
  55.         else {
  56.             assert(PyType_Check(base));
  57.             dict = ((PyTypeObject *)base)->tp_dict;
  58.         }
  59.         assert(dict && PyDict_Check(dict));
  60.         res = PyDict_GetItem(dict, name);
  61.         if (res != NULL)
  62.             break;
  63.     }
  65.     ...
  66.     return res;
  67. }

_PyObject_GenericGetAttrWithDict中先调用_PyType_Lookup从Foo的tp_mro中查到__class__属性(来自Foo的基类object)，该属性是一个data descriptor，最终调用了object_get_class。

typeobject.c

  1. static PyObject *
  2. object_get_class(PyObject *self, void *closure)
  3. {
  4.     Py_INCREF(Py_TYPE(self));
  5.     return (PyObject *)(Py_TYPE(self));
  6. }

从object_get_class函数可以看出，对于f = Foo(); f.__class__;来说也是返回的Foo对象的ob_type。这就解释了Case 1中为什么type(b)和b.__class__是相等的。___

那为什么Case 2中的type(a)和a.__class__不相等呢？

因为Case 1中没有自定义__class__，所以查找__class__时在Bar中没找到，接着就去Bar的基类object中找，正好object中定义了一个__class__的 data descriptor, 就返回这个。

而在Case 2中我们自定义了__class__，所以在ASML.__dict__中找到有这个 attribute 后就返回了，不会再去找mro中的下一个(object)。但是这里找到的这个 attribute 不是 data descriptor，根据前面提到的 attribute 搜索顺序，我们接着在a.__dict__中找，也没有，那就直接返回ASML中的找到的那个了。___

为什么设置__class__后，Case 1和Case 2有差别

obj.xxx = yyy 设置attribute时的顺序
1. 先从type对象及其基类的__dict__中查找该 attribute，找到就返回。如果找到的是 data descriptor，则用该 data descriptor的__set__来设置
2. 否则添加到obj.__dict__里

Case 1中得到的__class__是一个 data descriptor，给它赋值实际上调用的是object_set_class函数。

typeobject.c

  1. static int
  2. object_set_class(PyObject *self, PyObject *value, void *closure)
  3. {
  4.     PyTypeObject *oldto = Py_TYPE(self);
  5.     PyTypeObject *newto;
  7.     ...
  8.     newto = (PyTypeObject *)value;
  9.     ...
  10.     if (compatible_for_assignment(newto, oldto, "__class__")) {
  11.         Py_INCREF(newto);
  12.         Py_TYPE(self) = newto;
  13.         Py_DECREF(oldto);
  14.         return 0;
  15.     }
  16.     else {
  17.         return -1;
  18.     }
  19. }

从该函数的实现可以看到b.__class__ = Foo实际上会把b的ob_type设为Foo。所以赋值后type(b)和b.__class__都跟着变了。

  1. >>> b.__dict__
  2. {}
  3. >>> Bar.__dict__
  4. dict_proxy({'__dict__': <attribute '__dict__' of 'Bar' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Bar' objects>, '__doc__': None})
  5. >>>
  6. >>> b.__class__ = Foo
  7. >>>
  8. >>> b.__class__, type(b)
  9. (<class '__main__.Foo'>, <class '__main__.Foo'>)
  10. >>> b.__dict__
  11. {}
  12. >>> Bar.__dict__
  13. dict_proxy({'__dict__': <attribute '__dict__' of 'Bar' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Bar' objects>, '__doc__': None})

而Case 2中得到的__class__不是 data descriptor。所以a.__class__ = Foo会在a.__dict__中添加一条记录，而a的ob_type不会变，ASML.__dict__也不会变。

  1. >>> a.__dict__
  2. {}
  3. >>> ASML.__dict__
  4. dict_proxy({'__dict__': <attribute '__dict__' of 'ASML' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'ASML' objects>, '__class__': <class '__main__.Foo'>, '__doc__': None})
  5. >>>
  6. >>> a.__class__ = Brion
  7. >>>
  8. >>> a.__dict__
  9. {'__class__': <class '__main__.Brion'>}
  10. >>> ASML.__dict__
  11. dict_proxy({'__dict__': <attribute '__dict__' of 'ASML' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'ASML' objects>, '__class__': <class '__main__.Foo'>, '__doc__': None})

以上的讨论都是基于new style class。对于old style class来说,type()不等于__class__:

  1. >>> class A():
  2.     pass
  4. >>> a = A()
  5. >>> a.__class__, type(a)
  6. (<class __main__.A at 0x0270CFB8>, <type 'instance'>)

另外一个关于 isintance(obj, cls) 的问题

  1. >>> class Foo(object):
  2.     pass
  3.     
  4. >>> class ASML(object):
  5.     __class__ = Foo
  6.     
  7. >>> a = ASML()
  8. >>> isinstance(a, Foo)
  9. True
  10. >>> isinstance(a, ASML)
  11. True

为什么这里的两个isinstance都返回True呢？

object.h

  1. #define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
  3. #bltinmodule.c
  4. static PyMethodDef builtin_methods[] = {
  5.     ...
  6.     {"isinstance",  builtin_isinstance, METH_VARARGS, isinstance_doc},
  7.     ...
  8. }
  10. static PyObject *
  11. builtin_isinstance(PyObject *self, PyObject *args)
  12. {
  13.     PyObject *inst;
  14.     PyObject *cls;
  15.     int retval;
  17.     if (!PyArg_UnpackTuple(args, "isinstance", 2, 2, &inst, &cls))
  18.         return NULL;
  20.     retval = PyObject_IsInstance(inst, cls);
  21.     if (retval < 0)
  22.         return NULL;
  23.     return PyBool_FromLong(retval);
  24. }

最终isinstance(obj, cls)会调用PyObject_IsInstance。

abstract.c

  1. int
  2. PyObject_IsInstance(PyObject *inst, PyObject *cls) // Yun: "isinstance(obj, cls)" will call it
  3. {
  4.     static PyObject *name = NULL;
  6.     /* Quick test for an exact match */
  7.     if (Py_TYPE(inst) == (PyTypeObject *)cls)      // Yun: "isinstacne(b, ASML)" returns True
  8.         return 1;
  10.     ...
  11.     if (!(PyClass_Check(cls) || PyInstance_Check(cls))) {
  12.         PyObject *checker;
  13.         checker = _PyObject_LookupSpecial(cls, "__instancecheck__", &name);
  14.         ...
  15.         res = PyObject_CallFunctionObjArgs(checker, inst, NULL);  // Yun: "isinstance(b, Foo)" call recursive_isinstance() and returns True
  16.         if (res != NULL) {
  17.             ok = PyObject_IsTrue(res);
  18.             ...
  19.         }
  20.         return ok;
  21.     }
  22.     return recursive_isinstance(inst, cls);        
  23. }
  25. static int
  26. recursive_isinstance(PyObject *inst, PyObject *cls)
  27. {
  28.     ...
  29.     static PyObject *__class__ = NULL;
  30.     int retval = 0;
  31.     if (__class__ == NULL) {
  32.         __class__ = PyString_InternFromString("__class__");
  33.         if (__class__ == NULL)
  34.             return -1;
  35.     }
  36.     ...
  38.     if (PyClass_Check(cls) && PyInstance_Check(inst)) {
  39.         ...
  40.     }
  41.     else if (PyType_Check(cls)) {
  42.         retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
  43.         if (retval == 0) {
  44.             PyObject *c = PyObject_GetAttr(inst, __class__);
  45.             ...
  46.             retval = PyType_IsSubtype(
  47.                     (PyTypeObject *)c,
  48.                     (PyTypeObject *)cls);      // Yun: Both "c" and "cls" are "Foo" here
  49.     }
  50.     ...
  52.     return retval;
  53. }

从__instancecheck__ 到 recursive_isinstance:

typeobject.c

  1. static PyMethodDef type_methods[] = {
  2.     {"mro", (PyCFunction)mro_external, METH_NOARGS,
  3.      PyDoc_STR("mro() -> list\nreturn a type's method resolution order")},
  4.     {"__subclasses__", (PyCFunction)type_subclasses, METH_NOARGS,
  5.      PyDoc_STR("__subclasses__() -> list of immediate subclasses")},
  6.     {"__instancecheck__", type___instancecheck__, METH_O,
  7.      PyDoc_STR("__instancecheck__() -> bool\ncheck if an object is an instance")},
  8.     {"__subclasscheck__", type___subclasscheck__, METH_O,
  9.      PyDoc_STR("__subclasscheck__() -> bool\ncheck if a class is a subclass")},
  10.     {0}
  11. };
  13. static PyObject *
  14. type___instancecheck__(PyObject *type, PyObject *inst)
  15. {
  16.     switch (_PyObject_RealIsInstance(inst, type)) {
  17.     case -1:
  18.         return NULL;
  19.     case 0:
  20.         Py_RETURN_FALSE;
  21.     default:
  22.         Py_RETURN_TRUE;
  23.     }
  24. }
  26. int
  27. _PyObject_RealIsInstance(PyObject *inst, PyObject *cls)
  28. {
  29.     return recursive_isinstance(inst, cls);
  30. }

简单来说就是isinstance(obj, cls)会先看ob_type，然后在看__class__。

0 0
js div style js div style
原创粉丝点击
热门IT博客
淘宝清仓和天天特价淘宝清仓和天天特价
手机淘宝怎么搜索达人手机淘宝怎么搜索达人
网络兼职打字日赚100
淘宝网手机版客户端
s7200模拟量ao编程
sql 查询前10条数据
淘宝年费
服装面料 知乎
u盘扩容软件
网易公开课视频 大数据
黄金时时彩软件下载
mac nginx lua
js给input的属性赋值
中控考勤机数据导入
淘宝客的原理
mac重启后壁纸还原
电商补货量算法
2015淘宝网销量排行榜
凤凰卫士加密软件
手机淘宝怎么撤销退款
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 10篇200字语文曰记 曰字 小学生二年级曰记50字 曰期和时间下载到桌面 华能集团招聘2019招聘截止曰期 曰立念什么 曰立空调 曰立中央空调 曱 曱由 曱怎么读 曱状腺结节是怎么回事 曱亢是什么原因造成的 曱钴胺片的作用与功效 曱亢 甲亢能引起什么病 什么引起甲亢 甲亢会引发什么病 甲坑 得了甲亢严重吗 甲减与甲亢 甲亢的药 甲亢跟甲减有什么区别 甲亢大脖子 轻微甲亢 甲亢是不是大脖子病 什么是亚临床甲亢 甲亢脖子 原发性甲亢是指 那曲 曲到 曲部 塞上曲 曲小蛐 曲相思 曲组词 阿果吉曲故事 阿果吉曲的故事 采莲曲 曲部首 一曲红尘

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里