在 Python 中，为什么说“一切皆对象”？

在 Python 中，“一切皆对象”是核心设计哲学，理解这一点能帮我们打通对 Python 语法的底层认知。下面结合具体问题详细解释：

一、为什么说 Python 中“一切皆对象”？

在 Python 中，所有能被“赋值给变量”或“作为参数传递”的实体，本质上都是“对象”。对象的核心特征是：有自己的类型（type）、可以被赋予属性、能响应特定的方法。

具体来说，无论是基本数据、容器、函数、类，甚至模块、文件等，都符合“对象”的定义：

实体类型	示例	作为对象的证明（有类型、可操作）
基本数据类型	整数 123、字符串 "abc"	type(123) → int（有类型）；123.__add__(456) → 579（有方法）
容器类型	列表 [1,2,3]、字典 {"a":1}	type([1,2,3]) → list；[1,2,3].append(4)（有方法）
函数	def f(): pass	type(f) → function；可赋值给变量 g = f
类	class A: pass	type(A) → type（类本身是“类型对象”）；A.attr = 1（可加属性）
模块	导入的 math 模块	type(math) → module；math.pi（有属性）
实例	a = A()（类的实例）	type(a) → A；a.x = 10（可加属性）

简单说：Python 中没有“非对象”的实体——哪怕是最基础的整数，也不是“纯粹的数值”，而是“int 类型的对象”，有自己的方法和属性。

二、函数是对象吗？函数有自己的属性和方法吗？

函数是对象，且有自己的属性和方法。

在 Python 中，函数属于 function 类型的对象，它满足“对象”的所有特征：可以被赋值给变量、作为参数传递、作为返回值，且自带属性和方法。

1. 函数是对象的直接证明：

def add(a, b):return a + b# 1. 有类型（function）
print(type(add))  # 输出：<class 'function'># 2. 可赋值给变量（像对象一样被传递）
func = add  # 将函数赋值给变量 func
print(func(2, 3))  # 输出：5（通过变量调用函数，证明 func 指向函数对象）# 3. 可作为参数传递给其他函数
def calculate(func, x, y):return func(x, y)  # 接收函数作为参数并调用print(calculate(add, 2, 3))  # 输出：5

2. 函数有自带的属性和方法：

• 自带属性：如 __name__（函数名）、__doc__（文档字符串）、__module__（所在模块）等；
• 自带方法：如 __call__（允许函数被调用，add.__call__(2,3) 等价于 add(2,3)）；
• 自定义属性：可以给函数动态添加属性（因为是对象）。

示例：

def add(a, b):"""返回两数之和"""return a + b# 自带属性
print(add.__name__)  # 输出：add（函数名）
print(add.__doc__)   # 输出：返回两数之和（文档字符串）# 自带方法（__call__ 实现函数调用）
print(add.__call__(2, 3))  # 输出：5（等价于 add(2,3)）# 动态添加自定义属性
add.version = "1.0"  # 给函数加一个 version 属性
print(add.version)   # 输出：1.0

三、一等对象（First-Class Object）是什么？

一等对象是指在编程语言中，满足以下条件的实体：

1. 可以被赋值给变量；
2. 可以作为参数传递给函数；
3. 可以作为函数的返回值；
4. 可以包含在数据结构中（如列表、字典）。

Python 中几乎所有对象都是一等对象，这是 Python 灵活性的重要来源。

一等对象的典型例子：

1. 整数、字符串等基本类型：

   # 赋值给变量
   a = 10
   # 作为参数传递
   def func(x): return x * 2
   print(func(a))  # 20
   # 作为返回值
   def get_num(): return 100
   # 包含在列表中
   nums = [1, 2, 3]
   

2. 函数（前面已举例，满足所有条件）：

   def add(a, b): return a + b
   # 赋值给变量
   f = add
   # 作为参数传递
   def wrapper(func): return func(2, 3)
   # 作为返回值
   def get_func(): return add
   # 包含在列表中
   funcs = [add, lambda x: x*2]
   

3. 类和类的实例：

   class Person: pass
   p = Person()
   # 类作为一等对象
   cls = Person  # 赋值给变量
   objs = [Person, p]  # 包含在列表中
   # 实例作为一等对象
   def get_person(): return p  # 作为返回值
   

四、哪些不是一等对象？

在 Python 中，非对象的实体都不是一等对象。但 Python 中“一切皆对象”，严格来说“非一等对象”非常少，主要是语法关键字/结构（它们是语言的语法规则，不是实体对象）。

这些语法结构不能被赋值、传递或包含在数据结构中，因此不是一等对象：

1. 关键字（if、for、def、class 等）

# 尝试将 if 赋值给变量 → 语法错误
x = if  # 报错：invalid syntax

if 是条件判断的语法关键字，不是对象，不能被操作。

2. 运算符（+、-、* 等）

运算符是语法规则的一部分，本身不是对象（但它们对应的“魔法方法”是对象的方法）：

# 尝试将 + 赋值给变量 → 语法错误
op = +  # 报错：invalid syntax

虽然 1 + 2 本质是调用 1.__add__(2)（__add__ 是 int 对象的方法），但 + 本身是语法符号，不是对象。

3. 代码块（缩进的逻辑块）

例如 if 后的缩进块、函数体的缩进块，是语法结构，不是对象：

# 代码块无法被赋值或传递
block = {print("hello")  # 这是执行语句，不是对象
}

总结

1. Python 中“一切皆对象”：所有可操作的实体（数据、函数、类、模块等）都是对象，有类型、属性和方法；
2. 函数是对象：属于 function 类型，可赋值、传递，有自带属性（如 __name__）和自定义属性；
3. 一等对象：满足“可赋值、可传递、可返回、可包含在数据结构”的对象，Python 中绝大多数对象都是一等对象；
4. 非一等对象：主要是语法关键字（if、for）、运算符（+、-）等语法结构，它们不是实体对象，无法被操作。

这种设计让 Python 极其灵活——例如可以把函数当参数传递（实现装饰器、回调函数），把类当参数动态创建实例，极大提升了代码的表现力。