zoukankan      html  css  js  c++  java
  • python之路之函数03

     一  首先我们学到函数的嵌套调用与定义:

    1 函数嵌套
    # def f1():
    #     print(f1)#我们这里如果输入f1那么输出的则是f1这个变量(函数)所在的地址。如果输入一个字符的话那么就直接输出该字符
    #     def f2():
    #         print(f2)
    #         def f3():
    #             print(f3)
    #         f3()
    #     # f2()
    # f1()
    那么我们在调用时,必须由外到内,也就是说我们如果想调用f3那么我们必须先通过f1才可以

    2 函数的嵌套调用
    在函数内又调用了其他函数。
    def max2(x,y):
         if x>y:
             return x
         else:
             return y
     print(max2(2,3))
    
     def max3(x,y,z):
         res1=max2(x,y)
         res2=max2(res1,z)
         return res2
     res2=max3(1,2,6)
     print(res
    二  名称空间    namespace
    1. 名称空间顾名思义就是存放名字与值绑定关系的地方。
    2. 名称空间分为三类:
    (1)内置名称空间
    存放python解释器自带的名字,如print(),len()等。
    当解释器一启动就会生效,也就是说就可以对其进行调用

    (2)全局名称空间
    用来存放文件级别的名字,只要不在函数里面都叫全局变量。
    只在文件执行的时候生效,在文件结束或者文件执行期间被删除则失效。
    假如我们定义一个:
    x=1
     def func():
         name='egon'
     del func#将func删除,
     print('====')
    
     x=1
     def f1():
         def f2():
             print(x)
         f2()
     f1()
     输出结果为1
     (3)局部名称空间

    用来存放函数内定义的名字,(函数的参数以及函数内的名字都存放于局部名称空间)。
    只在函数调用时执行时短暂生效,函数调用结束则失效。

    那么对于这三种名称空间,他们加载的顺序就是也就是他们在程序运行的一个加载先后顺序:
    内置名称空间---〉全局名称空间---〉局部名称空间
    那么查找在程序运行过程中查找的顺序是跟加载顺序相反的:
    也就是:局部名称空间--〉全局名称空间---〉内置名称空间

    作用域:作用域顾名思义就是作用的范围。
    也就是函数所能访问到的范围:

    全局作用域:
    那么对于内置名称空间和全局名称空间来说,他们具有全局作用域,该范围内的名字会伴随程序整个运行周期,
    也就是说程序不结束,那么在任何地方都能调用。

    局部作用域:
    只是包含局部的名称空间的名字,所以局部作用域只能在函数内部使用,调用函数时生效,调用结束后失效。


    三 函数在python中是第一类对象(相当于变量)

    1 可以被引用,像变量一样被引用:

    变量
     x=1
     y=x
    
      函数
         print('from')
     def bar():
     f=bar#这个时候bar作为一个变量赋给f,那么f()就相当于bar()。
     f()
    
    '''
    
    def foo():# foo=<function .... x1238102391203>
        print('from foo')
    
     print(foo)
     x=foo
     print(x)
    
     l=[foo,]
     print(l)
    
    def print_msg(x):
        # print(x)
        return x
    a='sdfasdfasdfasdfadsf'
    res=print_msg(foo)
    print(res)
    
    '''


    2 可以当作参数传入:

     def func(a):#我们定义func为有参函数。
         a+=1
         print(a)
     func(x)
    
     def bar():
         print('from bar,1')
     def wrapper(func):#这一步相当于fun=bar
         func()#那么相当于bar()
    
     wrapper(bar)#在这个过程就相当于调用函数wrapper(),我们把函数名bar传入,那么就相当于我们运行bar函数


    3可以当作函数的返回值:

    1#
    x=1 def foo(): return x#直接将返回值传给foo res=foo() print(res)
    2#
    x=1
    def foo():              那么我们可以看出13与2#输出的结果是相同的。返回值会返回给函数本身。
    print(x)
    foo()
    作为变量将x赋给foo() def bar(): print('from bar') def foo(func): return func print(bar) f=foo(bar) print(f) f() print(foo)#直接输出变量名,那么我们输出的是变量名所在的地址 x=1 print(x,id(x))

    4 可以当作容器类型的元素。
    x=1
     l=[x]
     print(l)
    
     def get():
         print('from get')
     def put():
         print('from put')
     l=[get,put]
     print(l)
     l[0]()

    程序实例
    def auth():
         print('登录。。。。')
     def register():
         print('注册')
     def search():
         print('查看。。')
     def pay():
         print('支付。。')
    
     dic={
         '1':auth,
         '2':register,
         '3':search,
         '4':pay,
     }
     print(dic)
     def interactive():
         while True:
             print('''
             1 登陆
             2 注册
             3 查看
            4 支付''')
             choice=input('请输入编号:').strip()
             if choice in dic:
                 dic[choice]()
             else:
                 print('非法输入!')
    
     interactive()
     l=[auth,register,search,]
     print(l)
    View Code

    四 闭包函数

    闭:指的是定义在函数内部的函数。
    作用域:在函数定义阶段就规定死了,与调用位置无关,不管在哪使用都要到原函数定义位置去找。
    def outter():
        x=2
        def inner():
            x=1
            print('from inner',x)
    
        return inner#在这里我们返回inner就是为了得到inner这个函数,而outter只是起到一个包裹作用。
    
    f=outter()#在调用函数outter时,将inner返回给outter这个函数名,也就是f=inner。
    print(f)#输出的为变量inner,也就是inner所对应的地址。
    f()#当我们把x=1注释掉之后,会变成x=2。
    def foo():
        x=122323
        f()
    foo()

    闭包函数:
    1、定义在函数内的函数
    2、并且该函数包含对外部函数作用域中名字的引用,该函数成为闭包函数。比如上述函数中inner引用了outer中的变量x。
    
    
    闭包函数说白了就是将一个函数包进另一个函数里面,而且外层函数会给内层被包含函数定义好值,所以内部函数需要值时候先去自己所在层找。
    找不到就去外层函数找,但是一般不会到全局找,因为全局变量大家都可以引用,所以闭包函数外层函数专门给闭包函数传值。
    传值目的就是为了得到闭包函数的执行结果,所以return。
     闭包函数包含对外部作用域的引用而非全局作用域的引用
    在被包函数的头上,定义一个变量。
     
     
  • 相关阅读:
    Python 类中方法的内部变量,命名加'self.'变成 self.xxx 和不加直接 xxx 的区别
    用foreach遍历 datagridView 指定列所有的内容
    treeView1.SelectedNode.Level
    YES NO 上一个 下一个
    正则 单词全字匹配查找 reg 边界查找 精确匹配 只匹配字符 不含连续的字符
    抓取2个字符串中间的字符串
    sqlite 60000行 插入到数据库只用不到2秒
    将多行文本以单行的格式保存起来 读和写 ini
    将秒转换成时间格式
    richtextbox Ctrl+V只粘贴纯文本格式
  • 原文地址:https://www.cnblogs.com/zhangsanfeng/p/8667055.html
Copyright © 2011-2022 走看看