一 Python的自定義函式

函式是組織好的、可以重復使用的、用來實作單一功能的代碼，作為拆解大問題的有效手段，在實際的編程中必不可少，

函式定義
函式的主體包括函式名，引數，函式體和回傳值，其定義為：

def 函式名 (引數):
	函式體
	return陳述句

以下對函式的各個要素進行講解：

1.函式名

函式名是用戶自定義的，可以通過簡單的字母和部分符號組合標定函式的主要功能，需要注意自定義函式不能與系統函式“重名”，

2.回傳值

在Python中，一個函式可以存在一個或多個回傳值，也可以不設回傳值，回傳值型別可以為整形、浮點型、字串型、串列、字典或元組，以下分別探討各型別的回傳值：

1）無回傳值

無回傳值的函式通常在函式內部就完成了特定功能，無需回傳，觀察下面的例子：

def add(x,y):
    print(x+y)
add(1,2)
print(add(1,2))
#輸出結果為: 3
#            3
#           None

由于add()函式沒有回傳值，所以print(add(1,2))的列印結果會是None，但細心的小伙伴一定已經發現了一個問題，那就是3這個結果輸出了兩次，這一結果出現的原因其實是add()函式在上述代碼中呼叫了兩次，分別在第三行和第四行，關于這一現象，后面會具體討論，

2）回傳值為數字型別

以下討論的數字型別有兩種，分別為int型和float型，下面通過代碼進行探究：

def add(x,y):
    return x+y
a=1
b=1
print(a,b,type(a),type(b))
print(add(a,b),type(add(1,2)))
#結果為：1 1 <class 'int'> <class 'int'>
#        2 <class 'int'>

可以看到，這里的a和b都是int型，呼叫了函式后結果還是int型，
那么a和b中有float型或者都為float型，結果如何呢？（以a，b均為float型為例）

def add(x,y):
    return x+y
a=1.0
b=1.5
print(a,b,type(a),type(b))
print(add(a,b),type(add(1,2)))
#結果為：1.0 1.5 <class 'float'> <class 'float'>
#        2.5 <class 'int'>

結果依舊是int型，

def add(x,y):
    return float(x+y)
a=1
b=2
print((add(a,b)),type(add(a,b)))
#結果為：3.0 <class 'float'>

回傳值為float型，

3）回傳值為字串型

利用下面函式拼接輸入的字母：

def joint(x,y):
    z=x+y
    return z
a=input('請輸入第一組字母：')
b=input('請輸入第二組字母：')
print((joint(a,b)),type((joint(a,b))))

運行結果為：

4）回傳值為串列或字典

串列和字典作為回傳值的情況并不復雜，和單一的字符或數字作為回傳值比較類似，當函式的回傳值為一個串列時，其回傳值型別為list，示例如下：

def gift_list():
    gift=['蛋撻','雞翅','薯條']
    return gift
print('贈品為：',end='')
list=gift_list()
print(list,type(list))
#結果為：贈品為：['蛋撻', '雞翅', '薯條'] <class 'list'>

當函式的回傳值為字典時，其回傳值型別為list，示例如下：

def gift_list():
    gift={'a':'蛋撻','b':'雞翅','c':'薯條'}
    return gift
#也可以直接合并成一句：return {'a':'蛋撻','b':'雞翅','c':'薯條'}，下同
print('贈品為：',end='')
dict=gift_list()
print(dict,type(dict))
#結果為：贈品為：{'a': '蛋撻', 'b': '雞翅', 'c': '薯條'}<class 'dict'>

可以在主函式里定義新變數將回傳的字典或串列接收，

5）回傳值型別為元組

元組型別作為回傳值時，可以和串列、字典作為回傳值的情況比較類似，示例如下：

def gift_list():
    gift=('贈品有：',['蛋撻','雞翅','薯條'])
    return gift
tuple=gift_list()
print(tuple,type(tuple))
#結果為：('贈品有：', ['蛋撻', '雞翅', '薯條']) <class 'tuple'>

但是，由于元組型別內可以存盤包括數字型別、字串型、串列和字典在內的所有資料型別的資料，因此以元組作為回傳值更多的時候用于函式有多個回傳值時，假如我們需要撰寫一段程式，要求在三種增品種隨機抽取一個搭配冰激凌送出：

