前言：
嵌套函数指定是在函数的内部再定义一个函数，但是需要注意的是，在函数内部定义的函数，无法被外部所访问，通俗来讲就是函数在哪里定义的就只能在同级别位置进行调用



函数嵌套定义
通过将函数定义在已存在的函数内容，称为：嵌套函数
def func1():
    print('this is func1')
    
    def func2():	# 此函数为嵌套函数
        print('this is func2')



调用嵌套函数
能否通过在外部调用到func2函数
def func1():
    print('this is func1')
    
    def func2():	# 此函数为嵌套函数
        print('this is func2')
        
func1()
func2()

执行效果




正确调用方法
def func1():
    print('this is func1')
    def func2():
        print('this is func2')

    func2()	# 通过在同级别位置调用这个函数

func1()

def func1():
	def func2():
		print('this is func2')
	return func2	# 调用func1	将func2函数对象返回给调用者

res = func1() # 调用func1，返回了func2的返回对象
# res = func2

res() # 调用的就是func2
打印结果：'this is func2'





练习：定义多个功能的内部函数
模拟我们日常使用的一些内置方法：如len、sum
def calculation(value,mode=0):  # 可根据输入模式执行对应功能，默认为0

    def lens(element):  # 计算传入值的长度,模拟了 len方法
        count = 0
        for i in element:
            count += 1
        return count    # 把结果返回给调用这个函数的代码

    def sums(element): # 计算传入值的总和，模拟了 sum方法
        count = 0
        for i in element:
            count += i
        return count    # 把结果返回给调用这个函数的代码

    if mode == 0:	# 判断输入模式对应功能
    
 		# 将外部函数传入的值传递给内部功能函数
        return lens(value)  # 返回函数处理的结果

    elif mode == 1:
        return sums(value)  # 返回函数处理的结果

lis = [10,20,30]

res = calculation(lis,mode=1)   # 模式输入1就是计算列表内元素的总和
print(res)
打印结果：60

strs = 'Hello World'

res = calculation(strs) # 不输入模式默认就是计算元素的长度
print(res)
打印结果：11



练习：找出传递内容的最大值
模拟了max内置方法，向函数传递多个值，可以获取到最大的那个值
def count_max(x,y): # 对比传递进来的两个数，返回最大的那个数
	if x > y:
		return x

	else:
		return y

def res_max(*args):
    count = 0	# 定义计数
    max_value = 0	# 取最大值，必须放在循环外面，因为需要待循环结束作为返回值

    '''
    每次count都要对应到下一个值，所以在最后一次时
    如果count=5 args有6个元素 最后一个在args里面+1 
    可以获取到最后一个元素，那么count再次加1之后，
    如果总长度不减一，那么count再找下一个元素就不能找到，会索引报错
    '''
    while count < len(args) - 1:

        if count == 0:          # 第一次传递元组里面1,2个进行对比
            max_value = count_max(args[count],args[count + 1])
            count += 1

        else:       # 后面的每一次都是拿上一次的最大值，与下一个值相比
            max_value = count_max(max_value, args[count + 1]) # 注意看：count在这里要+1
            count += 1
    return max_value

print(res_max(50,20,18,60,72))
打印结果：72




技术小白记录学习过程，有错误或不解的地方请指出，如果这篇文章对你有所帮助请点赞 收藏+关注 谢谢支持！

我们学习了函数的定义和使用，那么，函数在被调用之前，必须先进行定义或者声明。

如下是一个程序测试例子：



 

程序运行结果如下：



 

可以看到，在main函数中调用了func函数。就是说：函数调用了函数；那么，我们称为：函数嵌套调用。

注意：不能够在函数中定义函数，就是不能够“嵌套定义函数”。我们不可以把func函数的定义放在main函数的定义中。例如：

int main(int argc, char* argv[])

{

//定义func函数

void func(int a)

{

printf("in func, a = %d\n", a);

}

func(6);

return 0;

}

注意：这样的代码，在VC编译器，或者Visual Studio编译器中，是非法定义的代码。

这样的代码是错误的，虽然在func函数的调用之前，定义了func函数。但是，不能够在main函数中定义func函数，就是不能够嵌套定义函数。

但是，在Ubuntu系统的GCC编译器中，支持嵌套定义函数的语法。

虽然GCC支持这样的语法，但是，我们不建议嵌套定义函数。这样的语法，是不提倡的写法。不便于代码的移植。

但是，函数可以嵌套调用，就是在函数的定义中，调用其他函数，程序测试例子如下：

