Python 中 “一切皆对象” 的核心含义是，在 Python 语言的设计中，所有数据、结构、代码单元乃至语言本身的基础构件，均被抽象和实现为对象。这意味着，从简单的整数、字符串，到复杂的函数、类、模块，再到语言层面的元类（metaclass），它们都遵循统一的对象模型，拥有共同的行为和操作方式 。

为了清晰地解释“对象”的定义和特征，可以将其解构为以下几个层面：

一、 对象的定义与本质

在 Python 语境下，对象（Object） 是内存中一段包含数据和相关操作（方法）的存储区域，它是类（Class） 的实例化产物。每个对象都拥有：

1. 身份（Identity）：一个唯一的标识符，在对象的生命周期内保持不变，通常对应于对象在内存中的地址。可以使用内置函数 id() 获取 。
2. 类型（Type）：决定了对象支持的操作（方法）和可能的取值。类型本身也是一个对象（type 类的实例）。可以使用内置函数 type() 获取 。
3. 值（Value）：对象所表示的具体数据内容。有些对象的值可以改变（可变对象），有些则不能（不可变对象）。

一个简单的例子可以说明这三者：

# 创建一个字符串对象
my_str = “Hello, Object!”

# 获取对象的身份（内存地址）
print(f“身份 (id): {id(my_str)}“)  # 输出类似：1401234567890

# 获取对象的类型
print(f“类型 (type): {type(my_str)}“)  # 输出：<class ‘str’>

# 获取对象的值
print(f“值: {my_str}“)  # 输出：Hello, Object!

# 甚至类型本身也是对象
print(f“str类型的身份: {id(str)}“)  # str类型本身也有id
print(f“str类型的类型: {type(str)}“)  # 输出：<class ‘type’>，表明str是type类的一个实例 

二、 “一切皆对象”的具体体现

“一切皆对象”这一哲学贯穿于 Python 的各个角落，下表列举了主要体现方面：

下面的代码示例进一步验证了函数和类作为对象的特性：

def greet(name):
    return f“Hello, {name}!“

# 1. 函数是对象，可以赋值
say_hello = greet
print(say_hello(“World“))  # 输出：Hello, World!
print(type(greet))         # 输出：<class ‘function’>

# 2. 函数可以作为参数传递
def apply_func(func, value):
    return func(value)

print(apply_func(greet, “Python“))  # 输出：Hello, Python!

# 3. 类也是对象，可以动态操作
class Person:
    def __init__(self, name):
        self.name = name

# 类名 `Person` 是一个指向 `type` 实例的变量
print(type(Person))  # 输出：<class ‘type’>

# 可以像操作普通对象一样操作类
Person.alias = “Human“  # 给类动态添加属性
print(Person.alias)     # 输出：Human

三、 对象的核心特征与优势

Python 对象模型带来的核心特征和优势主要体现在面向对象编程（OOP）的三大特性和动态性上 ：

1. 封装（Encapsulation）
   对象将数据（属性）和操作数据的方法捆绑在一起，并可以控制对内部状态的访问权限（尽管 Python 主要依靠约定实现私有性）。这提高了代码的模块化和安全性。

   class BankAccount:
       def __init__(self, owner, balance=0):
           self.owner = owner       # 公开属性
           self._balance = balance  # 受保护的属性（约定俗成）
   
       def deposit(self, amount):
           if amount > 0:
               self._balance += amount
               return True
           return False
   
       def get_balance(self):
           return self._balance  # 通过方法访问内部数据
   
   account = BankAccount(“Alice“, 100)
   account.deposit(50)
   print(account.get_balance())  # 输出：150，余额被安全地封装在对象内部 。
   

2. 继承（Inheritance）
   一个类（子类）可以继承另一个类（父类）的属性和方法，实现代码的复用和层次化抽象。

   class Animal:
       def __init__(self, name):
           self.name = name
       def speak(self):
           raise NotImplementedError(“子类必须实现此方法“)
   
   class Dog(Animal):  # Dog 继承自 Animal
       def speak(self):
           return f“{self.name} says: Woof!“
   
   my_dog = Dog(“Buddy“)
   print(my_dog.speak())  # 输出：Buddy says: Woof! 
   

3. 多态（Polymorphism）
   不同类的对象可以对同一消息（方法调用）做出不同的响应。这提高了代码的通用性和灵活性。

   class Cat(Animal):
       def speak(self):
           return f“{self.name} says: Meow!“
   
   def animal_talk(animal_obj):  # 参数类型是父类Animal
       print(animal_obj.speak())  # 实际调用子类实现的方法
   
   animals = [Dog(“Rex“), Cat(“Whiskers“)]
   for a in animals:
       animal_talk(a)
   # 输出：
   # Rex says: Woof!
   # Whiskers says: Meow! 
   

4. 动态性（Dynamism）
   由于一切皆对象，Python 程序在运行时具有极高的灵活性：

   • 动态类型：变量无需声明类型，其类型由引用的对象决定。
   • 动态属性：可以随时为对象（包括类和实例）添加、修改或删除属性。
   • 内省（Introspection）：程序可以在运行时检查对象的类型、属性、方法等信息（如使用 dir(), hasattr(), getattr()）。

   obj = {}
   obj.new_attribute = “Dynamic“  # 运行时添加属性
   print(hasattr(obj, ‘new_attribute‘))  # 输出：True
   
   # 内省：查看对象的所有属性和方法
   print(dir(obj))  # 输出包含 ‘new_attribute‘ 和众多内置方法 
   

四、 理解 type, object, class 的关系

深入理解“一切皆对象”需要厘清三个核心概念的关系，这是 Python 对象模型的基石 ：

• object：是所有类的基类（超类）。在 Python 中，无论是内置类型还是自定义类，最终都直接或间接继承自 object。
• type：是所有类型的类型（元类）。type() 函数用于获取对象的类型，而 type 类本身用于创建类（class 语句的本质）。type 本身也是一个类，并且是自身的实例。
• class：用户自定义的类。它是 type 类的实例，同时又是其未来实例的模板。

它们的关系可以概括为：

1. object 是顶层基类，type 继承自 object。
2. type 是 object 的类型（type(object) 结果是 type）。
3. 所有类（包括 type 和 object）都是 type 的实例。
4. 所有实例对象（如 5, [], 自定义类的实例）的类型的类型最终都是 type。

# 验证关系
print(issubclass(type, object))  # True: type 是 object 的子类
print(isinstance(object, type))  # True: object 是 type 的实例
print(type(type))                # <class ‘type‘>: type 是自身的实例

class MyClass:
    pass

obj = MyClass()
print(isinstance(obj, MyClass))  # True
print(isinstance(MyClass, type)) # True: 自定义类也是 type 的实例
print(isinstance(MyClass, object)) # True: 所有类都是 object 的子类 

综上所述，Python 中“一切皆对象”的理念构建了一个极其统一和自洽的模型。它将数据和操作数据的代码都纳入对象的范畴，通过封装、继承、多态三大特性支撑起面向对象编程，并借助 type 和 object 的巧妙关系提供了强大的动态性和内省能力。这使得 Python 代码不仅高度灵活和可扩展，也保持了逻辑上的一致性 。

参考来源

• Python 高级语法：一切皆对象
• Python一切皆对象
• 第一章：Python中的一切皆对象
• 【Python学习教程】Python类和对象
• Python 中 一切皆对象
• 万物皆对象之Python中类的概念