一篇文章带你深入学习Python函数_Python

一篇文章带你深入学习Python函数

2022-09-02 08:53三爷带你飞 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