第四章 函数之参数、作用域

4.2 参数

1. 形参、实参

   　　def get_data(a):#a为形式参数（或形参） 
       v = [1,5,6,,8,5]
       print(v[a])
       get_data(1)# 1在调用函数是传递叫：实际参数（实参）
      # 严格按照顺序传参数：位置方式传参。
      # 实际参数可以是任意类型。

2. 基本参数

   • 任意个数

   • 任意类型

   　　def func(a1,a2,a3):
          print(a1,a2,a3)    
      func(1,"asdf",True) # 1 asdf True

3. 位置传参（调用函数并传入函数）【执行】

   　　 def func(a1,a2):
           print(a1,a2)
       func(11,22) # 11 22

4. 关键字传参 【执行】

   　　# 典例一
         def func(a1,a2):
             print(a1,a2)
         func(a2=11,a1=22)   # 22 11
   ​
      # 典例二
        def func(a1,a2):
             print(a1,a2)
       func(11,a2=22)  # 11 22

   • • 位置传参>关键字传参（顺序）

     • 位置传参 + 关键字传参 = 总传参个数

     • 前面是关键字传参，后面也必须关键字传参

5. 默认参数 【参数】 对于函数的默认值慎用可变类型

   　　# 如果要想给value设置默认是空列表
   ​
   　　# 不推荐(坑)
       def func(data,value=[]): 
            pass 
   ​
      # 推荐
       def func(data,value=None):
           if not value:
                value = []
           
      # 练习    
       def func(data,value=[]): 
           value.append(data)
       return value 
   ​
       v1 = func(1) # [1,]
       v2 = func(1,[11,22,33]) # [11,22,33,1]

   •  def func(a,b=[]) 有什么陷阱？

    

   # 典例一
   def func(a,b=[]):
       b.append(a)
       return b
   ​
   l1 = func(1)
   print(l1)   # [1]
   l2 = func(2,[11,22])
   print(l2)   # [11,22,2]
   l3 = func(3)
   print(l3)   # [1,2]
   ​
   # 示例二
   def func(a,b=[]):
       b.append(a)
       print(b)
       
   func(1) # [1]
   func(2,[11,22,33])  # [11,22,33,2]
   func(3) # [1,3]
   def func(a1,a2,a3=9,a4=10):
       print(a1,a2,a3,a4)
   ​
   func(11,22) # 11,22,9,10
   func(11,22,10)  # 11,22,10,10
   func(11,22,10,100)  # 11,22,10,100
   func(11,22,10,a4=100)   # 11,22,10,100
   func(11,22,a3=10,a4=100)    # 11,22,10,100
   func(11,a2=22,a3=10,a4=100)     # 11,22,10,100
   func(a1=11,a2=22,a3=10,a4=100)      # 11,22,10,100

    

6. 万能参数【打散】

   1. *args

      • 可以接受任意个数的位置参数，并将参数转换成元组.

        • 调用函数无 *

              def func(*args):
              print(args)
          ​
          func((1,2,3,4)) # ((1,2,3,4),)
          func([1,2,3,4]) # ([1, 2, 3, 4],)

        • 调用函数有 *

          def func(*args):
              print(args)
          ​
          func(*(1,2,3,4))    # (1, 2, 3, 4)
          func(*[1,2,3,4])    # (1, 2, 3, 4)

      • 只能用位置传参

        def func(*args):
            print(args)
        ​
        func(1) # ()
        func(1,2) # (1,2) 
        func((11,22,33,44,55)) # ((11,22,33,44,55),)
        func(*(11,22,33,44,55)) # (11,22,33,44,55)

   2. **kwargs

      • 可以接受任意个数的关键字参数，并将参数转换成字典。

        • 调用函数无 **

          def func(**kwargs):
              print(kwargs)
          ​
          func(k1=1,k2="alex")    # {'k1':1,'k2':'alex'}

        • 调用函数有**

          def func(**kwargs):
              print(kwargs)
          func(**{'k1':'v2','k2':'v2'}) # {'k1':'v2','k2':'v2'}

      • 只能用关键字传参

      • 综合应用：无敌 + 无敌 => 真无敌

        def func(*args,**kwargs):
            print(args,kwargs)
        ​
        func(1,2,3,4,5,k1=2,k5=9,k19=999)#(1, 2, 3, 4, 5) {'k1': 2, 'k5': 9, 'k19': 999}
        func([1,2,3],k1=2,k5=9,k19=999)# ([1, 2, 3],) {'k1': 2, 'k5': 9, 'k19': 999}
        func([1,2,3],**{'k1':1,'k2':3})# (1, 2, 3) {'k1': 1, 'k2': 3}
        func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})#(111, 222, 1, 2, 3) {'k11': 'alex', 'k1': 1, 'k2': 3}

