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

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 = 1def s1():    x1 = 666    print(x1)   #666    print(a)    #1    print(b)    #2?b = 2print(a)    #1s1()a = 88888def 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)

原文地址：https://www.cnblogs.com/dpsy921/p/11180080.html