函數定義
1、數學函數：
x是自變量，y是因變量；自變量的函數x的取值範圍叫做這個函數的定義域；x的變化會引起y的變動。
2、函數式編程：
函數是把邏輯結構化和過程化的一種編程方式。邏輯是指你寫一個購物車作業，先畫一個流程圖，也就是在畫邏輯。
函數式編程就是：先定義一個數學函數，然後按照這個數學模型用編程語言去實現它。
3、python中的函數定義方法：
def test01(x): #def是定義函數的關鍵字；test是函數名；括號內是可定義形參；
"the function definitions" #""裏邊是描述
x += 1 #泛指代碼塊或程序處理邏輯
return x #定義返回值
4、面向過程和函數式編程的區別之處
定義函數
def test1():
‘’‘test1’’’
print(“test1”)
return 0 #有返回值
定義過程
def test02():
‘’‘test02’’’
print(“test02”) #沒有返回值
函數調用
test1() #()代表調用test1函數；括號內可以有參數 也可以沒有。
x=test1()
print(x)
結果：
test1
0
過程調用
y=test02()
print(y)
結果：
test02
None
總結：面向過程和函數式編程的區別：
相同之處：都可以被調用
不通之處：過程沒有返回值；函數有返回值。
python中的面向過程，系統會默認返回一個None。
函數的三個特點
爲什麼使用函數，沒有函數的編程只是在寫邏輯（功能），想脫離函數，重用邏輯，唯一的辦法就是拷貝。
例1：
with open(“test01”,“a”) as f:
f.write(‘this is a stop’)
現在有三個函數，每個函數在處理完自己的邏輯後，都需要使用上面的邏輯，那麼唯一的辦法就是拷貝三次邏輯；
def test1():
print(“this is test1”)
with open(“test01”, “a”) as f:
f.write(“stop stop”)
def test02():
print(“this is test02”)
with open(“test01”, “a”) as f:
f.write(“stop stop”)
def test3():
print(“this is test3”)
with open(“test01”, “a”) as f:
f.write(“stop stop”)
執行：
test1()
test02()
test3()
例2：優化後的，重複利用邏輯
def logger():
with open(“test01”,“a”) as f:
f.write(‘this is a stop\n’)
def test1():
print(“this is test1”)
logger()
def test02():
print(“this is test02”)
logger()
def test3():
print(“this is test3”)
logger()
執行：
test1()
test02()
test3()
例:3：打印的時候加上時間,可擴展
import time
time_format = “%Y-%m-%d %X”
time_now = time.strftime(time_format)
def logger():
with open(“test01”,“a”) as f:
f.write(’\n%s this is a stop\n’%time_now)
def test1():
print(“this is test1”)
logger()
def test02():
print(“this is test02”)
logger()
def test3():
print(“this is test3”)
logger()
執行：
test1()
test02()
test3()
總結 函數的三個優點
1.代碼重用
2.保持一致性
3.可擴展性
函數返回值
def abc1():
print(“aaaaaaa:”)
return 0 #return 結束邏輯；後邊的代碼不執行；
print(“bbbbbbb:”)
def abc2():
print(“aaaaaaa:”)
def abc3():
print(“aaaaaaa:”)
return 1,“hello”,[“a”,“b”,“c”],{“aaa”:111}
x = abc1() #x接收的是abc函數的返回值0；
y = abc2()
z = abc3()
print(x) #return 結束邏輯；後邊的代碼不執行；
print(y)
print(z)
‘’’
輸出：
aaaaaaa:
aaaaaaa:
aaaaaaa:
0
None
(1, ‘hello’, [‘a’, ‘b’, ‘c’], {‘aaa’: 111})
‘’’
函數返回值總結
1.沒有return返回值：返回None
2.return返回一個值：返回object （object就是你定義的返回值；python中的所有數據類型都是對象）
3.return返回多個值：返回tuple （元組形式返回）
爲什麼要有返回值？
因爲想知道這個函數的執行結果是否成功，然後再進行下一步操作。
函數參數
1、形參和實參
形參定義：形式參數，不是實際存在，是虛擬變量。在定義函數和函數體的時候使用形參，目的是在函數調用時候接收實參；
實參定義：實際參數，調用函數時傳給函數的參數，可以是常量、變量、表達式、函數、傳給形參；
2、位置參數和關鍵字參數
位置參數和形參要一一對應；
位置參數和關鍵數同時存在的時候，關鍵參數不能寫在位置參數前面；
def test01(x,y): #x和y是形參
print(x)
print(y)
test01(1,2) #1和2是實參;位置參數和形參要一一對應；
test01(x=1,y=2) #關鍵參數與形參順序無關；
#位置參數和關鍵數同時存在的時候，關鍵參數不能寫在位置參數前面；
3、默認參數
特點：調用函數的時候，默認參數可有可無；
用途：默認安裝值（例如安裝軟件的時候，設置默認安裝路徑；默認數據庫端口值）
def moren(x,y=6): #y=6 是默認參數
print(x)
print(y)
moren(5)
輸出：
5
6
4、參數組
當實參不固定的時候，形參如何定義；
參數組1: 多個實參對應形參
def canshuzu(*args): # *代表接收的參數是不固定的；*args把實參變成了一個元組；
print(args)
canshuzu(1,2,3,4,5)
‘’’
輸出：(1, 2, 3, 4, 5)
‘’’
參數組2：形參和參數組結合
def canshuzu2(x,*args):
print(x)
print(args)
canshuzu2(1,2,3,4,5)
‘’’
輸出：
1
(2, 3, 4, 5)
‘’’
參數組3：把關鍵字參數轉換成字典格式輸出
#*args：接收n個位置參數，轉換成元組的形成
#**kwargs: 把n個關鍵字參數轉換成字典方式
def canshuzu4(kwargs):
print(kwargs)
print(kwargs[‘name’])
canshuzu4(name=“aaa”,age=111)
輸出：
{‘name’: ‘aaa’, ‘age’: 111}
aaa
canshuzu4({“name”:“aaa”,“age”:222})
輸出：
{‘name’: ‘aaa’, ‘age’: 222}
aaa
def canshuzu5(name,age=12,*args,**kwargs):
print(name)
print(age)
print(*args)
print(kwargs)
canshuzu5(“aaa”,age=22,job=“it”,)
輸出：
aaa
22
#空的元組
{‘job’: ‘it’}
函數局部變量和全局變量
namename = “AABBCC” #全局變量
def jubu(name):
namename = “aabbcc” #局部變量
print(“before change”,name,namename)
name = “ABC” #這裏的name是局部變量，這個函數就是這個變量的作用域；
print(“after change”,name)
name = “abc” #全局變量
jubu(name) #執行函數後的結果
print(name) #此處沒有執行函數，直接調用變量
print(namename) #此處沒有執行函數，直接調用變量
‘’’
輸出：
before change abc aabbcc
after change ABC
abc
AABBCC
‘’’
總結
局部變量：在子程序中（函數）定義的變量稱爲局部變量。
局部變量作用域是該變量的子程序；
全局變量：在程序的一開始定義的變量稱爲全局變量。
全局變量作用域是整個程序；
當全局變量和局部變量同名時：
當定義局部變量的子程序內，局部變量起作用；其他地方全局變量起作用。
字符串和整數 在局部變量情況下是不能修改全局變量的值；要想改變在局部變量前加global；
除了字符串和整數、元組以外高級點的類型（列表、字典、集合、類），局部變量可以改變全局變量的值；
例子：設置局部變量修改全局變量
namename = “AABBCC”
def jubu(name):
global namename #設置局部變量修改全局變量
namename = “aabbcc”
print(“before change”,name,namename)
name = “ABC” #這裏的name是局部變量，這個函數就是這個變量的作用域；
print(“after change”,name)
name = “abc”
jubu(name)
print(name)
print(namename)
輸出：
before change abc aabbcc
after change ABC
abc
aabbcc
函數-遞歸
定義：
在函數內部，可以調用其他函數。如果一個函數在內部調用自己本身，這個函數就是遞歸函數。
遞歸特性：
1.必須有一個明確的結束條件；
2.每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減少；
3.遞歸效率不高，遞歸層次過多會導致棧溢出（在計算機中，函數調用是通過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以，遞歸調用的次數過多，會導致棧溢出。）
4.最大的遞歸層次是999層，超過 就報錯；
簡單的遞歸例子
def digui(n):
print(n)
return digui(n)
dict(0) #0是爲了查看遞歸的次數,遞歸的次數最大爲997次；然後就報錯了
簡單的遞歸例子2
def digui2(n):
print(n)
if int(n/2) >0:
return digui2(int(n/2))
print(n)
digui2(10)
輸出：
10
5
2
1
1
高階函數
定義
變量可以指向函數，函數的參數能接收變量，那麼一個函數就可以接收另一個函數作爲參數，這就叫做高階函數。
例如：
def add(x,y,z):
return z(x) + z(y)
result = add(3.3,-6,abs) #abs() 查看絕對值,是一個內置函數。
print(result)
輸出：
9.3
擴展：
裝飾器：http://blog.51cto.com/506554897/1963710
生成器：http://blog.51cto.com/506554897/1963775
迭代器：http://blog.51cto.com/506554897/1963780