python - 函數

函數

• def add(x,y): 函數名add（標識符）對應一個內存中的一個函數對象，因此也可以有多個標識符同時指向這個對象，同樣可以調用。
• 再次定義會創建一個新的function對象，不是對原來對象的修改；add（標識符）指向這個新的對象，原來的函數對象引用計數減一。
• 函數調用：add(2,3) 將（2,3）傳入add指向的函數對象中進行計算
• 函數是一個可調用對象；callable(add) ==> True
• 函數傳參
  1、位置傳參；2、關鍵字傳參；3、可變位置傳參；4、keyworld-only；5、可變關鍵字傳參
• 關鍵字參數必須在位置參數后面，每個參數只能接受一個值，否則多值錯誤；位置參數可以使用關鍵字傳參

def sum(*iterable):
    print(type(iterbale))  # iterbale ==> 元組，不傳入為空元組
    for i in iterable:
        pass
def sum1(iterable):
   print(type(iterbale))
       for i in iterable:
           pass
sum(x for i in range(10)))  # 傳入生成器
sum1(range(5)))  # 傳入一個對象

• 可變位置參數：收集所有位置參數作為一個元組。
• 可變關鍵字參數：收集所有關鍵字參數作為一個字典。

def fn(a, b=5, *args, **kwargs):
    pass
fn(5, a=2, c=3, b=4,z=5) 
##位置參數和關鍵字參數混用，關鍵字參數可以亂序，多余的kwargs收集為字典

• keyword-only

  def fun(x=4, *args, y, **kwargs):  
  # y只能接受關鍵字參數，keyword-only參數
  pass
  def func(*args, x=0, y):  # 正確，keyword-only 默認值可以在前
  pass
  def func1(*,m): # m 必須為關鍵字傳參
  pass    

• 元組，列表，字符串，迭代器，生成器，range對象 均可以解構
• 字典解構傳參

def fun(a, b):
    pass
fun(**{"a":1,"b",2})               # ==> fun(a=1,b=2)
fun(*{"a":1,"b",2}.values())   # ==> fun(*(1,2))

• 函數返回值：使用return 返回，函數執行return后函數結束，并返回return 指定的內容，未定義return默認return None
• 函數作用域：函數定義的變量只在該函數內部，函數的局部作用域，也稱本地變量
• 全局變量、全局作用域：全局可見，可以向內部穿透，在函數內部可見

  函數嵌套：

• 執行函數定義的時候不會執行內部的語句，內部定義的函數無法執行

  def func():
  x = 1
  def fn():
      x = x + 1  #  調用時將會報錯，未定義本地x的值之前，使用了本地的x

• global：聲明全局變量，該作用域中的該變量將會在全局中尋找該變量。

  def func:
  global x # 聲明全局作用域，必須是全局作用域，上一層使用的nonlocal
  x = 1  # 在函數中可以定義全局變量，且執行后外部可用
  x += 1 

  閉包

• 閉包：函數嵌套使用時，內層函數使用到了外層函數定義的局部變量，形成了閉包。
• python 中實現閉包的方式：
  1.內部可以外部引用類型的變量，并可對其進行內部修改

  def func():
  x = [1]
  def fn():
      x.append[4]
  return fn
  foo = func()
  foo()   #  每次輸出將會在上一次的結果上增加一個元素；x 的操作與外部形成了閉包

  2.也可以使用nonlocal實現閉包：內部變量聲明使用外部定義的變量

def func():
    x = 1
    def fn():
        nonlocal x  #聲明該x 是外部變量 x  
        x = x + 1
    return fn
foo = func()
foo()  # 每次調用x 結果加1，foo函數未消亡，x 將不會被清除

• 如果在內部函數中定義一個變量，該變量名與外部變量名相同，那么這個變量只會使用內部的定義的這個值，且需要滿足先賦值，后使用

  def func():
  x = 1
  def fn():
      y = x + 1  # 此處使用了x 變量，但是在下一行才定義x 所以錯誤
      x = y   #  此處定義了與外部變量同名變量，在本函數內部所有范圍內只能用該變量
      # 如果沒有第5行對x的重新定義，第4行中x將會使用外部的x變量

• nonlocal：非該函數本地的變量，但是也不能是全局中的變量，在其他的任意一層定義即可使用該變量；函數多層嵌套時，使用nonlocal將會一層層向外部尋找該變量，直到最外層函數（非全局變量，不會匹配同名的global變量名）

  def fn():
  global c
  c = 0
  def fn1():
      c = 0
      def fn2():
          def fn3():
              nonlocal c  # 會使用5行的c值，與第3行的c不是同一個比變量
  #若沒有第5行的c定義，也無法匹配第3行的c變量。nonlocal無法匹配global變量  

• global和nonlocal都只是申明本函數作用域內該元素，并向上匹配尋找

  默認值的作用域

