• 函数的进阶


    一、动态参数

    def func(): # 形参

      pass

    func() # 实参

    args和 kwargs 是可以更换的,但是程序员约定都用它

    用途:在不明确接受参数,数量时使用*args和**kwargs

    def func(*args):
        print(args)
    func(1,2,3,)
    #结果   (1,2,3)是一个元祖
    def func(a,b,c,*args):  # 在形参位置*叫做聚合
        print(a,b,c)
        print(args)   # 元组形式
    func(1,2,3,4,5,9,6,7,8)
    
    #结果:
    1 2 3
    (4, 5, 9, 6, 7, 8)
    位置参数 > 动态的位置参数
    def func(**kwargs): # 动态默认参数  #形参的时候**聚合
        print(kwargs)  # 字典
    
    func(a=1,b=2,c=3) # 关键字的形式传参
    
    #结果: {'a': 1, 'b': 2, 'c': 3} 
    def func(*args,**kwargs):    #动态参数 > 动态默认参数
        print(args,kwargs)
    func(1,2,3,a=1,b=2,c=3)
    
    #结果:
    (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
    动态参数 > 动态默认参数
    def func(a,b,*args,**kwargs):     #位置参数 > 动态参数  > 动态默认参数
        print(a,b)
        print(args,kwargs)
    func(1,2,3,4,5,d = 2,e = 3,f = 4)
    #结果:
    1 2
    (3, 4, 5) {'d': 2, 'e': 3, 'f': 4}

    位置参数 > 动态参数  > 动态默认参数

    def func(a,b,*args,x = 66 ,y = 666 ,z = 6,**kwargs):
        print(a,b)
        print(x,y,z)
        print(args,kwargs)
    func(1,2,3,4,5,6,d = 2,e = 3,f = 4)
     
    #结果:
    1 2
    66 666 6
    (3, 4, 5, 6) {'d': 2, 'e': 3, 'f': 4}
    View Code
    args 和kwargs

     

    形参: 位置 > 动态位置 > 默认参数 > 动态默认参数

    实参: 位置 > 关键字参数

    在实参调用的时候 *将可迭代的对象打散,字典是将键取出

    在形参处出现*就是在聚合

    在实参调用的时候 **将字典打散成  关键字参数(键=值)

    在形参处出现**就是将关键字参数聚合成一个字典

    def func(*args,**kwargs): # * 聚合
        print(*args) # args = ()  *args = 1 2 3  *打散
        print(*kwargs) # args = ()  **kwargs = a,b  *打散 字典的键
    func(1,2,3,a=4,b=5)
    
    #结果:1 2 3
          #a b
    li = [1,2,3,5,4]
    
    def func(*args):  # 聚合 (1,2,3,5,4)
        print(args)
        print(*args)  # 打散 1,2,3,5,4
    func(*li)         # 1,2,3,5,4

     

    dic = {'a':1,'b':2}
    def func(*args,**kwargs):  
        print(args,*kwargs)    #() a b
    func(**dic)                # 将键打散

    二、函数的注释

    def log(user,pwd):

        """

        登录函数

        :param user: 用户名

        :param pwd: 密码

        :return: 校验后的账号和密码

        """

        print(111)

    # print(log.__doc__)

    #简单了解

    # print(log.__name__) # 反射

    三、名称空间

    1.内置空间中所有代码  -- 内置空间

    2.自己写的py文件      -- 全局空间

    3.函数中的代码        -- 局部空间

    a = 10
    
    def func():
        a = 1
        print(a)
    func()
    print(a)   
    #      1       10

    # 加载顺序:

    1.内置空间       2.全局空间      3.局部空间

    # 取值顺序:

    1.局部空间      2.全局空间    3.内置空间      4.找不到就报错

    # 作用域:

    1.全局作用域  内置+全局 = 全局作用域

    2.局部作用域  函数内的就是局部作用域

    四、函数的嵌套

    函数嵌套内,从最里层返回一个任意字符串,在外部接受打印

    # 第一种函数嵌套 在函数func内

    def func():
        print(3)
        def f():
            print(1)
        print(2)
        f()
    func()
    
    #   3
    #   2
    #   1

     

    # 第二种函数嵌套 多个函数嵌套调用

    def func2():
        print(1)
        log()
    
    def func1():
        print(3)
    
    def log():
        func1()
        print(6)
        def fun():
            print(7)
    
    #函数没有调用,没有输出结果
    def func2():
        print(1)
        log()
    
    def func1():
        print(3)
    
    def log():
        func1()
        print(6)
    func2()
    
    #   1
    #   3
    #   6

     

    View Code
    def func():
        a = 1
        def log():
            a = 5
            def info():
                a = 10
                print(a)
            info()
            print(a)
        log()
        print(a)
    func()

     

    五、gloabal、nonlocal

    gloabal

    a = 10
    def func():
        global a  # (声明)我要修改a 找到要a
        a+=1      # 修改
    func()
    print(a)
    #11

     

    def func():
        global a  #(声明我要修改a,找不到a的时候在全局创建一个 a=0)
        a = 1  # a = 1
    func()
    print(a)

    nonlocal

    def func():
        a = 1
        def log():
            a = 5  # a = 15
            def info():
                nonlocal a # 声明修改log函数下边的变量a
                a += 10   # a = a + 10  a = 15
                print(a)  # 15
            info()
            print(a)  # 15
        log()
        print(a)  # 1
    func()
    #   15
    #   15
    #   1
    def f():
        a = 1
        print(a)
        def a1():
            a = 5
            print(a)
            def l():
                nonlocal a
                a = 8
                print(a)
            l()
            print(a)
        print(a1())
    f()

  • 相关阅读:
    面向对象
    Spring学习(十四)----- Spring Auto Scanning Components —— 自动扫描组件
    Spring学习(十三)-----Spring 表达式语言(Spring EL)
    Spring学习(十二)-----Spring @PostConstruct和@PreDestroy实例
    Spring学习(十二)-----Spring Bean init-method 和 destroy-method实例
    学习计划
    Spring学习(十一)-----Spring使用@Required注解依赖检查
    Spring学习(十)-----Spring依赖检查
    Spring学习(九)-----Spring bean配置继承
    Spring学习(八)-----Spring注入值到集合类型的例子
  • 原文地址:https://www.cnblogs.com/Xiao_Xu/p/10534026.html
Copyright © 2020-2023  润新知