7. 参数相关重点：

   1. 定义函数

      def func1(a1,a2):
          pass 
      ​
      def func2(a1,a2=None):
          pass 
      ​
      def func3(*args,**kwargs):
          pass 

   2. 调用函数

      位置参数 > 关键字参数

4.3 作用域

1. python中

   • py文件：全局作用域

   • 函数：局部作用域

     a = 1
     def s1():
         x1 = 666
         print(x1)   #666
         print(a)    #1
         print(b)    #2
     ​
     b = 2
     print(a)    #1
     s1()
     a = 88888
     def s2():
         print(a,b)  #88888,2
         s1()    #666,88888,2
     ​
     s2()

2. 一个函数是一个作用域

      def func():
          x = 9
          print(x)    #9
      func()
      print(x)    #9

3. 作用域中查找数据规则：

   • 优先在自己的作用域找数据，自己没有就去 "父级" -> "父级" -> 直到全局，全部么有就报错。注意：父级作用域中的值到底是什么？

     # 示例一
     x = 10
     def func():
         x = 9
         print(x)    #9
     ​
     func()
     ​
     # 练习题
     x = 10
     def func():
         x = 9
         print(x)    #9
         def x1():
             x = 999
             print(x)    # 999
     ​
     func()
     ​
     x = 10
     def func():
         x = 9
         print(x)    # 9
         def x1():
             x = 999
             print(x)    # 999
         print(x)    # 9
         x1()
     ​
     func()

      

4. 子作用域中只能 找到父级中的值 ，默认无法重新为父级的变量进行赋值，但可以修改。(global/nonlocal可以强制做)

   • global ：对全局的变量进行赋值

   • nonloca ： 找到上一级的局部变量进行赋值

   # 示例一
   name = 'oldboy'
   def func():
       name = 'alex' # 在自己作用域再创建一个这样的值。
       print(name)# alex
   func()
   print(name)# oldboy
   ​
   # 示例二
   name = [1,2,43]
   def func():
       name.append(999)
       print(name) # [1, 2, 43, 999]
   func()
   print(name) #[1, 2, 43, 999]
   ​
   # 示例三
   name = ["老男孩",'alex']
   def func():
       global name
       name = '我'
       print(name) # 我
   func()
   print(name) # 我
   ​
   # 示例四
   name = "老男孩"
   def func():
       name = 'alex'
       def inner():
           global name
           name = 999  
       inner()
       print(name) # alex
   func()
   print(name) # 999
   ​
   ​
   ​
   # 示例五
   name = "老男孩"
   def func():
       name = 'alex'
       def inner():
           nonlocal name # 
           name = 999
       inner()
       print(name) # 999
   func()
   print(name) # 老男孩

    

5. 总结

   • 参数

     • 调用（执行）函数时，传参：位置参数 > 关键字参数

     • 定义函数：

       • def func(a)

       • def func(a,b=None) # 对于默认值，如果是可变类型，----> 坑。

       • def func(*args,**kwargs)

   • 作用域

     • 函数为作用域

     • 自己 > 父级 > 父级 > 全局 【读/修改（可变）】

     • 重新赋值：

       • global

       • nonlocal

   • 全部变量以后必须全部是大写

     USER_LIST = [11,22,3]
     ​
     def func():
         name = 'asdf'
         USER_LIST.append(12)
         USER_LIST.append(name)
     ​
     func()
     print(USER_LIST)