Python 达到“的固定点”；“类型”；

对对象调用

type（x）

返回该对象的类型。调用

type（type（…type（x）…）

总是最终产生

type

本身，其中

type（type）=type

是一个固定点。我能想到的最复杂的例子是

类元（类型）：
通过
C类（元类=元）：
通过
x=C（）

它需要三次调用type（

type（type（type（x）））

）来计算

type

---

对于Python中的任何表达式，最多需要三次对

type

的调用才能到达固定点，这是真的吗？如果没有，是否存在有限限制（仅大于三个），或者所需的

类型

调用堆栈是否可以无限增长？

所需的

类型

调用堆栈是否可以无限增长

以下是一个例子：

>>> class Meta(type):
...     pass
... 
>>> class C(type, metaclass=Meta):
...     pass
... 
>>> class D(type, metaclass=C):
...     pass
... 
>>> class E(type, metaclass=D):
...     pass
... 
>>> class F(type, metaclass=E):
...     pass
... 
>>> f = F("1",(),{});
>>> type(f)
<class '__main__.F'>
>>> type(type(f))
<class '__main__.E'>
>>> type(type(type(f)))
<class '__main__.D'>
>>> type(type(type(type(f))))
<class '__main__.C'>
>>> type(type(type(type(type(f)))))
<class '__main__.Meta'>
>>> type(type(type(type(type(type(f))))))
<class 'type'>
>>> type(type(type(type(type(type(type(f)))))))
<class 'type'>
>>> 

类元（类型）： ... 通过 ... >>>C类（类型，元类=元）： ... 通过 ... >>>D类（类型，元类=C）： ... 通过 ... >>>E类（类型，元类=D）： ... 通过 ... >>>F类（类型，元类=E）： ... 通过 ... >>>f=f（“1”，（），{}）； >>>类型（f） >>>类型（类型（f）） >>>类型（类型（类型（f））） >>>类型（类型（类型（类型（f））） >>>类型（类型）（类型）（类型）（类型（类型（f '）））） >>>类型（类型）（类型）（类型）（类型）（类型）（类型（类型）（fщщ））） >>>类型(类型)(类型)(类型(类型(f))) >>> 案例

type（type）==type

只是可实例化类型的基本案例。正如第一层类型可以从

type

创建一样，还可以构建更多的层。没有固定的限制

def下降（基本=类型）：
尽管如此：
类基（基，元类=基）：
通过
产量基数
def类型_深度（tp）：
深度=0
而类型（tp）！=类型：
深度+=1
tp=类型（tp）
返回深度
对于下降（）中的tp：
打印（tp，类型\深度（tp））

---

实际上，元层的用处是有限的：大多数类是

类型本身或其子类型之一的直接实例。
请注意，在您的示例中，
是instance（meta，type）
，或者换句话说
类型（C）如果我错了，请纠正我，但我认为所有对象都存储在heap中，虽然对象本身的指针存储在stackheap中，但在堆栈溢出时使用，对于局部变量，它会像循环中的i一样发生很大的变化；堆栈用于全局数据和函数返回，c中的一个典型分段错误是堆栈溢出或访问不允许的位置