• 當函數定義之后，會在內存中生成一個函數對象 ，此時函數已經定義了許多的方法和屬性（可以理解為函數的元數據），例如函數名字，默認值等，函數參數的默認值已被加載到函數的兩個屬性之中保存，分別為'. defaults'，'kwdefaults'中

  def fun(a, b=1, c={}, *d , m=1, **kw):
  a = 1
  x = 1
  return x
  dir(fun) # 查看該函數定義后的已經存在屬性
  '''
  ['__annotations__', '__call__', '__class__', '__closure__',
  '__code__', '__defaults__', '__delattr__', '__dict__',
  '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
  '__get__', '__getattribute__', '__globals__', '__gt__', 
  '__hash__', '__init__', '__init_subclass__', '__kwdefaults__',
  '__le__', '__lt__', '__module__', '__name__', '__ne__', 
  '__new__', '__qualname__',  '__reduce__', '__reduce_ex__',
  '__repr__', '__setattr__', '__sizeof__', '__str__',
  '__subclasshook__']
  '''
  # 默認值被保存到 __defaults__ 和 __kwdefaults__中，分別保存位置參數
  # (使用元組）和kw-only參數（使用字典）
  fun.__defaults__       # ==> ( 1, {} )   保存了b和c的缺省值
  fun.__kwdefaults__     # ==> {'m': 1}     保存了m 的默認值

• 注：當默認值為引用類型時，使用變量操作時可能會引起默認值的改變（在使用默認值時，進行一些引起本對象的操作就會引起默認值改變）
  如：list，bytearray，set，dict等可變類型對自身修改的操作，可變序列的 += 操作

  def fun(x = [], b=1):
  x.append(1)   # 此時 x 是默認值列表中對象，直接操作默認值參數的對象
  x += [1]         # += 執行列表的extend，也是對x本對象的改變
  b = 2             #b原本指向默認值列表中的1，現在指向新的對象2，原對象未改變

• LEGB原則：尋找一個變量時候的先后順序
  
• 當內部定義一個與全局變量或者build-in中相同的變量名時，將會使得全局或者build-in中的函數無法在本程序內使用，例如：

  print = 1   # 定義一個變量為print，此時print指向一個int對象，
  print(1)     #  此時將會報錯，默認先使用本文件中的print，而不是build-in中

  匿名函數

  1. 匿名函數普通定義
  2. 定義后可以使用變量接收，此時等同于 def
  3. 創建對象后直接調用，在函數后部直接（）進行調用
     特點：簡潔，快速實現某種功能，一次性創建使用，節省內存。

     lambda x : x + 1    #  返回值===> 對象,":"后不能出現賦值表達式
     foo = lambda x : x + 1  # ===> 返回的對象使用一個變量接收，foo可調用
     (lambda x : x+1)(1)  # ==> 直接在創建后調用，（）+ 傳入參數調用

• 使用場景
  構造一個類型，完成某種功能

  # 返回一個和str功能相同的函數對象，效果相同
  sorted([1,2,3,"a"], key = str)
  sorted([1,2,4,"a"], key = lambda x :str(x))
  # 可以定制一些自己的比較方式,例如：
  sorted([1,2,4,"a"], key = lambda x :hash(x)) # 使用元素哈希值排序
  sorted([1,2,4,"a"], key = lambda x :func(x)) # func為自己定義的函數，實現自定義

• 構造某些類型，使用其返回值

d = defalutdict(lambda ：0)
for k in "abc":
    d[k] += 1   # 第一次將會調用lambda并返回初始值0值，完成累加

d = defalutdict(lambda ：[])    # 構造列表 == list
for k in "abc":
    d[k].append(1)

• 嵌套使用，可用于閉包

  def fun():
  x =  [ ]
  return lambda  a : x.append(a)   # 匿名函數使用外層函數x,形成閉包

  遞歸函數

• 函數調用過程：函數定義后，會在內存中生成函數對象，在調用函數時，函數將會在main函數之上壓棧，對應的參數分別進行壓棧，函數全部執行結束，函數對象進行彈棧，繼續執行main函數；如果函數未進行彈出棧時調用新的函數，函數將會繼續壓棧，直到棧上層函數執行完成彈出后下層函數才會依次彈出；先進棧函數后出棧，后進棧函數一定會先彈出才能彈出下層函數
• 遞歸函數：在自己函數內部反復調用自己，形成一個循環的調用。
• 間接遞歸：A調用B函數，B調用C，C調用A形成間接的遞歸調用
• 注：遞歸必須有邊界條件，達到某個條件將對停止自身調用，并進行一層層的return 返回，這是一個“逆向”的操作，先執行內部函數，在執行外層函數 ；
  內層函數的 return 值將會成為外一層函數調用結果，注意 return 值的控制。
• 遞歸思路：找出遞推公式，即：F( n) = f ( n - 1) 的關系，有了該關系，基本可以寫成以下形式

