10-Python3從入門到實戰—基礎之函數

Python從入門到實戰系列——目錄

函數的定義

• 函數是組織好的，可重複使用的，用來實現單一，或相關聯功能的代碼段。
• 函數的語法

def 函數名（參數列表）:
        函數體

函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ();
任何傳入參數和自變量必須放在圓括號中間，圓括號之間能夠用於定義參數。
函數的第一行語句能夠選擇性地使用文檔字符串—用於存放函數說明。
函數內容以冒號起始，而且縮進。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return至關於返回 None。

• 定義一個簡單的函數

def showmsg():
        print("定義一個簡單的函數")
        return

• 定義一個含參數的函數

def showmsg1(msg):
        print(msg)
        return

• 函數的調用

# 調用以上兩個函數
    showmsg()
    showmsg1("這是一個帶參數的函數")

輸出結果：

定義一個簡單的函數
這是一個帶參數的函數

函數的參數

• Python 中調用函數時可以使用的正式參數類型：

  1.必需參數
  2.關鍵字參數
  3.默認參數
  4.不定長參數

• 必需參數須以正確的順序傳入函數；調用時的數量必須和聲明時的同樣；

def showmsg2(msg):
    print(msg)
    return
showmsg2("必傳參數")
showmsg2()

showmsg2("必傳參數") 輸出結果：

必傳參數
showmsg2() 報錯：
TypeError: showmsg2() missing 1 required positional argument: 'msg'

• 關鍵字參數容許函數調用時參數的順序與聲明時不一致

def showusermsg(name, age):
    print('name is ', name, '---age is ', age)
    return
showusermsg(age=18, name='SiebriaDante')

輸出結果：

name is SiebriaDante ---age is 18

• 默認參數:調用函數時，若是沒有傳遞參數，則會使用默認參數;

def showusermsg(name, age=18):
    print('name is ', name, '--- age is ', age)
    return
showusermsg(name='SiebriaDante')

輸出結果：

name is SiebriaDante --- age is 18

• 不定長參數:能處理比當初聲明時更多的參數,聲明時不會命名;不定長參數使用星號（*）標記

def shownumber(msg, *num):
    print(msg)
    for x in num:
        print(x)
shownumber("開始輸出不定長參數：",10,20,30,40)

輸出結果：

開始輸出不定長參數：
10
20
30
40

參數傳遞

在 python 中，類型屬於對象，變量是沒有類型的：
在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是能夠修改的對象;

• 傳遞不可變對象實例，傳遞的只是實例的值，沒有影響實例對象自己

def changenumber(a):
        a = 10
    
    b = 20
    changenumber(b)
    print(b)

輸出結果：

20

• 傳遞可變對象實例，傳遞是把對象自己傳過去，改變對象的值，同時也是改變函數外對象的值

def changelist(mlist):
        mlist.append([1, 2, 3.4, 5])
        print('函數內讀取 mlist 的值：', mlist)
        return
    mlist = [10, 20, 30]
    changelist(mlist)
    print('函數外讀取 mlist 的值：', mlist)

輸出結果：
> 函數內讀取 mlist 的值： [10, 20, 30, [1, 2, 3.4, 5]]
函數外讀取 mlist 的值： [10, 20, 30, [1, 2, 3.4, 5]]

匿名函數

• Python 使用 lambda 來建立匿名函數；

  lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
  lambda 函數擁有本身的命名空間，且不能訪問本身參數列表以外或全局命名空間裏的參數。

• 語法

  lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2;
# 調用sum函數
print ("相加後的值爲 : ", sum( 10, 20 ))
print ("相加後的值爲 : ", sum( 20, 20 ))

輸出結果：

相加後的值爲 : 30
相加後的值爲 : 40

變量做用域

• 變量的做用域決定了在哪一部分程序能夠訪問哪一個特定的變量名稱；Python的做用域一共有4種，分別是：

L （Local） 局部做用域
    E （Enclosing） 閉包函數外的函數中
    G （Global） 全局做用域
    B （Built-in） 內建做用域

做用域優先級由高到低： L ——> E ——> G ——> B

b_count = 99999  # 內建做用域
    g_count = 0  # 全局做用域
    def outer():
        e_count = 1  # 閉包函數外的函數中
        def inner():
            l_count = 2  # 局部做用域

• Python 中只有模塊（module），類（class）以及函數（def、lambda）纔會引入新的做用域，其它的代碼塊（如 if/elif/else/、try/except、for/while等）是不會引入新的做用域的，也就是說這這些語句內定義的變量，外部也能夠訪問，以下代碼：

>>> if True:
    ...     msg = 'my name is SiberiaDante'
    ...
    >>> msg
    'my name is SiberiaDante'
    >>>

msg 變量定義在 if 語句塊中，外部能夠訪問

>>> def showmsg():
    ...     msg_def='my name is SiberiaDante'
    ...
    >>> msg_def
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'msg_def' is not defined
    >>>

msg_def 定義在函數中，是局部變量，外部不能訪問

全局變量和局部變量

定義在函數內部的變量擁有一個局部做用域，定義在函數外的擁有全局做用域；
局部變量只能在其被聲明的函數內部訪問，而全局變量能夠在整個程序範圍內訪問。調用函數時，全部在函數內聲明的變量名稱都將被加入到做用域中。以下實例：

total = 0; # 這是一個全局變量
    def sum( arg1, arg2 ):
        total = arg1 + arg2; # total在這裏是局部變量.
        print ("函數內是局部變量 : ", total)
        return total;
    #調用sum函數
    sum( 10, 20 );
    print ("函數外是全局變量 : ", total)

輸出結果：

函數內是局部變量 : 30
函數外是全局變量 : 0

global 和 nonlocal關鍵字

當內部做用域想修改外部做用域的變量時，須要使用global和nonlocal關鍵字聲明

• 簡單使用 global 關鍵字聲明

>>> num = 1314
    >>> def showNum():
    ...     global num
    ...     print(num)
    ...     num = 520
    ...     print(num)
    ...
    >>> showNum()
    1314
    520
    >>>

• 外層非全局做用域時，修改變量須要使用 nonlocal 關鍵字

>>> def outer():
    ...     num=1314
    ...     def inner():
    ...             nonlocal num
    ...             print(num)
    ...             num = 520
    ...             print(num)
    ...     inner()
    ...
    >>> outer()
    1314
    520
    >>>

遞歸函數

• 在函數內部調用函數自己，即爲遞歸函數；

def voidTe(num):
        if num == 1:
            return 1
        return num * voidTe(num - 1)
    print(voidTe(10))

輸出結果

3628800

• 遞歸函數的優勢是定義簡單，邏輯清晰；可是，在計算機中，函數調用是經過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。因爲棧的大小不是無限的，因此，遞歸調用的次數過多，會致使棧溢出；