首頁 > 後端開發 > Python教學 > Python物件是怎麼被呼叫的

Python物件是怎麼被呼叫的

WBOY
發布: 2023-05-31 11:39:11
轉載
1075 人瀏覽過

楔子

我們了解到,創建物件的主要方法有兩種:一種是透過Python/C API,而另一種則是透過呼叫類型物件。對於內建類型的實例物件而言,這兩種方式都是支援的,例如列表,我們即可以透過[]創建,也可以透過list(),前者是Python/C API,後者是呼叫類型物件。

建立自訂類別的實例物件只能透過呼叫該類別的類型物件。如果一個物件可以進行調用,那麼該物件就是可調用的,否則不可調用。

一個物件是否可呼叫取決於其對應的類型物件是否定義了特定的方法。如果從 Python 的角度看的話,這個方法就是 __call__,從解釋器角度看的話,這個方法就是 tp_call。

從Python 的角度看物件的呼叫

呼叫int、str、tuple 可以建立一個整數、字串、元組,呼叫自訂的類別也可以建立出對應的實例對象,說明類型物件是可呼叫的,也就是callable。那麼這些類型物件(int、str、tuple、class等等)的類型物件(type)內部一定有 __call__ 方法。

# int可以调用
# 那么它的类型对象、也就是元类(type), 内部一定有__call__方法
print(hasattr(type, "__call__"))# True
# 而调用一个对象,等价于调用其类型对象的 __call__ 方法
# 所以 int(3.14)实际就等价于如下
print(type.__call__(int, 3.14))# 3
登入後複製

注意:這裡描述的可能有一些繞,我們說int、str、float 這些都是類型物件(簡單來說就是類別),而123、"你好"、3.14 是其對應的實例對象,這些都沒問題。但type是不是類型對象,顯然是的,雖然我們稱呼它為元類,但它也是類型對象,如果 print(type) 顯示的也是一個類別。

那麼相對 type 而言,int、str、float 是不是又變成了實例物件呢?因為它們的類型是 type。

所以class 具有二象性:

  • #如果站在實例物件(如:123、"satori"、[]、3.14)的角度上,它是型別物件

  • 如果站在type 的角度上,它是實例物件

##同理type的型別是也是type,那麼type 既是type 的型別對象,type 也是type 的實例對象。雖然描述有些複雜,但應該不難理解。為避免後續描述產生歧義,此處做出宣告:


  • 整數、浮點數、字串等等,我們稱之為實例物件


  • #int、float、str、dict,以及我們自訂的類,我們稱之為類型物件


  • ##type 雖然也是類型對象,但我們稱它為元類別

  • 所以type 的內部有__call__ 方法,那麼說明類型物件都是可呼叫的,因為呼叫類型物件就是呼叫type 的__call__ 方法。而實例物件能否呼叫就不一定了,這取決於它的類型物件中是否定義了 __call__ 方法,因為呼叫一個對象,本質上是執行其類型物件內部的 __call__ 方法。
class A:
 pass
a = A()
# 因为我们自定义的类 A 里面没有 __call__
# 所以 a 是不可以被调用的
try:
 a()
except Exception as e:
 # 告诉我们 A 的实例对象不可以被调用
 print(e)# 'A' object is not callable
# 如果我们给 A 设置了一个 __call__
type.__setattr__(A, "__call__", lambda self: "这是__call__")
# 发现可以调用了
print(a())# 这是__call__
登入後複製

我們看到這就是動態語言的特性,即便在類別創建完畢之後,依舊可以透過type進行動態設置,而這在靜態語言中是不支援的。所以type是所有類別的元類,它控制了我們自訂類別的生成過程,type這個古老又強大的類別可以讓我們玩出很多新花樣。


由於內建類別是在底層靜態定義的,因此無法使用type動態新增、刪除或修改屬性。因為從原始碼我們看到,這些內建的類別、包括元類,它們都是PyTypeObject對象,在底層已經被宣告為全域變數了,或者說它們已經作為靜態類別存在了。儘管type是所有類型物件的元類,但它只有在處理我們自訂的類別時才能進行增刪改操作。


而且我們也解釋過,Python 的動態性是解釋器將字節碼翻譯成C 程式碼的時候動態賦予的,因此給類動態設定屬性或方法只適用於動態類,也就是在py 檔案中使用class 關鍵字定義的類別。


