精华内容
下载资源
问答
  • 嵌套函数

    千次阅读 2018-03-30 18:17:09
    Python中一个与众不同的语法就是可以嵌套函数,所谓嵌套,并不像其他语言中的在一个函数中调用另一个函数,而是在定义一个函数的时候,函数体里还能定义另一个函数。 内函数可以访问外函数的作用域,这就是《Python...

    Python中一个与众不同的语法就是可以嵌套函数,所谓嵌套,并不像其他语言中的在一个函数中调用另一个函数,而是在定义一个函数的时候,函数体里还能定义另一个函数。
    内函数可以访问外函数的作用域,这就是《Python基础教程》P105里“它带着它的环境(和相关的局部变量)”及“由于Python的嵌套作用域,来自外部作用域的这个变量,稍后会被内层函数访问”。但是外部函数不能访问内部函数的作用域。

    下面用编程实例来详细说明:

    在func_1()中定义了func_2(),func_2()中又定义了func_3()

    def func_1():
    x1 = “func_1”
    #print(“x1 = %s,x2 = %s,x3 = %s” % (x1,x2,x3))运行此句出现错误
    print(“In func_1: x1 = %s” % x1)

    def func_2():
        x1 = "func_1_redefined"
        #将X2声明为全局变量,这样才可以在其外层函数func_1()中使用
        global x2 
        x2 = "func_2"
        print("In func_2: x1 = %s,x2 = %s" % (x1,x2))
    
        def func_3():
            x3 = "func_3"
            print("In func_3: x1 = %s,x2 = %s,x3 = %s" % (x1,x2,x3))
    
        return func_3()
    
    #调用func_2()使global x2被定义使用
    func_2()
    print("In func_1,again: x1 = %s,x2 = %s" % (x1,x2))
    

    程序分析:
    1)1只能访问自己定义的变量,2可以访问1和2中定义的变量但不能访问3中的变量,3可以访问所有变量;所以内部函数可以访问其外部函数的作用域,但是外部函数不能访问内部函数的作用域。
    2)如果2中的变量被1访问到,可以用gloabl对其声明,但在使用前必须调用2。
    3)若1,2中都有x1,则3中访问到的是2中的x1(离它最近的作用域中的x1),1中的x1不变(不被重新赋值)。

    我的总结:
    当函数实现的功能比较复杂,代码量比较大时,可以对函数进行分片,在这个函数的内部定义实现某一功能的函数,这样做的好处是代码易懂,并且可以对一部分变量封装,避免对变量的误操作。
    书上说“存储子封闭作用域的行为叫做闭包”。

    展开全文
  • python 函数嵌套函数A nested function is simply a function within another function, and is sometimes called an "inner function". There are many reasons why you would want to use nested functions, and ...

    python 函数嵌套函数

    A nested function is simply a function within another function, and is sometimes called an "inner function". There are many reasons why you would want to use nested functions, and we'll go over the most common in this article.

    嵌套函数只是另一个函数中的一个函数,有时也称为“内部函数”。 为什么要使用嵌套函数有很多原因,我们将在本文中介绍最常见的函数。

    如何定义一个嵌套函数 (How to define a nested function)

    To define a nested function, just initialize another function within a function by using the def keyword:

    要定义一个嵌套函数,只需使用def关键字在一个函数中初始化另一个函数:

    def greeting(first, last):
      # nested helper function
      def getFullName():
        return first + " " + last
    
      print("Hi, " + getFullName() + "!")
    
    greeting('Quincy', 'Larson')

    Output:

    输出:

    Hi, Quincy Larson!

    As you can see, the nested getFullName function has access to the outer greeting function's parameters, first and last. This is a common use case for nested functions–to serve as small helper function to a more complex outer function.

    如您所见,嵌套的getFullName函数可以访问外部greeting函数的参数firstlast 。 这是嵌套函数的常见用例-充当较小的辅助函数,成为更复杂的外部函数。

    使用嵌套函数的原因 (Reasons to use nested functions)

    While there are many valid reasons to use nested functions, among the most common are encapsulation and closures / factory functions.

    尽管有许多使用嵌套函数的正当理由,但最常见的是封装和闭包/工厂函数。

    数据封装 (Data encapsulation)

    There are times when you want to prevent a function or the data it has access to from being accessed from other parts of your code, so you can encapsulate it within another function.

    有时您想防止某个功能或其有权访问的数据从代码的其他部分访问,因此您可以封装在另一个功能中。

    When you nest a function like this, it's hidden from the global scope. Because of this behavior, data encapsulation is sometimes referred to as data hiding or data privacy. For example:

    当您嵌套这样的函数时,它对全局作用域是隐藏的。 由于这种行为,数据封装有时被称为数据隐藏数据隐私 。 例如:

    def outer():
      print("I'm the outer function.")
      def inner():
        print("And I'm the inner function.")
      inner()
    
    inner()

    Output:

    输出:

    Traceback (most recent call last):
      File "main.py", line 16, in <module>
        inner()
    NameError: name 'inner' is not defined

    In the code above, the inner function is only available from within the function outer. If you try to call inner from outside the function, you'll get the error above.

    在上面的代码中, inner功能仅可从outer功能中使用。 如果尝试从函数外部调用inner ,则会收到上面的错误。

    Instead, you must call the outer function like so:

    相反,您必须像这样调用outer函数:

    def outer():
      print("I'm the outer function.")
      def inner():
        print("And I'm the inner function.")
      inner()
    
    outer()

    Output:

    输出:

    I'm the outer function.
    And I'm the inner function.

    关闭 (Closures)

    But what would happen if the outer function returns the inner function itself, rather than calling it like in the example above? In that case you would have what's known as a closure.

    但是,如果外部函数返回内部函数本身,而不是像上面的示例那样调用它,将会发生什么? 在这种情况下,您将拥有所谓的闭包。

    The following are the conditions that are required to be met in order to create a closure in Python:

    以下是在Python中创建闭包所需满足的条件:

    These are the conditions you need to create a closure in Python:

    这些是在Python中创建闭包所需的条件:

    1. There must be a nested function

    1.必须有一个嵌套函数

    1. There must be a nested function

    1.必须有一个嵌套函数

    2. The inner function has to refer to a value that is defined in the enclosing scope

    2.内部函数必须引用在封闭范围内定义的值

    2. The inner function has to refer to a value that is defined in the enclosing scope

    2.内部函数必须引用在封闭范围内定义的值

    3. The enclosing function has to return the nested function

    3.封闭函数必须返回嵌套函数

    3. The enclosing function has to return the nested function

    3.封闭函数必须返回嵌套函数

    - Source: https://stackabuse.com/python-nested-functions/

    -来源: https//stackabuse.com/python-nested-functions/

    Here's a simple example of a closure:

    这是一个简单的闭包示例:

    def num1(x):
      def num2(y):
        return x + y
      return num2
    
    print(num1(10)(5))

    Output:

    输出:

    15

    Closures make it possible to pass data to inner functions without first passing them to outer functions with parameters like the greeting example at the beginning of the article. They also make it possible to invoke the inner function from outside of the encapsulating outer function. All this with the benefit of data encapsulation / hiding mentioned before.

    闭包使得可以将数据传递给内部函数,而无需先将其传递给具有本文开头greeting示例之类的参数的外部函数。 它们还可以从封装外部函数的外部调用内部函数。 所有这些都具有前面提到的数据封装/隐藏的好处。

    Now that you understand how and why to nest functions in Python, go out and nest 'em with the best of 'em.

    既然您已经了解了如何以及为什么在Python中嵌套函数,请充分利用'em来嵌套它们。

    翻译自: https://www.freecodecamp.org/news/nested-functions-in-python/

    python 函数嵌套函数

    展开全文
  • MATLAB嵌套函数

    万次阅读 多人点赞 2017-09-20 18:32:00
    嵌套函数的定义嵌套函数,即nested function,就是嵌套在函数体内部的函数。嵌套函数可以出现在一个函数体内部的任何位置,开始以function声明,结束的时候加上end。需要说明的是包含有嵌套函数的函数,无论它是...

    嵌套函数的定义

    嵌套函数,即nested function,就是嵌套在函数体内部的函数。嵌套函数可以出现在一个函数体内部的任何位置,开始以function声明,结束的时候加上end。需要说明的是包含有嵌套函数的函数,无论它是主函数、子函数、嵌套函数,都应该在末尾的地方加上end。下面的代码是一个简单的嵌套函数的例子
    例1

    function r=MyTestNestedFun(input)
    a=5;
    c=sin(input)+tan(input);
    function y=nestedfun(b)
    y=a*c+b;
    end
    r=nestedfun(5);
    end
    >> r=MyTestNestedFun(6)
    
    r =
    
       2.1479
    结果是这样得到的:调用MyTestNestedFun后,程序依次执行a=5;c=sin(input)+tan(input);然后又调用nestedfun这个嵌套函数,此时b=5,而嵌套函数所在的函数中的a,c对嵌套函数是可见的。r=a*c+b=5*(-0.5704)+5=2.1479
    

    嵌套函数种类

    嵌套函数可以分为单重嵌套函数和多重嵌套函数。先说单重嵌套函数,这样的函数嵌套在别的函数体内,自己内部不再有嵌套的函数。如上例示例。一个函数里可以有一个或者多个单重嵌套函数。
        多重嵌套函数,这样的函数嵌套在别的函数体内,同时自己内部又嵌套着别的另一层或几层函数。同样一个函数里可以有一个或者多个多重嵌套函数。如下
    

    例2

    function x=A(p1,p2)
    ...
        function y1=B1(p3)
        ...
            function z1=C1(p4)
            ...
            end
        ...
        end
    ...
        function y2=B2(p5)
        ...
            function z2=C2(p6)_
            ...
                function w=D(p7)
                ...
                end
            end
        end
    end
    该函数A(p1,p2)内部有两个嵌套函数,分别B1(p3)和B2(p5),而B1(p3)和B2(p5)分别是二重和三重嵌套函数。
    

    嵌套函数的变量作用域

    例1

    function r=NestedFunctionVarScopeDemo(a)
    b=a+1;
        function Nested1
        c=b+1;
            function Nested11
                d=c+a;
            end
            Nested11;
        end
    Nested1
    r=d;
    end

    运行上面的代码,譬如

     r=NestedFunctionVarScopeDemo(1)
    
    r =
    
         4
    上述代码有一个二重嵌套函数Nested1,它内部还包含一个嵌套函数Nested11,整个函数的执行过程如下:
    传入变量a=1,计算b的值,b=2;遇到Nested1的函数定义,往下是调用Nested1的语句,进入Nested1之后先计算c的值,即c等于b+1=3。从这里可以看到,在嵌套函数体内,可以访问主函数之内的变量。“c=b+1;”这条语句之后是定义Nested11的函数语句,定义Nested11结束后,是调用Nested11的函数语句。从Nested11的定义来看,这个函数非常简单,仅仅做的是计算d=c+a;从这里可以看出在第二重嵌套函数里,分别访问了Nested1里的变量c和主函数里的变量a。主函数最后一句是从外部访问了第二重嵌套函数里的变量d,并将d赋给r,以此作为主函数的返回值。
        从上面这个嵌套函数的示例可以看出,主函数和嵌套在其内的函数,它们各自的变量是可以互相访问的。但是必须要注意的是,嵌套函数访问主函数的变量,可以在函数定义里直接拿过来用,而主函数访问嵌套在其内的函数里的变量则必须要经过调用之后才能用。譬如上例主函数访问Nested11里的d,是经过在主函数里调用Nested1,而在Nested1里又调用Nested11后才成功的,否则是不行的。
    

    例2

    function r=NestedFunctionVarScopeDemo2(a)
    b=a+1;
        function Nested1
            c=b+1;
            c1=10;
            function Nested11
                d=c+a;
            end
        end
    Nested1
    e=c1
    r=d;
    end

    运行得到如下结果

     r=NestedFunctionVarScopeDemo2(1)
    e =
    
        10
    
    未定义函数或变量 'd'。
    
    出错 NestedFunctionVarScopeDemo2 (line 12)
    r=d;
    在调用NestedFunctionVarScopeDemo2时候发生了错误。从提示来看,是没有定义变量“d”。这是因为调用Nested1后执行了Nested1里的语句,但是Nested1中只是定义了Nested11,而并没有调用它的语句。因此,外界不能访问d。这就是为什么e=c1;可以成功而r=d;报错的原因了。
    上面讨论了嵌套函数和主函数之间变量互相访问的情况(包括主函数也是嵌套函数的情况)。那么不同的嵌套函数之间呢?如下例
    

    例3

    function r=NestedFunctionVarScopeDemo3(a)
    b=a+1;
        function Nested1
            c=b+1;
            c1=10;
            Nested2;
            c2=d^2;
        end
        function Nested2
            d=2*b;
        end
    Nested1
    r=c2
    end
    该函数里面包含两个嵌套函数,都是单重的,一个是Nested1,一个是Nested2。本例是想验证,是否直接从Nested1中通过调用Nested2来访问其中的变量。经过运行得到下面的结果:
    
    >> r=NestedFunctionVarScopeDemo3(1)
    未定义函数或变量 'd'。
    
    出错 NestedFunctionVarScopeDemo3/Nested1 (line 7)
            c2=d^2;
    
    出错 NestedFunctionVarScopeDemo3 (line 12)
    Nested1
    从错误提示来看,出错原因是访问变量“d”不成功,“d”未定义,所以彼此没有嵌套关系的嵌套函数是不能简单得共享变量的,如果非要共享,只能通过他们所在的主函数来进行。
    

    嵌套函数彼此调用关系

    主函数和嵌套函数之间

    这里的主函数包括最上层的主函数,即不嵌套在任何函数里的函数以及本身是嵌套函数,但同时内部还嵌套有其他函数的函数。因为这些函数相对嵌套在内的函数来说也是主函数。这样的情形下,调用关系遵循下面的原则:
    

    主函数可以调用嵌套在其中的第一重嵌套函数而不能调用第二重或者更深重的嵌套函数;无论第几重嵌套函数,都可以调用主函数或者主函数的主函数等等
    如下例

    function r=NestedFunctionCallDemo1(a)
    b=a+1;
        function c1=Nested1(x)
            c=b+1;
            c1=10+c*x;
            function d=Nested11
                d=c+a;
            end
        end
    c1=Nested1(1);
    r=Nested11;
    end
    本例呈现的是主函数调用子函数的例子。又上例可以看出。在主函数NestedFunctionCallDemo1中分别对Nested1和Nested11进行了调用。运行结果如下:
    
     r=NestedFunctionCallDemo1(1)
    
    c1 =
    
        13
    
    未定义函数或变量 'Nested11'。
    
    出错 NestedFunctionCallDemo1 (line 11)
    r=Nested11;

    从结果来看,调用Nested1成功,而调用Nested11没有成功。这验证了主函数可以调用嵌套在其中的第一重嵌套函数,而不能调用第二重或者更深重的嵌套函数
    下例为嵌套函数调用主函数的例子

    function NestedFunctionCallDemo2(flag)
    switch flag
        case 1
            disp('flag=1');
            return;
        case 2
            disp('flag=2');
            NestedFun1
        case 3
            disp('flag=3');
            return
        otherwise
            disp(['flag=',num2str(flag)]);
            return
    end
        function NestedFun1
            NestedFunctionCallDemo2(1);
            NestedFun2
            function NestedFun2         NestedFunctionCallDemo2(3)
            end
        end
    end       

    运行上述代码,得到下面结果

    >> NestedFunctionCallDemo2(2)
    flag=2
    flag=1
    flag=3

    当flag=2时,执行的是NestedFun1,而在NestedFun1中调用了主函数,这时候flag=1;因此此时显示“flag=1”,接下来在NestedFun1中对NestedFun2进行了调用。而NestedFun2对最外层的主函数来说是一个二重嵌套函数,同样它也调用了NestedFunctionCallDemo2,只不过flag=3,因此显示“flag=3”。从上例可以看出,嵌套函数对主函数的调用是可以的。

    不同的嵌套函数之间

    这里讨论的不用嵌套函数之间指的是嵌套深度相同或者不同,彼此之间没有嵌套与被嵌套关系的不同的嵌套函数。譬如位于第一层的不同嵌套函数之间,以及位于第二层的不同嵌套函数之间,等等。如下例
    

    嵌套函数调用示例1

    function NestedFunctionCallDemo3
    Nested1(5)
        function Nested1(x)
            disp(['Nested1 执行,输入:',num2str(x)]);
            Nested2(6)
            function Nested11(xx)
                disp(['Nested11 执行,输入:',num2str(xx)]);
            end
        end
        function Nested2(y)
            disp(['Nested2 执行,输入:',num2str(yy)]);
            function Nested22(yy)
                disp(['Nested22 执行,输入:',num2str(yy)]);
            end
        end
    end

    运行结果如下:

    Nested1 执行,输入:5
    Nested2 执行,输入:6
    从上面结果来看,Nested1执行后成功调用Nested2这说明第一层的嵌套函数之间是可以互相调用的。
    

    嵌套函数调用示例2

    function NestedFunctionCallDemo4
    Nested1(5)
        function Nested1(x)
            disp(['Nested1 执行,输入:',num2str(x)])
            Nested11(6)
            function Nested11(xx)
                disp(['Nested11 执行,输入:',num2str(xx)])
                Nested2(pi)
                Nested22(10);
            end
        end
        function Nested2(y)
            disp(['Nested2 执行,输入:',num2str(y)])
            Nested22(pi*pi)
            function Nested22(yy)
                disp(['Nested22 执行,输入:',num2str(yy)])
            end
        end
    end

    运行代码,得到

    >> NestedFunctionCallDemo4
    Nested1 执行,输入:5
    Nested11 执行,输入:6
    Nested2 执行,输入:3.1416
    Nested22 执行,输入:9.8696
    未定义函数或变量 'Nested22'。
    
    出错 NestedFunctionCallDemo4/Nested1/Nested11
    (line 9)
                Nested22(10);
    
    出错 NestedFunctionCallDemo4/Nested1 (line 5)
            Nested11(6)
    
    出错 NestedFunctionCallDemo4 (line 2)
    Nested1(5)
    从上面的执行情况可以看出函数Nested11成功被调用,而且Nested11再调用Nested2时也成功了,通过Nested2,间接调用了Nested22,但是从Nested11中直接调用Nested22却没有成功。说明第二重调用可以调用不包含它的第一重嵌套函数。
    

    嵌套函数调用3

    function NestedFunctionCallDemo5
    Nested1(5)
        function Nested1(x)
            disp(['Nested1 执行,输入:',num2str(x)])
            Nested11(6)
            function Nested11(xx)
                disp(['Nested11 执行,输入:',num2str(xx)])
                Nested111(pi)
                function Nested111(xxx)
                    disp(['Nested111 执行,输入:',num2str(xxx)]);
                    Nested2(exp(1))
                    Nested22(100)
                end
            end
        end
        function Nested2(y)
            disp(['Nested2 执行,输入:',num2str(y)])
            Nested22(pi*pi)
            function Nested22(yy)
                disp(['Nested22 执行,输入:',num2str(yy)])
            end
        end
    end

    运行代码结果为:

    Nested1 执行,输入:5
    Nested11 执行,输入:6
    Nested111 执行,输入:3.1416
    Nested2 执行,输入:2.7183
    Nested22 执行,输入:9.8696
    未定义函数或变量 'Nested22'。
    
    出错
    NestedFunctionCallDemo5/Nested1/Nested11/Nested111
    (line 12)
                    Nested22(100)
    
    出错 NestedFunctionCallDemo5/Nested1/Nested11
    (line 8)
                Nested111(pi)
    
    出错 NestedFunctionCallDemo5/Nested1 (line 5)
            Nested11(6)
    
    出错 NestedFunctionCallDemo5 (line 2)
    Nested1(5)
    从上面的执行情况可以看出,函数Nested1执行后,函数Nested11成功被调用,而且Nested11在调用Nested111,Nested111在调用Nested2时也成功了;通过Nested2,Nested111间接调用了Nested22,但是从Nested111直接调用Nested22却没有成功。这说明第三重嵌套函数,不可以调用不包含它的第二重嵌套函数。
    

    嵌套函数调用关系总结

    为了方便理解。可以将上述调用情况进行类比
    具体如下
    

    将主函数看成“父亲”,嵌套函数依据嵌套深度可以看成“儿子”,“孙子”,“重孙子”,等等。
    父亲可以求助儿子,儿子可以求助父亲。即父子可以互相求助。一个人不能求助孙子,重孙等后代,但是可以求助自己的祖宗(祖父、曾祖父等等)。一个人可以求助自己亲兄弟,或者叔叔、伯伯但不能求助侄儿

    展开全文
  • Python 嵌套函数

    万次阅读 多人点赞 2017-06-28 21:35:37
    在 Python 中,函数的用法可谓是千变万化,只不过我们平日接触的大多是一些基本用法。函数强大之处当然不止于此,它还有很多高级用法 - 闭包、...这些高级用法都与嵌套函数紧密相关,所以有必要先熟悉一下嵌套函数

    简述

    在 Python 中,函数的用法可谓是千变万化,只不过我们平日接触的大多是一些基本用法。函数强大之处当然不止于此,它还有很多高级用法 - 闭包、装饰器。。。

    这些高级用法都与嵌套函数紧密相关,所以有必要先熟悉一下嵌套函数。

    | 版权声明:一去、二三里,未经博主允许不得转载。

    嵌套函数

    嵌套函数(Nested function)是在另一个函数(即:封闭函数)中定义的函数

    嵌套函数的基本概念在前面已经介绍过了,参见:Python 函数的高级用法

    那么,一般在什么情况下使用嵌套函数?

    • 封装 - 数据隐藏
    • 贯彻 DRY 原则
    • 闭包

    除此之外,嵌套函数还有其他用法,只不过这些是比较常用的。另外,闭包的内容较为丰富,后面做单独分享。

    封装 - 数据隐藏

    可以使用内层函数来保护它们不受函数外部变化的影响,也就是说把它们从全局作用域隐藏起来。

    来看一个简单的例子 - 求一个数字 n 的倍数:

    >>> def outer(n):
    ...     def inner_multiple(n):  # 从外部代码隐藏
    ...         return n * 2
    ...     num = inner_multiple(n)
    ...     print(num)
    ... 
    >>>

    尝试调用 inner_multiple(n) 会引发错误:

    >>> outer(5)
    10
    >>> 
    >>> inner_multiple(5)  # 外部无法访问
    ...
    NameError: name 'inner_multiple' is not defined

    这是因为它被定义在 outer() 的内部,被隐藏了起来,所以外部无法访问。

    Python 递归函数 一节中,分享过一个关于阶乘的递归实现,但是存在一个问题 - 没有做容错处理。

    下面来利用嵌套函数,对递归做一个更好的实现:

    >>> def factorial(n):
    ...
    ...     # 错误处理
    ...     if not isinstance(n, int):  # 仅限整形
    ...         raise TypeError("Sorry. 'n' must be an integer.")
    ...     if n < 0:  # 仅限 0 和 正数
    ...         raise ValueError("Sorry. 'n' must be zero or positive.")
    ...     
    ...     def inner_factorial(n):
    ...         if n <= 1:
    ...             return 1
    ...         return n * inner_factorial(n - 1)
    ...     return inner_factorial(n)
    ... 
    >>> 

    这样以来,程序就会变得更加健壮,当数据类型或值不合理时,便会引发错误:

    >>> factorial('Py')  # 类型错误
    ...
    TypeError: Sorry. 'n' must be an integer.
    >>> 
    >>> factorial(-10)  # 值错误
    ...
    ValueError: Sorry. 'n' must be zero or positive.
    >>> 
    >>> factorial(5)  # OK
    120

    使用这种模式的主要优势在于:利用外部函数执行所有的参数检查,便可以在内部函数中跳过错误检查,并安全放心地进行使用。

    贯彻 DRY 原则

    DRY(Don’t Repeat Yourself)- 是指在程序设计以及计算中避免重复代码,因为这样会降低灵活性、简洁性,并且有可能导致代码之间的矛盾。

    DRY 更多的是一种架构设计思想,在软件开发过程中的万事万物均可能重复,大到标准、框架、开发流程;中到组件、接口;小到功能、代码均纯存在自我重复。而 DRY 提倡的就是在软件开发过程中应消除所有这些自我重复。

    如果看过《程序员修炼之道》,想必对这一思想有所了解,那里面做了很好的阐述。

    例如,处理文件时,需要支持打开的文件对象和文件名,传统方式是采用两个函数分别实现。

    支持文件对象:

    >>> def print_file(f):
    ...     for line in f:
    ...         print(line)
    ... 
    >>> f = open('data.txt', 'r')
    >>> print_file(f) 
    Hi, all
    
    I am a Pythonista
    
    >>> 

    支持文件名:

    >>> def print_file_content(file_name):
    ...     if isinstance(file_name, str):
    ...         with open(file_name, 'r') as f:
    ...             for line in f:
    ...                 print(line)
    ... 
    >>> print_file_content('data.txt')
    Hi, all
    
    I am a Pythonista
    
    >>> 

    很显然,有很多代码可以复用,通过嵌套函数来实现:

    >>> def print_file(file):
    ...     def inner_print(file_process):
    ...         for line in file_process:
    ...             print(line, end = '')
    ...     
    ...     if isinstance(file, str):
    ...         with open(file, 'r') as f:
    ...             inner_print(f)
    ...     else:
    ...         inner_print(file)
    ... 
    >>>

    这样,一个函数便可以支持多种方式,简洁很重要。

    >>> f = open('data.txt', 'r')
    >>> print_file(f)
    Hi, all
    I am a Pythonista
    >>> 
    >>> print_file('data.txt')
    Hi, all
    I am a Pythonista

    除此之外,通常也会把 inner_print() 作为一个顶层私有函数,但是若想要将其作为一个内层函数隐藏起来,就用嵌套函数。

    展开全文
  • c++ 函数中嵌套函数No, you can’t. 不,你不能。 We can’t define functions inside other functions in C. 我们无法在C中的其他函数中定义函数。 With languages like JavaScript, Swift or Python it is ...
  • 嵌套函数和闭包

    千次阅读 2019-08-02 01:52:48
    嵌套函数 嵌套函数,就是指在某些情况下,您可能需要将某函数作为另一函数的参数使用,这一函数就是嵌套函数。 在一个函数被调用的过程中又调用另一个函数,这就是函数的嵌套调用。如果是函数本身嵌套调用函数本身,...
  • 函数内嵌和嵌套函数

    2020-03-31 23:16:09
    嵌套函数不能在外部声明 可以将嵌套函数的地址传递给其他函数,并由其他函数调用,就好像可以传递其他局部变量的地址 嵌套哈数和父函数可访问同样地变量,但只能访问比钱凹函数声明枣的局部变量 嵌套函数可以...
  • python函数中的嵌套函数
  • MATLAB嵌套函数练习

    2020-11-30 22:39:03
    嵌套函数:把一个或多个子函数放在同一个主函数的函数体内部而构成的函数称为嵌套函数,一般形式如下: 1.单层嵌套 %一嵌一 function x = A(p1,p2) ... function y = B(p3) ... end ... end %一嵌多 function ...
  • Oracle 嵌套函数

    2019-03-08 21:06:56
    单行函数可以嵌套。 嵌套函数的执行顺序是由内到外。
  • JS 嵌套函数

    千次阅读 2018-07-24 10:43:08
    转载请注明出处:... 定义 JS可以在函数体中定义新的函数,这个新的函数称之为嵌套函数 代码实例 function isSumLess(arrA, arrB){ function sum(arr){ var s=0; for(var i=0; i&lt;arr.lengt...
  • 嵌套函数与闭包

    2020-03-27 15:10:34
    文章目录嵌套函数封装 - 数据隐藏贯彻 DRY 原则闭包产生闭包的条件自由变量存放在呢?变量作用域 嵌套函数 嵌套函数(Nested function)是在另一个函数(即:封闭函数)中定义的函数 那么,一般在什么情况下使用...
  • 嵌套函数 定义时 先判断function_exists 防止 递归调用外部函数 导致两次定义内部 函数 导致致命错误 看一下PHP手册中是如何说的: function foo() { function bar() { echo "I don't exist until foo() is ...
  • MATLAB嵌套函数的应用

    万次阅读 2017-09-20 21:39:24
    嵌套函数的应用
  • Python3 嵌套函数

    2018-07-12 15:48:00
    嵌套函数: 函数体内用def定义函数 注意:函数体中调用其他函数不算嵌套函数,只能是函数的调用 简单的嵌套函数: 输出结果: 转载于:https://www.cnblogs.com/bert227/p/9299840.html...
  • javascript当中嵌套函数

    2019-08-21 17:32:58
    3)嵌套函数 例 3.3.1 <head> <meta http-equiv="content-type" content="text/html; charset=utf-8"/> </head> <script> function outerFun(){ var i = 0; function inn...
  • python中的嵌套函数和类

    千次阅读 2020-04-03 20:06:14
    文章目录1 嵌套函数1.1 嵌套函数的定义1.2 关键字2 类2.1 类的定义2.2 实例属性和方法2.3 类属性和方法2.4 del和call方法2.4.1 del()析构方法2.4.2 __call__方法 1 嵌套函数 1.1 嵌套函数的定义 嵌套函数是在函数...
  • js调用嵌套函数

    千次阅读 2019-08-14 10:18:58
    js调用嵌套函数 js的函数是可以嵌套的,那么怎么来调用嵌套函数呢?代码如下: function foo() { var x = 1; function bar() { var y = x + 1; console.log(y); } console.log(x); } 在这里,该如何调用bar()...
  • 嵌套函数 文章目录嵌套函数嵌套函数的定义:函数之间的调用练习练习一2,练习二练习三练习四 嵌套函数的定义: 函数嵌套就是在函数内部定义子函数。 例如: def go(): print("ABC") def ins(): print("EFG") ...
  • Python基础之嵌套函数

    千次阅读 2019-03-18 20:26:22
    嵌套函数即在函数内部定义函数并使用,需要注意:1.外部函数的变量可以被内部函数所使用,但不能被内部函数修改,若要修改需要添加关键字nonlocal 嵌套函数作用: 1.封装-数据隐藏:外部无法访问“嵌套函数”, 2...
  • 我在昨天的文章中(零基础学习 Python 之函数对象)说过,函数不单单可以作为对象来传递,还可以在一个函数里面嵌套一个函数,这个就是我们今天要讲的嵌套函数嵌套函数 首先我们来看一个例子: &gt;&gt;&...
  • Scala 函数 - 嵌套函数

    2018-09-15 00:41:40
    Scala允许您定义函数内部的函数,而在其他函数中定义的函数称为局部...尝试以下程序来了解如何实现嵌套函数。 示例 object Demo { def main(args: Array[String]) { println( factorial(0) ) println( fact...
  • python嵌套函数

    千次阅读 2017-03-11 15:27:32
    嵌套函数里面两个重要的概念:变量作用域和函数闭包 1. 变量作用域  内部函数可以直接读取访问外部函数变量,但是不能修改;访问规则是从内到外函数逐级寻找变量 #!/usr/bin/env python def outer...
  • GCC嵌套函数定义 参考文献: https://gcc.gnu.org/onlinedocs/gcc-8.1.0/gcc/Nested-Functions.html 嵌套函数是定义在另一个函数内部的函数。嵌套函数在GNU C中被支持作为扩展,但是GNU c++不支持, 嵌套函数的名称...
  • python3的嵌套函数

    千次阅读 2018-11-19 19:28:42
    背景 最近在学python3 ...嵌套函数 顾名思义,即使在函数中还有函数,实现了函数的多级嵌套 def test1(): age = 10 print(age) def test2(): te = 5 print(age) def test3(): print(te) te...
  • python中的递归函数和嵌套函数递归函数嵌套函数 递归函数 递归函数指的是:自己调用自己的函数,在函数体内部直接或间接的自己调用自己。递归类似于大家中学数学学习过的“数学归纳法”。每个递归函数必须包含两个...
  • Java script的嵌套函数、递归函数

    千次阅读 2015-05-01 19:45:21
    1.嵌套函数: script的嵌套函数、递归函数" title="Java script的嵌套函数、递归函数" style="margin:0px; padding:0px; border:0px; list-style:none"> 2.递归函数 script的嵌套函数、递归函数" title="Java...
  • Oracle DB 嵌套函数

    千次阅读 2013-10-18 23:57:31
    嵌套函数 • 单行函数可以嵌套到任意层。 • 嵌套函数的计算顺序是从最内层到最外层。 单行函数可以嵌套到任意深度。嵌套函数的计算顺序是从最内层到最外层。下面的一些示例显示这类函数的灵活性。 嵌套...
  • 嵌套函数与全局变量

    2018-08-31 15:52:34
    本次记录全局变量在嵌套函数中的使用与函数调取中需要注意的内容。 全局变量 global; 示例:1】 def fun():  x=2  def fun2():  print x  return x  return fun2 fun()() 运行结果: 若执行fun2(),则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 436,002
精华内容 174,400
关键字:

怎么嵌套函数