Python：内置类型也是类对象

在 Python 中有一个非常核心且经常被忽略的概念：

所有的内置类型（int、str、list、dict、tuple、bool、float 等）本质上也都是类（class）对象。

这不是比喻，而是 Python 的语言设计事实。

下面通过代码和解释，一步一步帮你看清楚这件事。

1. 最直观的证据：type() 函数

print(type(123))          # <class 'int'>
print(type("hello"))      # <class 'str'>
print(type([1,2,3]))      # <class 'list'>
print(type({"a":1}))      # <class 'dict'>
print(type(True))         # <class 'bool'>
print(type(3.14))         # <class 'float'>
print(type(None))         # <class 'NoneType'>

你会发现：它们返回的都是 class，而不是别的什么东西。

2. 它们真的是类，可以被继承

class MyInt(int):
    def __add__(self, other):
        return super().__add__(other) * 2

a = MyInt(5)
b = MyInt(3)
print(a + b)          # 16  （不是 8，而是 8×2）
print(type(a))        # <class '__main__.MyInt'>
print(issubclass(MyInt, int))   # True

int 是一个真正的类，你可以继承它、改写它的方法。

同样的操作对 str、list、dict 等也完全成立。

3. 内置类型本身也是对象（有自己的属性和方法）

print(int.__name__)          # 'int'
print(int.__bases__)         # (<class 'object'>,)
print(int.__mro__)           # 方法解析顺序
print(int.__dict__)          # 类的属性字典（很长）

# 甚至可以给内置类型动态加属性（不推荐，但可以证明它是对象）
int.hello = lambda self: "hello from int"
print((123).hello())         # hello from int

4. 一切皆对象的最彻底体现：type 也是类，而且 type 自己是自己的实例

print(type(int))      # <class 'type'>
print(type(str))      # <class 'type'>
print(type(list))     # <class 'type'>
print(type(type))     # <class 'type'>   ← type 自己也是 type 的实例

这形成了 Python 最经典的“元循环”：

• 普通对象（如 123、“abc”）是某个类的实例
• 普通类（如 int、str、list）是 type 的实例
• type 本身是 type 的实例

5. 常见但容易混淆的对比

6. 为什么这个设计对我们写代码很重要？（实际影响）

1. 统一的对象模型
   你可以用完全相同的语法操作内置类型和自定义类（dir()、hasattr()、getattr()、issubclass() 等）。

2. 可以 monkey patch（猴子补丁）
   虽然不推荐在生产代码中乱改内置类型，但调试、测试、框架开发中非常有用。

3. 元编程的基础
   metaclass、类装饰器、ABC（抽象基类）等高级特性都是建立在这个“类型也是对象”的前提上。

4. 理解 isinstance 和 type 的区别

   print(isinstance(123, int))     # True
   print(type(123) is int)         # True
   print(isinstance(int, type))    # True   ← 类本身是 type 的实例
   

5. 鸭子类型与类型检查的哲学
   Python 更倾向于“行为像什么就是什么”，而不是强依赖静态类型。

7. 小结：一句话记住

在 Python 中，没有“基本类型”和“类”的本质区别——所有东西（包括 int、str、list、甚至 type 本身）都是对象，而这些对象的类型（类）也都是对象。

这正是 Python “一切皆对象”这句话最彻底的体现。

如果你对下面任何一个点还想再深入一点，可以直接告诉我，我继续展开：

• 如何给内置类型安全地打猴子补丁？
• metaclass 怎么利用这个特性？
• class 和 type() 的细微区别
• Python 2 vs Python 3 在这方面的变化
• 如何判断一个对象是不是“真正的内置类型”

随时问～