而對於靜態類別、或編寫擴充模組時定義的擴充類別(兩者是等價的),它們在編譯之後已經是指向C 一級的資料結構了,不需要再被解釋者解釋了,因此解釋器自然也就無法在它們身上動手腳,畢竟彪悍的人生不需要解釋。

try:
 type.__setattr__(dict, "__call__", lambda self: "这是__call__")
except Exception as e:
 print(e)# can't set attributes of built-in/extension type 'dict'
登入後複製

我們看到拋異常了,提示我們不可以為內建/擴充類型dict設定屬性,因為它們繞過了解釋器解釋執行這一步,所以其屬性不能被動態設定。


同理其實例物件也是如此,靜態類別的實例物件也不可以動態設定屬性:

class Girl:
 pass
g = Girl()
g.name = "古明地觉"
# 实例对象我们也可以手动设置属性
print(g.name)# 古明地觉
lst = list()
try:
 lst.name = "古明地觉"
except Exception as e:
 # 但是内置类型的实例对象是不可以的
 print(e)# 'list' object has no attribute 'name'
登入後複製

可能有人奇怪了,為什麼列表不行?答案是內建類型的實例物件沒有__dict__屬性字典,因為相關屬性或方法底層已經定義好了,不可以動態新增。當我們為自訂類別設定了__slots__屬性時,它將和內建類別擁有相同的效果。


當然了,我們後面會介紹如何透過動態修改解釋器來改變這一點,舉個栗子,不是說靜態類別無法動態設定屬性嗎?下面我就來打自己臉:

import gc
try:
 type.__setattr__(list, "ping", "pong")
except TypeError as e:
 print(e)# can't set attributes of built-in/extension type 'list'
# 我们看到无法设置,那么我们就来改变这一点
attrs = gc.get_referents(tuple.__dict__)[0]
attrs["ping"] = "pong"
print(().ping)# pong
attrs["append"] = lambda self, item: self + (item,)
print(
 ().append(1).append(2).append(3)
)# (1, 2, 3)
登入後複製

我脸肿了。好吧,其实这只是我们玩的一个小把戏,当我们介绍完整个 CPython 的时候,会来专门聊一聊如何动态修改解释器。比如:让元组变得可修改,让 Python 真正利用多核等等。

从解释器的角度看对象的调用

我们以内置类型 float 为例,我们说创建一个 PyFloatObject,可以通过3.14或者float(3.14)的方式。前者使用Python/C API创建,3.14直接被解析为 C 一级数据结构,也就是PyFloatObject实例;后者使用类型对象创建,通过对float进行一个调用、将3.14作为参数,最终也得到指向C一级数据结构PyFloatObject实例。

Python/C API的创建方式我们已经很清晰了,就是根据值来推断在底层应该对应哪一种数据结构,然后直接创建即可。我们重点看一下通过类型调用来创建实例对象的方式。

如果一个对象可以被调用,它的类型对象中一定要有tp_call(更准确的说成员tp_call的值是一个函数指针,不可以是0),而PyFloat_Type是可以调用的,这就说明PyType_Type内部的tp_call是一个函数指针,这在Python的层面上我们已经验证过了,下面我们再来通过源码看一下。

//typeobject.c
PyTypeObject PyType_Type = {
 PyVarObject_HEAD_INIT(&PyType_Type, 0)
 "type", /* tp_name */
 sizeof(PyHeapTypeObject), /* tp_basicsize */
 sizeof(PyMemberDef),/* tp_itemsize */
 (destructor)type_dealloc, /* tp_dealloc */
 //... /* tp_hash */
 (ternaryfunc)type_call, /* tp_call */
 //...
}
登入後複製

我们看到在实例化PyType_Type的时候PyTypeObject内部的成员tp_call被设置成了type_call。当 PyFloat_Type 被调用时, type_call 指向的函数将会被触发,因为它是一个函数指针。

因此 float(3.14) 在C的层面上等价于:

(&PyFloat_Type) -> ob_type -> tp_call(&PyFloat_Type, args, kwargs);
// 即:
(&PyType_Type) -> tp_call(&PyFloat_Type, args, kwargs);
// 而在创建 PyType_Type 的时候,给 tp_call 成员传递的是 type_call
// 因此最终相当于
type_call(&PyFloat_Type, args, kwargs)
登入後複製

如果用 Python 来演示这一过程的话:

