零基础学Python(第2版)
上QQ阅读APP看书,第一时间看更新

5.3.4 函数的嵌套

函数的嵌套是指在函数的内部调用其他函数。C、C++只允许在函数体内部嵌套,而Python不仅支持函数体内嵌套,还支持函数定义的嵌套。例如,计算表达式(x+y)*(m-n)的值。可以把计算步骤分为3步,先计算表达式x+y,然后计算表达式m-n,最后计算前面两步结果的乘积。因此,可以设计3个函数。第一个函数sum()计算x+y的值,第二个函数sub()计算m+n的值,第三个函数计算前面两者的乘积,如图5-5所示。

下面【例5-12】这段代码演示了函数之间的调用操作。

【例5-12.py】


01     # 嵌套函数
02     def sum(a, b):
03         return a + b
04     def sub(a, b):
05         return a - b
06     def func():
07         x = 1
08         y = 2
09         m = 3
10         n = 4
11         return sum(x, y) * sub(m, n)
12
13     print (func())

【代码说明】

·第2行代码定义了函数sum(),sum()带有两个参数a、b。参数a、b用于计算表达式x+y的值。

·第3行代码计算a+b的值,即返回x+y的结果。

·第4行代码定义了函数sub(),sub()带有两个参数a、b。

·第5行代码计算a–b的值,即返回m–n的结果。

·第6到第10行代码定义了函数func(),对x,y,m,n赋值。

·第11行代码,在return语句中调用sum()、sub(),并执行乘法运算。

·第13行代码,调用函数func()。输出结果如下所示。


-3

注意 函数嵌套的层数不宜过多。否则,容易造成代码的可读性差、不易维护等问题。一般函数的嵌套调用应控制在3层以内。

上面这段代码也可以换一种形式实现,即把函数sum()、sub()放到func()的内部,如图5-6所示。

下面【例5-13】这段代码实现了在func()内部定义sum()、sub()。

【例5-13.py】


01     # 嵌套函数
02     def func():
03         x = 1
04         y = 2
05         m= 3
06         n = 4
07         def sum(a, b):               # 内部函数
08             return a + b
09         def sub(a, b):               # 内部函数
10             return a - b
11         return sum(x, y) * sub(m, n)
12
13     print (func())

【代码说明】

·第7行代码,在func()内部定义了sum()。

·第9行代码,在func()内部定义了sub()。

·第11行代码,调用sum()和sub(),然后执行乘法运算。输出结果为“-3”。

内部函数sum()、sub()也可以直接调用外部函数func()定义的变量,如图5-7所示。

图5-5 函数的嵌套

图5-6 在函数内部定义函数

图5-7 内部函数引用外部函数的变量

下面【例5-14】这段代码实现了内部函数sum()、sub()引用外部函数func()的变量。

【例5-14.py】


01     # 嵌套函数,直接使用外层函数的变量
02     def func():
03         x = 1
04         y = 2
05         m= 3
06         n = 4
07         def sum():                   # 内部函数
08             return x + y
09         def sub():                    # 内部函数
10             return m - n
11         return sum() * sub()
12
13     print (func())

【代码说明】

·第7行代码,函数sum()没有任何参数。

·第8行代码,在sum()内部调用外部变量x、y。

·第9行代码,函数sub()也没有任何参数。

·第10行代码,在sub()内部调用外部变量m、n。

·第11行代码,计算sum()*sub()的值。输出结果为“-3”

注意 尽量不要在函数内部定义函数。这种方式不便于程序的维护,容易造成逻辑上的混乱。而且嵌套定义函数的层次越多,程序维护的代价就越大。