• def func(n):
  if n == ?                   # 退出條件，可能不止一個
      return ?               # 一個確定的值，不可以再調用自身
  return func( n - 1 )  #  根據實際遞推公式變化    

• 遞歸分析： 分析返回結果 習慣從最里層分析。
• 遞歸最大深度：無限遞歸將會消耗所有的棧資源，所以python中對遞歸層數進行了限制，查看方法：

  import sys 
  print(sys.getrecursionlimit())  # ==> 最大遞歸數

• 遞歸會使用大量函數的壓棧，開辟和清理新的棧空間需要時間和資源，效率較低；一般不使用

生成器函數

yield關鍵字

• yield只能在函數中使用，當函數中有yield關鍵字，該函數執行時將會返回一個 生成器對象，每次使用 next驅動，遇到yield語句暫停執行，等待下一次next，但當執行到return 語句時，將結束生成器運行。

  def func():
  for i in range(3):
      yield i                   #  執行到yield，返回一次結果，并暫停函數執行 
  f = func()                     # 調用函數將不會執行，而是返回一個生成器對象
  next(f)                        # 使用next()，返回每次yield值 
  每次調用函數func 將會返回一個新的生成器，不能直接對func()進行操作，否則每次生成新的對象。

• 每次調用函數func 將會返回一個新的生成器，不能直接對func()進行操作，否則每次生成新的對象。
• 函數中如果有return語句，執行return語句將會結束函數，但是無法拿到return返回值。
• 使用next函數執行到最后將會報錯，StopIteration

  .send()方法

• send()是生成器對象的一個方法，會推動生成器函數執行，直到遇到 yield 語句，并接受返回的yield 的值，同時，send會將實參傳入生成器函數內部yield語句，作為yield函數體內部執行后的返回值，從而實現生產器函數內部的一種“交互”

  def foo():
  i = 0
  while True:
      i += 1
      res = yield i           #yield 的默認返回值None，外部使用send后將返回send值
      print(res)
  g = foo()
  g.send("abc")                # 執行next(g)，并將"abc"作為生成器g內部yield的返回值 

  使用案例：重置計數器，send任意值重置計數

  def foo():
  i = 0
  while True:
      i += 1
      res = yield i                # 第一次執行會返回i, 然后暫停函數的執行
      if res is not None:      # 當收到send值，重置計數器i
          i = 0
      print(res)                    # 下一次next,才會使用res 即"abc"
  g = foo()                             # 生成器對象
  g.send("abc")

  yield from

  # 每一次執行返回可迭代對象中的一個值
  def foo():
  yield from [1,2,3]                 # 接iterable

  高階函數

  定義及實現

• 高階函數：參數中至少有一個函數，或者返回值是一個函數對象的函數
  下面 key 參數的實現為高階函數的實現原理，利用高階函數，自行實現sorted排序函數

  a = [8, 7,6, 47, 464, 4, 32,3,2]
  def sort(nums, *, key=None, reverse=False):
  res = []
  for x in nums:
      for i, v in enumerate(res):                          #第一次不會for,append第一個元素
          cx = key(x) if key else x                        #key實現
          cv = key(v) if key else v                        #只用于比較，插入時使用原值 
          cmp = cx > cv if reverse else cx < cv    # reverse實現
          if cmp: 
              res.insert(i,x)                                     # 找到插入位置i , 插入 x 
              break
      else:
          res.append(x)
  print(res)
  sort(a, reverse=1, key=str)

  常用高階函數

  sorted()
  排序函數：返回排序好的原列表

  # sorted(iterbale, *, key=None, reverse=False）
  # 結合 lambda 實現特定功能
  # 使用 lambda 按照其lambda返回值的數值大小依次進行排序
  sorted(a, key=lambda x: abs(x-10) )     # 以x-10的絕對值大小排序
  sorted(a, key=lambda x: 1)                   # 原來的序列

  filter()

• 將可迭代對象中的每個元素放入function中，將function 返回值為等效false 的元素進行過濾
• function接受一個參數，且返回值應當是bool類型，或其返回值等效布爾值
• function參數如果是None，可迭代對象的每一個元素自身等效布爾值

  # filter(function, iterable)  ==> 迭代器,惰性對象
  list(filter(int, ["0", "12"]))             # ==> ["12"]  #int("0")后等效false
  list(filter(lambda x: int(x), ["0", "12"]))                 # 同上功能
  filter(None, [None, 0, "False", False, [],"",(), {}])  # ['False']

  map()

  # map(self, /, *args, **kwargs)
  # map(func, *iterables) --> map object  # 返回map對象，惰性  
  map(str, range(5))                         # [ '0, '1', '2', '3', '4']
  map(lambda x: str(x), range(5))       # 同上
  map(lambda x,y: (x,y), "abcde", range(10))      # 類似zip,返回組合后的元組