# float(3.14),等价于
f1 = float.__class__.__call__(float, 3.14)
# 等价于
f2 = type.__call__(float, 3.14)
print(f1, f2)# 3.14 3.14
登入後複製

这就是 float(3.14) 的秘密,相信list、dict在实例化的时候是怎么做的,你已经猜到了,做法是相同的。

# lst = list("abcd")
lst = list.__class__.__call__(list, "abcd")
print(lst)# ['a', 'b', 'c', 'd']
# dct = dict([("name", "古明地觉"), ("age", 17)])
dct = dict.__class__.__call__(dict, [("name", "古明地觉"), ("age", 17)])
print(dct)# {'name': '古明地觉', 'age': 17}
登入後複製

最后我们来围观一下 type_call 函数,我们说 type 的 __call__ 方法,在底层对应的是 type_call 函数,它位于Object/typeobject.c中。

static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
 // 如果我们调用的是 float
 // 那么显然这里的 type 就是 &PyFloat_Type

 // 这里是声明一个PyObject *
 // 显然它是要返回的实例对象的指针
 PyObject *obj;

 // 这里会检测 tp_new是否为空,tp_new是什么估计有人已经猜到了
 // 我们说__call__对应底层的tp_call
 // 显然__new__对应底层的tp_new,这里是为实例对象分配空间
 if (type->tp_new == NULL) {
 // tp_new 是一个函数指针,指向具体的构造函数
 // 如果 tp_new 为空,说明它没有构造函数
 // 因此会报错,表示无法创建其实例
 PyErr_Format(PyExc_TypeError,
"cannot create '%.100s' instances",
type->tp_name);
 return NULL;
 }

 //通过tp_new分配空间
 //此时实例对象就已经创建完毕了,这里会返回其指针
 obj = type->tp_new(type, args, kwds);
 //类型检测,暂时不用管
 obj = _Py_CheckFunctionResult((PyObject*)type, obj, NULL);
 if (obj == NULL)
 return NULL;
 //我们说这里的参数type是类型对象,但也可以是元类
 //元类也是由PyTypeObject结构体实例化得到的
 //元类在调用的时候执行的依旧是type_call
 //所以这里是检测type指向的是不是PyType_Type
 //如果是的话,那么实例化得到的obj就不是实例对象了,而是类型对象
 //要单独检测一下
 if (type == &PyType_Type &&
 PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
 (kwds == NULL ||
(PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) == 0)))
 return obj;
 //tp_new应该返回相应类型对象的实例对象(的指针)
 //但如果不是,就直接将这里的obj返回
 //此处这么做可能有点难理解,我们一会细说
 if (!PyType_IsSubtype(Py_TYPE(obj), type))
 return obj;

 //拿到obj的类型
 type = Py_TYPE(obj);
 //执行 tp_init
 //显然这个tp_init就是__init__函数
 //这与Python中类的实例化过程是一致的。
 if (type->tp_init != NULL) {
 //将tp_new返回的对象作为self,执行 tp_init
 int res = type->tp_init(obj, args, kwds);
 if (res < 0) {
 //执行失败,将引入计数减1,然后将obj设置为NULL
 assert(PyErr_Occurred());
 Py_DECREF(obj);
 obj = NULL;
 }
 else {
 assert(!PyErr_Occurred());
 }
 }
 //返回obj
 return obj;
}
登入後複製

因此从上面我们可以看到关键的部分有两个:

  • 调用类型对象的 tp_new 指向的函数为实例对象申请内存

  • 调用 tp_init 指向的函数为实例对象进行初始化,也就是设置属性

所以这对应Python中的__new__和__init__,我们说__new__是为实例对象开辟一份内存,然后返回指向这片内存(对象)的指针,并且该指针会自动传递给__init__中的self。

class Girl:
 def __new__(cls, name, age):
 print("__new__方法执行啦")
 # 写法非常固定
 # 调用object.__new__(cls)就会创建Girl的实例对象
 # 因此这里的cls指的就是这里的Girl,注意:一定要返回
 # 因为__new__会将自己的返回值交给__init__中的self
 return object.__new__(cls)
 def __init__(self, name, age):
 print("__init__方法执行啦")
 self.name = name
 self.age = age
g = Girl("古明地觉", 16)
print(g.name, g.age)
"""
__new__方法执行啦
__init__方法执行啦
古明地觉 16
"""
登入後複製

