函数嵌套-名称空间与作用域-函数对象-闭包函数

一、可变长度参数*的应用场景

    def sum2(*args):    #args=(1,2,3)
        res=0
        for num in args:
            res+=num
        return res

    print(sum2(1,2,3,4,5,6,7))

    ** 的应用场景
    def auth(name,pwd,**kwargs):
        print(name)
        print(pwd)
        print(kwargs)

    auth(name='egon',pwd='123',group='group1')

二、命名关键字参数
    什么是命名关键字参数？
    格式：在*后面参数都是命名关键字参数
    特点：
        1 必须被传值
        1 约束函数的调用者必须按照key=value的形式传值
        2 约束函数的调用者必须用我们指定的key名
        使用方式auth(name="egon",pwd="123")
        :param args:
        :param kwargs:
        :return:
        """
        # print(args,kwargs)
        if len(args) !=0:
            print('必须用关键字的形式传参')
            return
        if 'name' not in kwargs:
            print('必须用指定的key名name')
            return
        if 'pwd' not in kwargs:
            print('必须用指定的key名pwd')
            return

        name=kwargs['name']
        pwd=kwargs['pwd']
        print(name,pwd)

    auth('egon','123')
    auth(name='egon',pwd='123') #约束函数的调用者必须用key=value的形式传值
    auth('egon',pwd='123')
    auth(name='egon',pwd='123')
    auth('egon',123)

    auth(x='egon',y='123')
    print(help(auth))

三、函数的嵌套调用：在函数内又调用了其他函数
        def max2(x,y):
            if x > y:
                return x
            else:
                return y

        def max3(x,y,z):
            res1=max2(x,y)
            res2=max2(res1,z)
            return res2

        print(max3(11,199,2))

四、函数的嵌套定义：在函数内又定义其他函数

        def f1():
            print('f1')
            def f2():
                print('f2')
                def f3():
                    print('f3')
                f3()
            f2()
        f1()

        '''
        f1
        f2
        f3
        '''

五、名称空间：存放名字与值绑定关系的地方
        二:名称空间分为三类

        1 内置名称空间:存放Python解释器自带的名字，在解释器启动时就生效，解释器关闭则失效


        2、全局名称空间：文件级别的名字,在执行文件的时候生效，在文件结束或者在文件执行期间被删除则失效
        x=1
        def func():
            name='egon'

        del func

        3、局部名称空间:存放函数内定义的名字(函数的参数以及函数内的名字都存放与局部名称空间)，
            在函数调用时临时生效，函数结束则失效
        def func(x):
            y=2

        func(1)

        重要特别注意：
            加载顺序：内置名称空间-》全局名称空间-》局部名称空间
            查找名字：局部名称空间-》全局名称空间-》内置名称空

六、作用域
        全局作用域：包含的是内置名称空间与全局名称空间的名字，
        特点
        1在任何位置都能够访问的到
        2该范围内的名字会伴随程序整个生命周期

        局部作用域：包含的是局部名称空间的名字
        特点：
        1、只能在函数内使用
        2、调用函数时生效，调用结束失效


七、函数在python中是第一类对象？

    1、func可以被引用
        f=func
        
    2、func可以当作参数传给x
        def bar(x):
            print(x)
            x()
        bar(func)
    3、func还可以当作返回值
        def bar(x): # x=func
            return x #return func
        
        res=bar(func) #res=func
        # print(res)
        res()
    4 可以当中容器类型的元素
        def auth():
            print('登陆。。。。。')
        def reigster():
            print('注册。。。。。')
        def search():
            print('查看。。。。')
        def transfer():
            print('转账。。。。')
        def pay():
            print('支付。。。。')
        dic={
            '1':auth,
            '2':reigster,
            '3':search,
            '4':transfer,
            '5':pay
        }
        
        def interactive():
            while True:
                print("""
                1 认证
                2 注册
                3 查看
                4 转账
                5 支付
                """)
                choice=input('>>: ').strip()
                if choice in dic:
                    dic[choice]()
                else:
                    print('非法操作')
        interactive()
        l=[auth,reigster,search,interactive]
        print(l)

八、闭包函数

    闭：指的是定义在函数内部的函数
        ！！！作用域关系 在函数定义阶段就规定死了，与调用位置无关
        def outter():
            x=2
            def inner():
                # x=1
                print('from inner',x)
        
            return inner
        
        def foo():
            x=1111111111111111111111111111
            f()
        
        foo()
        
    闭包函数：
        1、定义在函数内部的函数
        2、 并且该函数包含对外部函数作用域中名字的引用，该函数就称为闭包函数
        
        def outter():
            name='egon'
            def inner():
                print('my name is %s' %name)
        
            return inner
        
        
        f=outter()

    了解：
        为函数体传值的方式
        方式一：将值以参数的形式的传入
        import requests
        
        def get(url):
            response=requests.get(url)
            if response.status_code == 200:
                print(response.text)
        
        get('https://www.baidu.com')
        
        方式二：
        import requests
        import time
        
        def outter(url): #url='https://www.baidu.com'
        
            # url='https://www.baidu.com'
            def get():
                response=requests.get(url)
                if response.status_code == 200:
                    print(response.text)
        
            return get

        baidu=outter('https://www.baidu.com')
        python=outter('https://www.python.org')
        
        baidu()      
        baidu()
        python()