python_0基礎開始_day10

第十節

一、函數進階

1. 動態參數

   • *a r g s —— 聚合位置參數，動態位置參數

     預設返回的是tuple元組

     def eat(*args):  # 函數的定義階段 *聚合(打包)
         print(args) # tuple
         print(*args) # 函數體中的 *    打散(解包)
     eat(*args) # 打散可得迭代的數據類型

     def eat(a,b,*c):
         print(a)
         print(b)
         print(c)     # tuple
     eat("麵條","米飯","饅頭","大餅")
     # 返回的是 麵條，米飯，(饅頭，大餅)

   • k w a r g s —— 聚合關鍵字參數，動態預設參數

     預設返回的是d i c t字典

def eat(a,b,*args,d=2,**c):# 位置參數 > 動態位置參數 > 預設參數 > 動態預設參數
    print(a)
    print(b)
    print(d)
    print(args)     # tuple
    print(c)        # dict
eat("麵條","米飯","大燒餅","大煎餅",a1=1,b1=2)# 位置 > 關鍵字

參數位置 > 動態參數位置 > 預設參數位置 > 動態預設參數位置

• 定義的時候 * ** 都是聚合

• 函數體和實際參時 * a r g s 將元組中的元組打散，** k w a r g s將字典中的鍵獲取

• 形參：

  • 位置參數：

    • 動態位置參數：先執行位置參數，位置參數接受後額外的參數動態參數進行接收，獲取的是一個元組。

  • 預設參數：

    • 動態預設參數（預設）：先執行預設參數，預設參數接受後額外的動態預設參數進行接收，獲取的是一個字典。

• 實參和函數體：

  • *打散 **實參時能夠使用

 def eat(*args,**kwargs):  # (萬能傳參)
     print(args) # tulpe
     print(kwargs) #dict
 lst = [1,23,4,6,7]
 dic = {"key1":1,"key2":3}
 # 應用場景
 eat(lst,dic)
 # ([1, 23, 4, 6, 7], {'key1': 1, 'key2': 3})
 # {}
 eat(*lst,**dic)
 # (1, 23, 4, 6, 7)
 # {'key1': 1, 'key2': 3}
 
 # 資料庫  ———— **
 def func(*args,**kwargs):
     print(kwargs)
 func("key"=1,"ke1"=1)# 資料庫都是傳入的鍵值對

2. 函數的註釋

   def 函數名():
       """
       註釋信息
       :return:
       """
       return
   # 函數名.__doc__查看註釋內容
   # 函數名.__name__查看函數名稱

3. 名稱空間

   1，內置空間：Python解釋器自帶的空間

   2，全局空間：p y文件頂格寫的就是全局空間

   3，局部空間：函數體就是局部空間

   • 載入：

     • 內置空間 > 全局空間 > 局部空間

   • 取值：

     • 局部空間 > 全局空間 > 內置空間

   • 作用域：作用域就是作用範圍, 按照生效範圍來看分為 全局作用域 和 局部作用域

     • 全局作用域：全局+內置

     • 局部作用域：局部

4. 函數的嵌套

   • 不管在什麼位置，只要出現函數名()就是在調用函數。

     # 混合嵌套:
     def f1():
         print(11)
     ​
     def f2():
         print(22)
         f1()
     ​
     def f3():
         print(33)
         f1()
     ​
     def run():
         f3()
         f2()
         f1()
     run()
     #33
     #11
     #22
     #11
     #11
     ​
     def func(a):
         print(a)
         return f1(foo(a))
     ​
     def foo(b):
         print(b)
         return b + 5
     ​
     def f1(args):
         return args + 10
     ​
     print(func(5))
     #5
     #5
     #20
     ​
     def foo(a):
         a = 10
         def f1(b):
             c = b
             def foo(c):
                 print(c)
                 print(foo.__doc__)
             foo(c)
             print(b)
         f1(a)
         print(a)
     foo(25)
     #10
     #None
     #10
     #10
     ​
     def foo():
         a = 10
         func(a)
     ​
     def func(a):
         print(a)
     ​
     foo()
     #10

5. global 和 nonlocal

   • global ：只修改全局變數，如果全局沒有，則創建一個新的

   • nonlocal：只修改局部變數，修改聲明nonlocal 最近的一層，上層沒有繼續向上上層查找；只限制在局部，找不到就報錯。

   a = 10
   def func():
       global a
       a = a - 6
       print(a)
   print(a)#10    直接讀取全局空間的值
   func()#4
   print(a)#4     global 已經改變了全局空間中a的值
   ​
   ​
   a = 100
   def func():
       b = 10
       def foo():
           b = a# b = a = 100
           def f1():
               nonlocal b
               b = b + 5 # b = 100 + 5
               print(b)  # 105
           f1()
           print(b)  # 105   b的值隨著nonlocal改變了
       foo()
       print(b) # 10     讀取的是相同空間的值
   func()
   print(a) # 100    全局空間的b 沒發生改變

6.