注意：下面的例子，作者举例有些复杂，在分析的过程中，还分析函数的返回值等数据的传递。如果只是说明函数的嵌套调用，那么，没有那么复杂。很简单，就是：在一个函数中，调用一个函数，这就是函数的嵌套调用。

下一章节，我们讲解函数的递归调用，才是重点。



 

程序运行结果如下：



 

我们来分析该程序的执行过程如下：

(1) 定义了main函数，是程序的入口地址；程序从main函数开始执行；

(2) 在main函数中调用func3函数，执行到 int x = func3(); 代码的时候，就跳转到func3函数执行；

(3) 在func3函数中调用func2函数，执行到 int c = func2(); 代码的时候，就跳转到func2函数执行；

(4) 在func2函数中调用func1函数，执行到int b = func1(); 代码的时候，就跳转到func1函数执行；

(5) 此时，一步一步嵌套调用函数，调用到func1函数，执行func1函数体定义的代码，执行：

printf("in func1, a = %d\n", a);

输出调试代码，然后，执行return a; 返回变量a的值；

(6) 结束func1函数的调用，返回到func2函数的int b = func1(); 代码，此时，把func1函数的返回值赋给变量b，那么，变量b得到func1函数的返回值10。

(7) 继续执行func2函数的代码：

printf("in func2, b = %d\n", b);

return b;

此时，在func2函数中输出信息，然后，返回变量b的值；

(8) 结束func2函数的调用，返回到func3函数的int c = func2(); 代码，此时，把func2函数的返回值赋给变量c，那么，变量c得到func2函数的返回值12。

(9) 继续执行func3函数的代码：

printf("in func3, c = %d\n", c);

return c;

输出调试信息，然后，返回变量c的值。最终，结束func3函数的调用，返回到main函数的int x = func3(); 代码，此时，结束func3函数的调用，把返回值赋给变量x。在main函数中输出变量x的值。执行完main函数之后，结束程序的运行。

通过这个程序的分析，我们知道了函数的嵌套调用，就是在函数中调用函数。碰到调用函数时，就跳转到函数定义的函数体中运行。例如，在main函数中调用func3函数的时候，就跳转到func3函数定义函数体中运行。

 

感谢作者：https://www.cnblogs.com/thinking-jxj/p/7681415.html

还可以对照看下：https://www.cnblogs.com/haiyan123/p/7240665.html  帮助理解

1. 函数嵌套：

　　在一个函数中定义了另外一个函数

def outer():

　　def inner():

　　　　print('inner')

　　print('outer')

　　inner()

outer()

inner()    # 此句会出错

函数有可见范围，这就是作用域的概念

内部函数不能被外部直接使用，会抛NameError异常

2. 作用域

一个标识符的可见范围，这就是标识符的作用域。一般常说的是变量的作用域

全局作用域（global）：在整个程序运行环境中都可见

局部作用域：在函数、类等内部可见；局部变量使用范围不能超过其所在的局部作用域

def fn1():

　　x = 1    # 局部作用域，在fn1内可见

def fn2():

　　print(x)   # x可见吗？

print(x)        # x可见吗？





global使用原则：

　　外部作用域变量会内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的是为了封装，尽量与外界隔离。

　　如果函数需要使用外部全局变量，请使用函数的形参传参解决。

　　一句话：不用global，学习它就是为了深入理解变量作用域。

3. 闭包

自由变量：未在本地作用域中定义的变量。例如定义在内存函数外的外层函数的作用域中的变量。

闭包：出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就行成了闭包。很多语言都有这个概念，最熟悉的就是JavaScript

前言

昨天的那一篇讲的几个函数，不知道你们理解的如何，是否懂得怎么去使用了，如果还没懂，一定要再多看几遍，并且去在软件上进行实操，今天的话，将要介绍一下函数的嵌套，不过在正式讲嵌套之前，先对主函数和子函数做下了解。

 

主函数

一般来说，函数M文件中的第一个函数就是主函数，之后任意数量的函数都是子函数，主函数也就是以其函数名命名的函数，因此可以被该文件外的其他文件中的函数或者脚本调用。

 

子函数

一个函数M文件中，除主函数之外的都是子函数，子函数只能够被该文件中的其他函数调用，每个子函数都是以“function”开始，直至下一个函数的定义或者文件的结尾才结束，子函数的顺序可以随意，但是主函数一定是要最开始出现的。

 

接下来对主函数和子函数的格式编写一个程序，然后简单调用看下其运行结果：

