目录
- 函数的特性：
- 函数是对象：
- 函数可以删除：
- 总结
函数的特性：
- 函数是对象
- 函数可以删除
- 函数名字和函数本身完全是分开的
- 函数因为是对象，可以结合数据结构使用
- 函数因为是对象，可以作为函数参数
- 函数因为是对象，可以在嵌套在函数体内
- 内层函数对象能够记忆住父函数的变量
- 所有的函数都是对象，但是所有的对象并不一定都是函数
对象成为函数需要实现__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
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注北冥有鱼的更多内容!