__new__里面的参数要和__init__里面的参数保持一致,因为我们会先执行__new__,然后解释器会将__new__的返回值和我们传递的参数组合起来一起传递给__init__。一般来说,除了cls,__new__方法的参数通常包括*args和**kwargs。

然后再回过头来看一下type_call中的这几行代码:

static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
 //......
 //......
 if (!PyType_IsSubtype(Py_TYPE(obj), type))
 return obj;

 //......
 //......
}
登入後複製

一般情况下,我们认为tp_new会返回该类型的实例对象,因此通常不需要编写__new__方法。如果进行重写,就需要手动返回object.__new__(cls)。可如果我们不返回,或者返回其它的话,会怎么样呢?

class Girl:
 def __new__(cls, *args, **kwargs):
 print("__new__方法执行啦")
 instance = object.__new__(cls)
 # 打印看看instance到底是个什么东东
 print("instance:", instance)
 print("type(instance):", type(instance))

 # 正确做法是将instance返回
 # 但是我们不返回, 而是返回个 123
 return 123
 def __init__(self, name, age):
 print("__init__方法执行啦")
g = Girl()
"""
__new__方法执行啦
instance:type(instance):"""
登入後複製

这个句子可以重写为:“有很多需要讨论的问题,最先引起注意的是在 __init__ 中需要传入两个参数,然而我们未传入参数时并未报错。”。原因就在于这个 __init__ 压根就没有执行,因为 __new__ 返回的不是 Girl 的实例对象。

通过打印 instance,我们知道了object.__new__(cls) 返回的就是 cls 的实例对象,而这里的cls就是Girl这个类本身。如果我们不返回instance,__new__方法就会直接返回,而无法执行对应的__init__方法。我们在外部来打印一下创建的实例对象吧,看看结果:

class Girl:
 def __new__(cls, *args, **kwargs):
 return 123
 def __init__(self, name, age):
 print("__init__方法执行啦")
g = Girl()
print(g, type(g))# 123
登入後複製

我们看到打印的是123,所以再次总结一些tp_new和tp_init之间的区别,当然也对应__new__和__init__的区别:

  • tp_new:为该类型对象的实例对象申请内存,在Python的__new__方法中通过object.__new__(cls)的方式申请,然后将其返回

  • tp_init:tp_new的返回值会自动传递给self,然后为self绑定相应的属性,也就是进行实例对象的初始化

但如果tp_new返回的不是对应类型的实例对象的指针,比如type_call中第一个参数接收的&PyFloat_Type,但是tp_new中返回的却是PyLongObject *,所以此时就不会执行tp_init。

以上面的代码为例,我们Girl中的__new__应该返回Girl的实例对象才对,但实际上返回了整型,因此类型不一致,所以不会执行__init__。

下面我们可以做总结了,通过类型对象去创建实例对象的整体流程如下:
  • 第一步:获取类型对象的类型对象,说白了就是元类,执行元类的 tp_call 指向的函数,即 type_call

  • 第二步:type_call 会调用该类型对象的 tp_new 指向的函数,如果 tp_new 为 NULL,那么会到 tp_base 指定的父类里面去寻找 tp_new。在新式类中,所有类都继承自 object,因此最终都会调用 object 的 __new__ 方法。然后通过访问对应类型对象中的 tp_basicsize 信息,这个信息记录着该对象的实例对象需要占用多大的内存,继而完成申请内存的操作

  • 调用type_new 创建完对象之后,就会进行实例对象的初始化,会将指向这片空间的指针交给 tp_init,但前提是 tp_new 返回的实例对象的类型要一致。

所以都说 Python 在实例化的时候会先调用 __new__ 方法,再调用 __init__ 方法,相信你应该知道原因了,因为在源码中先调用 tp_new、再调用的 tp_init。

static PyObject *
type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
 //调用__new__方法, 拿到其返回值
 obj = type->tp_new(type, args, kwds);
 if (type->tp_init != NULL) {
 //将__new__返回的实例obj,和args、kwds组合起来
 //一起传给 __init__
 //其中 obj 会传给 self,
 int res = type->tp_init(obj, args, kwds);
 //......
 return obj;
}
登入後複製

所以源码层面表现出来的,和我们在 Python 层面看到的是一样的。

以上是Python物件是怎麼被呼叫的的詳細內容。更多資訊請關注PHP中文網其他相關文章!

相關標籤:
來源:yisu.com
本網站聲明
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn
熱門教學
更多>
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板