深入理解Python函数作为一等对象的特性与实现

Nora

发布时间：2026-10-12| 3人浏览过

原创

本文深入解析Python中函数作为一等对象的特性，包括函数的赋值、删除、存储于数据结构及作为参数传递。详细阐述闭包机制如何保留父函数变量，以及通过实现__call__协议使自定义对象具备函数调用能力的方法，帮助开发者掌握高阶Python编程技巧。

函数的核心特性在于其作为一等对象的地位。

在Python中，函数被视为一种对象。
既然函数是对象，它们就可以被删除。
函数的名称与函数实体本身是完全独立的，二者并不绑定。
由于函数属于对象类型，它们可以存储在数据结构中。
函数可以作为参数传递给其他函数。
函数可以在另一个函数的内部进行定义和嵌套。
内部函数对象能够记住并访问父函数的变量，这被称为闭包。
虽然所有的函数都是对象，但并非所有的对象都是函数。

若要使一个对象能够像函数一样被调用，该对象必须实现__call__协议。

函数作为对象的体现：支持赋值操作。

# 函数是对象：支持赋值操作。
def test1(n):
    print(f"hello, {n}!")

# test1的函数名赋值给 new1
new1 = test1
new1("tom") # hello, tom!

函数的删除机制：

# 函数可以删除
def test2(n):
    print(f"hello, {n}!")
del test2
# test2("tom") # NameError: name 'test2' is not defined

函数名与函数实体分离：删除test3后，已赋值的new3仍可正常调用。

# 函数名字和函数本身完全是分开的：删除test3，不影响已经赋值的调用
def test3(n):
    print(f"hello, {n}!")

new3 = test3
del test3
new3("Jam") # hello, Jam!

函数作为对象，可结合数据结构使用：

# 函数因为是对象，就可以结合数据结构使用
def test4(n):
    print(f"hello, {n}!")

data = [1, "a", {"name": "tom"}, test4]
for i in data:
    from types import FunctionType
    if type(i) == FunctionType:
        test4("Lily")  # hello, Lily!

函数作为对象，可作为函数参数传递：

# 函数因为是对象，就可以作为函数参数
def test5(n):
    print("原始函数执行")
    print(f"hello, {n}")

def new5(n):
    n("Golang")

new5(test5)  # 原始函数执行  hello, Golang

函数作为对象，可在嵌套在函数体内：

# 函数因为是对象，可以在嵌套在函数体内
def test6(n):
    def inner1(m):
        new = m + "!!!"
        return new
    def inner2(m):
        new = m + "***"
        return new
    if n > 3:
        return inner2
    else:
        return inner1

result6 = test6(3)
print(result6("tom"))  # tom!!!

内层函数对象能够记忆住父函数的变量：也称为闭包。

# 内层函数对象能够记忆住父函数的变量
def test7(n):
    def inner(m):
        return m + n
    return inner

result7 = test7(7)
print(result7(6))  # 13

所有的函数都是对象，但是所有的对象并不一定都是函数：

# 所有的函数都是对象，但是所有的对象并不一定都是函数
class A:
    pass

a = A()

def test8():
    pass

from types import FunctionType
print(isinstance(a, A))  # True
print(isinstance(test8, FunctionType))  # True
print(isinstance(a, FunctionType))  # False  所有的对象并不一定都是函数

对象成为函数需要实现__call__协议：

# 对象成为函数需要实现__call__协议
class B:
    def __init__(self, n):
        self.n = n
    def __call__(self, m):
        return self.n + m

b = B(9)
print(b(9))  # 18