#random.choice()函式可以完成在元組或串列中隨機選取一個元素的功能
#但random.choice()函式不能完成在字典中隨機取一個元素的功能
import random
foodten = ['蛋撻','雞翅','薯條']
def order():
        a = random.choice(foodten)
        return a,'冰激淋'
res=order()
print(res,type(res))
#結果為：('薯條', '冰激淋') <class 'tuple'>

這種情況下，計算機會默認回傳值型別是元組，即使在res接識訓傳值之前將其定義為其他型別，接收后也依舊會被轉換為元組型別，如：

import random
foodten = ['蛋撻','雞翅','薯條']
def order():
        a = random.choice(foodten)
        return a,'冰激淋'
res=1
#將res定義為整型
res=order()
print(res,type(res))

輸出的結果依然為：(‘薯條’, ‘冰激淋’) <class ‘tuple’>，

3.引數

1）位置引數

位置引數是描述總體最常用的一種引數，舉例為：

def func (x,y,z):

這個定義中，x、y、z就是位置引數，
呼叫函式時，傳引數量必須和位置引數數量相同，否則計算機會報錯，示例如下：

def add (x,y):
    return x+y
res1=add(1,2)
print(res1)
res2=add(1)
print(res2)

這樣一來的輸出結果為：

錯誤的原因是第五行呼叫add()函式時缺少一個必須的位置引數“y”，

2）默認引數

含有默認引數的函式舉例：

def add (x,y=0):
    return x+y
res=add(1)
print(res)
#運行結果為：1

這個例子中，y就是默認引數，如果呼叫add()時沒有對y進行傳參，那么計算機會默認y為0，從而得出結果，同時，如果呼叫add()函式時，又一次對y進行傳參，會有以下結果：

def add (x,y=0):
    return x+y
res=add(1,2)
print(res)
#輸出結果為：3

這個結果表明，默認的y=0被傳入的引數y=2覆寫，
因此，如果需要定義一個不被修改的默認引數，其位置一定要放在默認引數之后，否則無法在默認引數不被覆寫的情況下完成對位置引數的傳參，

3）可變引數（元組傳參）

元組傳參的定義形式舉例：

def func (*tup):

前文提到，元組型別內可以存盤所有資料型別的資料，因此元組傳參的方式對傳入引數應該也沒有資料型別要求，下面我們對元組傳參的功能進行探究：

def menu(*food):
    #回傳套餐內容
    return food
order1=menu('香辣雞腿堡','可樂')
order2=menu('鹵肉飯','老北京雞肉卷','雪碧','可樂')
order3=menu('烤串','火鍋','培根烤雞腿堡','橙汁','薯條','甜筒')
print(order1)
print(order2)
print(order3)
#結果為：('香辣雞腿堡', '可樂')
#       ('鹵肉飯', '老北京雞肉卷', '雪碧', '可樂')
#       ('烤串', '火鍋', '培根烤雞腿堡', '橙汁', '薯條', '甜筒')

從以上結果看出，輸入數量不同的引數，函式都可以完成函式回傳套餐內容的功能，這說明元組傳參的方式可以傳遞未知數量的引數，

下面來試驗一下元組傳參是否支持不同資料型別引數：

def menu(*food):
    return food
order=menu(('烤串'),{'火鍋':'expensive','培根烤雞腿堡':'cheep'},['橙汁','薯條','甜筒'])
print(order)
#結果為：('烤串', {'火鍋': 'expensive', '培根烤雞腿堡': 'cheep'}, ['橙汁', '薯條', '甜筒'])

這個結果說明，之前的猜想完全正確，元組傳參可以傳遞未知個數、不同型別的引數，

4）字典傳參

字典傳參不是指用字典作為引數傳遞給函式，而是傳入的引數在字典中以字典的形式呈現，其定義為：

def func (**dit):

舉個簡單的例子：
呼叫函式列印一個簡易成績單

def grade (**stu):
    print(stu)
grade(zhang=90,wang=120,zhao=150)
#結果為：{'zhang': 90, 'wang': 120, 'zhao': 150}