程序：

function [avg,med] = newstats(u)%主函数

%返回数组的均值和中间值

n=length(u);

avg=mean(u,n);

med=median(u,n);

function a=mean(v,n)%子函数

%计算平均值

a=sum(v)/n;

function m=median(v,n)%子函数

%计算中值

w=sort(v);

if rem(n,2)==1

    m=w((n+1)/2);

else

    m=(w(n/2)+w(n/2+1))/2;

end

结果：



再说一下在M文件中调用函数的流程，调用时遇到函数，会先判断是否为子函数。然后判断是否为私有函数，最后才判断是不是当前目录下的其他函数M文件或者系统内置的函数。

私有函数

刚好讲到私有函数，就顺便对它简单介绍下，私有函数就是MATLAB安装目录下，位于“private”这个目录下的函数M文件，构造和我们自己创建的函数一个样，不过私有文件只可以被private目录的上级目录下的函数M文件调用，而不能被脚本文件调用，也不能被其他目录下的任何M文件调用。

嵌套函数

讲完主函数和子函数，现在开始嵌套函数的记录，这个理解起来就很简单了，最容易理解的就是多层嵌套结构，就相当于套纸杯，一个套一个的感觉，看下它的程序结构就知道了：

function x=A(p1,p2)

......

    function y=B(p3)

    ......

        function z=C(pN)

        ......

        end

    .......

    end

.......

end

除了这种多层嵌套的结构，还有一种平级嵌套结构，就相当于一堆小球放一个纸箱子里，纸箱子就是级别最高的那个函数，然后其他小球都是同级别的函数，再来看看它的程序结构：

function x=A(p1,p2)

......

    function y=B(p3)

        ...

    end

    function y=C(p4)

        ...

    end

    function y=N(pN)

        ...

    end

end



嵌套规则

讲完了两种嵌套的结构，或许你们在想，这些函数嵌套后，函数之间的调用会有什么规则吗？

没错，有一定规则的，嵌套函数可以被该嵌套函数的上一层函数使用、也可以是同一个母函数的同级嵌套函数使用、甚至可以被任意一个低级别的函数调用，如果没太看懂意思，来看一个简单的示例，再理解上面讲的嵌套函数被调用的规则：

程序：

function A(x,y)

B(x,y);

D(x,y);

    function B(x,y)

        C(x);

        D(x);

        function C(x)

            B(x,y);

            D(x,y);

        end

    end

    function D(x,y)

        B(x,y);

        E(x);

        function E(x)

            B(x,y);

            D(x,y);

        end

    end

end

该程序中可以很明显的看出，函数A能调用B和D，但是不能调用C和E；函数B可以调用C和D；函数D可以调用B和E，函数C可以调用B和D，函数E也可以调用B和D；看完这段程序后，再返回看调用规则就可以学会使用了。

夜未深，人未眠，就用上一篇讲到的函数参数配上今天讲的嵌套玩一玩吧，顺便加深下大家的印象。

因为嵌套函数和主函数是使用的相同的函数工作区，所以，varargin和varargout既可以表示为嵌套函数的输入输出变量，也可表示为主函数的输入输出变量。

那该怎么进行区分呢？

这就需要写好程序中的变量声明了，如果嵌套函数在函数声明里包含了varargin或varargout，则在函数内部调用这两个变量时，变量内容为该函数的输入输出变量；如果声明中没有包含，但是在其上层的函数声明有包含，就当在该嵌套函数内部调用这两个变量的时候，变量内容是上层函数的输入输出变量，不知道现在的你有没有被绕晕……，来看程序再理一理吧。

程序

function y=A(x,varargin)

B(nargin,x*rand(4))

    function B(argsIn,z)

        if argsIn>=2

            C(z,varargin{1},4.512,1.729)

        end

        function C(varargin)

            if nargin>=2

                y=varargin{1}

            end

        end

    end

end

结果：



分析：

函数A调用nargin即“B(nargin,x*rand(4))”，表示函数A的输入变量个数，函数C调用的nargin代表的就是函数C的输入变量个数；

在函数A中，函数C嵌套在B中，函数B嵌套在A中，函数B中调用varargin{1}表示的是主函数A传入的第二个变量，因为A的第一个变量是x，之后才是varargin，而在函数C中的varargin{1}表示的就是函数B传给C的第一个变量，即z，也就是A传给B的”x*rand(4)”。

坚持看到这篇文章的你，现在是否已经对这几篇分享的内容有很好的理解了呢？

欢迎关注~