• 小学生都能学会的python(函数的进阶)


    小学生都能学会的python(函数的进阶)

    1. 动态传参
    形参:
    1. 位置参数
    2. 默认值参数
    3. 动态传参
    *args 动态接收位置参数
    **kwargs 动态接收关键字参数
    def func(*args, **kwargs):
    在形参上用*,** 表示聚合. 实参表示打散

    顺序:
    位置 *args 默认值 **kwargs

    # def chi(*food): # * 表示的是不定参数. 可以传递任意个信息 参数名是food, 接受到的是元组
    #     print("我要吃", food)
    #
    # chi("一锅大米饭", "一箱辣条", "一桶方便面", "4L可乐")
    # chi("方便面")
    # chi("一大锅米饭", "一小锅小米饭", "一箱辣条", "一桶方便面", "4L可乐")
    
    # * 表接收位置参数的动态传参
    # 传参的顺序
    # 位置 *args 默认值 **kwargs
    #
    # 如果默认值参数在*args前面. 如果想让默认值生效. *args将永远接不到值
    # def func( a, b, *args,c = 5): # arguments参数
    #     print(a, b, c, args)
    #
    # func(1,2,3,4,5,6,8,c = 10)
    
    # 关键字的动态传参
    # *args 位置参数 接收到的是元组
    # **kwargs 关键字的动态传参, 接收到的是字典
    # def func(**kwargs): # key word arguments
    #     print(kwargs)
    #
    # func(a=10, b=20, jay="周杰伦", jj="林俊杰")
    
    # 无敌模式. 所有的参数都能接收
    # def func(*args, **kwargs):
    #     print(args)
    #     print(kwargs)
    #
    # func(1, 2, 5, jj="陶喆", jay="zhoujielun", soup="胡辣汤")
    
    # def func(*args): # 在这里. 其实相当于把传进来的参数做了一次聚合, 聚合成一个元组
    #     print(args)
    #
    # lst = "娃哈哈"
    # func(*lst) #  在实参位置 * 表示打散, 打散的是可迭代对象
    
    
    # def func(**kwargs): # ** 把接收到的关键字参数打包(聚合)成字典
    #     print(kwargs) # 一定是字典
    #
    # dic = {"张无忌": "明教教主", "谢逊": "金毛狮王", "范瑶": "光明右使"}
    #
    # # func(张无忌=dic['张无忌'], 谢逊=dic['谢逊'], 范瑶=dic['范瑶'])
    # func(**dic) # 这里的** 是把字典打散. 字典的key作为参数的名字, 字典的值作为参数的值传递给形参
    
    # 在形参上
    #   1. 位置参数
    #   2. 默认值参数
    #   3. 动态参数
    #       1. *args  位置参数的动态传参. 系统会自动的把所有的位置参数聚合成元组
    #       2. **kwargs  关键字的动态传参. 系统会自动把所有的关键字参数聚合成字典
    #       3.  def func(*args, **kwargs): 无敌传参
    #       4. 顺序:  位置参数, *args, 默认值, **kwargs
    #       5. 在使用的时候, 可以任意的进行搭配
    #   4. 在实参上. *, **表示的打散.  在形参. *,** 表示聚合
    

      

    2. 作用域
    名称空间:
    1. 内置
    2. 全局
    3. 局部

    作用域:
    1. 全局作用域: 内置+全局
    2. 局部作用域: 局部

    globals() 查看全局作用域中的内容
    locals() 查看当前作用域中的内容

    # 最开始会开辟一个自己的命名空间- 内置名称空间
    # a = 10
    # print(a)
    # # 直接在py文件一个层面上是全局名称空间
    # def func():
    #     hasakey = 10
    # # 在函数内部属于局部名称空间
    # func()
    # 加载顺序: 内置 => 全局 => 局部
    # 取值顺序: 局部 => 全局 => 内置
    
    # a = 10 # 全局
    # def func():
    #     # a = 20
    #     print(a)
    #
    # func()
    
    # 作用域: 变量或者函数的声明周期
    # 全局作用域: 全局名称空间+内置名称空间
    # 局部作用域: 局部名称空间
    # a = 10 # 全局
    # def func():
    #     liuwei = "刘伟"
    
    # 1. globals() 查看全局作用域中的所有内容
    # qiao = "乔峰"
    # def 抗收音机():
    #     bgm = "难念的经"
    #     print("娃哈哈")
    #     print(locals())
    # 抗收音机()
    
    # # print(globals()) # 查看全局作用域中的内容
    # # print(locals()) # locals()查看的是当前作用域中的内容
    

      

    3. global nonlocal
    global: 在局部引入全局变量
    nonlocal: 在局部, 引入离他最近的那一层的变量

    关于函数的嵌套

    # def func1():
    #     print("我是func1")
    #
    # def func2():
    #     print("我是func2")
    #     func1()
    #
    # def func3():
    #     func2()
    #     print("我是func3")
    # func3()
    # 这样的代码不是嵌套. 互相调用
    
    # 函数可以互相嵌套
    # def outer():
    #     def inner():
    #         print("我是内部")
    #     print("我是外部")
    #     inner()
    #
    # outer()
    
    # def outer():
    #     print("我是外面的")
    #     def inner_1():
    #         def inner_2():
    #             print("我是里面的2")
    #         inner_2()
    #         print("我是里面的1")
    #     inner_1()
    #     print("我是外面的收尾")
    #
    # outer()
    
    # a = 10
    # def func():
    #     global a #表示在当前作用域中的使用的a是全局中的变量
    #     a = 20 # 所有的a都是外面的了
    #     print(a) # 现在只有看的权利
    #
    # print(a) # 10
    # func() # 20
    # print(a) # 20
    
    
    # def outer():
    #     a = 10
    #     def inner():
    #         nonlocal a # 找的是局部当中, 离他最近的上层的那个变量
    #         a = 20
    #         print(a)
    #     print(a) # 10
    #     inner() # 20
    #     print(a) # 20
    # outer()
    
    
    
    # a = 1
    # def fun_1():
    #     a = 2
    #     def fun_2():
    #         nonlocal a
    #         a = 3
    #         def fun_3():
    #             a = 4
    #             print(a)
    #         print(a)
    #         fun_3()
    #         print(a)
    #     print(a)
    #     fun_2()
    #     print(a)
    # print(a)
    # fun_1()
    # print(a)
    
    # global 引入全局变量, 可以定义全局变量
    # nonlocal 引入局部中离他最近的外层变量
    
    # def func():
    #     global a # 没有也得有. 自动帮你创建
    #     a = 20
    #
    # func()
    # print(a)
    

      

  • 相关阅读:
    git客户端
    Autowired注解的妙用---在Controller里的构造函数里获取需要注入的对象
    面向对象的理解
    改变对update的做法
    时间戳与日期相互转换
    Git随记
    json数据传输有感
    Mybatis的批量CRUD
    并发与线程有感
    dpkg --info
  • 原文地址:https://www.cnblogs.com/konghui/p/9670398.html
Copyright © 2020-2023  润新知