從上例中我們可以看出，字典傳參實際上是在函式中以字典型別存盤引數，同時可以通過字典的訪問方式訪問各個引數，字典傳參的方式也沒有對引數的數量限制，

5）引數作用域

函式的作用于分為全域作用域和區域作用域，下面我們舉例探索全域作用域和區域作用域的區別：
例1：撰寫制作成績單函式:

def grade (**stu):
    return stu
grade(zhang=90,wang=120,zhao=150)
print(stu)

運行的結果為：

可以看到雖然我們在函式內部制作了成績單“stu”，但是依然出現了“stu”沒有定義的錯誤，這說明函式內申請的變數只在函式記憶體在，即其作用域為區域，
例2：撰寫將傳入引數翻倍的函式：

a=2
def double (x):
    return 2*x
res=double(23)
print(res)
#結果為：46

可以看出，在主函式內定義的變數，可以直接在子函式中使用，即其作用域為全域，
對于區域變數，可以在其前面加一個“global”修飾，將其更改為全域變數，還以成績單函式為例：

def grade (**s):
    global stu
    stu=s
grade(zhang=90,wang=120,zhao=150)
print(stu)
#結果為：{'zhang': 90, 'wang': 120, 'zhao': 150}

可以看出，“stu”被修改為全域變數之后，在grade()函式以外就可以直接使用了，

6）傳參順序

既然函式傳參方式有很多種，那么在一個需要同時使用多種方式傳參的函式中，就會對傳參順序就會有額外要求，比如，一個需要1個位置引數，1個默認引數和1個可變引數，那么順序就應該為：（位置引數，可變引數，默認引數），如果將可變引數放在首位，那么位置引數將無法接收到傳參，因為所有的傳參都會被可變引數接收，而如果將默認引數放在位置引數或可變引數之前，那么在傳參程序中，默認引數又一定會被覆寫，因此，傳參順序一般為：位置引數，可變引數，默認引數，字典傳參則一定要放在最后面，否則會引起計算機報錯，
下面我們研究一下系統函式print的傳參順序：
查找到print函式的定義為：

print(*objects, sep = ' ', end = '\n', file = sys.stdout, flush = False)

從這個函式的引數分布來看，默認引數確實是放在可變引數之后的，同時，我們也可以修改默認引數來改變部分功能：

print(1,2,3,4,5,sep=' and ')
#列印五個數字，以' and '作為分隔
#結果為：1 and 2 and 3 and 4 and 5

4.函式的嵌套使用

函式除了可以單獨使用，也可以嵌套使用，所謂的嵌套使用，即為向某個函式傳遞的引數是呼叫其它函式運算的結果，比如：

import time
def mul (x,y):#乘法函式
    time.sleep(1)
    print(x*y)
    return x*y
def add (x,y):#加法函式
    #由于x,y為區域作用域，因此mul()函式中定義的
    #引數x,y在離開mul()函式后就會失效，因此add()函式里依然用
    #x，y作為引數是可行的，
    time.sleep(1)
    print(x+y)
    return x+y
print(mul(add(2,3),add(2,2)))
#結果為：5
#        4
#        20
#        20

看到“print(mul(add(2,3),add(2,2)))”這行代碼可以看出，這里的print函式嵌套了mul函式，而mul函式又嵌套了add函式，從結果不難看出，計算及實際執行的順序為：
1.add（2,3），列印5，回傳5；
2.add（2,2），列印4，回傳5；
2.mul（5,4），列印20，回傳20；
3.print（20），列印結果20，
計算機在面對嵌套使用的函式時，先執行的是最內層的函式，在最內層函式執行完成后，再繼續執行此時的最內層函式，直到所有函式都執行完畢，在同一層有多次函式呼叫時，會從左到右依次執行，
函式的嵌套使用還有一種特殊情況：自己呼叫自己，這種情況會在之后講到，

二、編程思路及具體問題解決

1.解決問題的思路介紹

利用編程解決問題的基本思路是將一個大問題拆解成多個步驟和方面，逐漸完成最簡單的步驟和方面，進而解決整個問題，
專案完成流程
1.明確專案目的；
2.分析流程，拆解專案；
3.逐步解決，逐漸完善，

2.實體演示

下面我們通過一個實體演示如何解決問題：
利用函式的自呼叫完成任意數的階乘計算，并將計算結果回傳，
第一步：假設需要計算的是5的階乘，第一步需要計算5*(5-1)：

def fac(x):
    res=x
    x-=1
    res*=x
    print(res)
fac(5)
#結果為：20

以上結果說明，我們已經完成利用函式計算5*（5-1）了，那么第二步，我們需要完成利用函式自呼叫計算5*(5-1)*（（5-1）-1）…：
根據上一步的經驗，我們對函式作出以下改動：

def fac(x):
    res=x
    x-=1
    res*=x
    if x>1:
        fac(x)
    else:
        print(res)
fac(5)
#結果為：2

很顯然，不是我們想要的結果，那么問題在哪里呢？進入單步除錯發現，在計算機第一次執行完第四行代碼時，res為20，此時x=4，執行fac（4），由于res作用域為區域，所以之前的內容（res=20）會丟失并在之后被重新賦值為4，為了可以將之前的res儲存并且在之后不被覆寫，我們引入另一個默認引數y：

def fac(x,y=1):
    res=y
    #在首次呼叫函式時，要將res的置為1，在之后呼叫中保存
    #上一步的res結果
    res=x*y
    x-=1
    if x>1:
        fac(x,res)
    else:
        print(res)
fac(5)
#結果為120

結果正確，說明我們通過函式自呼叫的方法計算并列印5的階乘的任務已經完成，
第三步：輸入任意數字，完成階乘計算：

def fac(x,y=1):
    res=y
    res=x*y
    x-=1
    if x>1:
        fac(x,res)
    else:
        print(res)
#單步呼叫前要從主函式最先執行的地方設定標記點
f=int(input("請輸入一個數："))
fac(f)
#輸入5，結果為：120

結果正確，下面需要完成將計算的結果回傳的任務：

def fac (x,y=1):
    res=y
    res*=x
    x-=1
    if x>1:
        fac(x,res)
    else:
        print(res)
        return res
f=int(input("請輸入一個數："))
#結果為：請輸入一個數：5
#        120
#        5的階乘為：None

回傳值出現錯誤，繼續進行單步除錯發現代碼運行的程序為：

函式的自呼叫與簡單嵌套區別在于：函式的自呼叫程序中，計算機沒辦法直接從最內層的函式fac（2,60）開始執行，只能從fac（5）開始，一層一層向內執行，因此在最內層函式執行完成之后，需要逐層回傳結果，而不是直接回傳到主函式，因此我們實際需要的運行方式為：

因此將程式做以下修改：

def fac (x,y=1):
    res=y
    res*=x
    x-=1
    if x>1:
        return fac(x,res)
    else:
        return res
f=int(input("請輸入一個數："))
print(str(f)+'的階乘為：'+str(fac(f)))
#結果為：請輸入一個數：5
#        5的階乘為：120

結果正確，下面我們需要完成對代碼的測驗：鍵入其他數字看是否可以得到正確結果，當輸入0時，結果出現錯誤：

因此需要再次修改程式：

def fac (x,y=1):
    res=y
    if x==0:
        return 1#如果輸入數字為0，直接回傳1
    res*=x
    x-=1
    if x>1:
        return fac(x,res)
    else:
        return res
f=int(input("請輸入一個數："))
print(str(f)+'的階乘為：'+str(fac(f)))

這樣，利用自呼叫求階乘的函式就正式完成了，

3.格式符的應用

通過上面解決問題的舉例，我們已經介紹了如何利用編程解決具體問題，接下來講一種化簡方式，觀察以下程式片段：

print(str(f)+'的階乘為：'+str(fac(f)))

我們使用【+】拼接字串和變數的時候，常常要考慮變數是什么型別的資料，資料型別不統一，還要先進行強制型別轉換以統一型別，再進行拼接，實際編程之中，可能會有需要多次強制型別轉換后才能拼接的情況，非常麻煩，
因此我們介紹一種簡單的拼接方式，即格式符（%）：

將上述代碼作以下改動：

print('%d的階乘為：%d'%(f,fac(f)))

可以發現，這樣處理后輸出的結果相同，并且由于【%d的階乘為：%d】在一個單引號內，所以盡管這三個部分格式不相同，依然可以列印出我們需要的結果，更為方便，