一、函數的介紹
函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。
函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創建函數，這被叫做用戶自定義函數
函數的好處：
-
代碼重用
-
保持一致，易于維護
-
可擴展性
二、函數的定義及調用
2.1 函數的定義
函數的定義規則：
-
函數代碼塊以?def?關鍵詞開頭，后接函數標識符名稱和圓括號?()
-
任何傳入參數和自變量必須放在圓括號中間，圓括號之間可以用于定義參數
-
函數的第一行語句可以選擇性地使用文檔字符串—用于存放函數說明
-
函數內容以冒號起始，并且縮進
-
return [表達式]?結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None
1
定義函數的語法：
2
3
4
def
函數名(參數):
5
函數體
6
返回值
1
#
示例
2
3
def
print_hello():
4
"""
5
打印hello
6
:return:
7
"""
8
print
(
"
hello
"
)
2.2 函數的調用
定義了函數之后，就相當于有了一個具有某些功能的代碼，想要讓這些代碼能夠執行，需要調用它
調用函數很簡單的，通過?函數名()?即可完成調用
1
#
示例：
2
print_hello()
#
調用函數
注意：
- 每次調用函數時，函數都會從頭開始執行，當這個函數中的代碼執行完畢后，意味著調用結束了
- 當然了如果函數中執行到了return也會結束函數
三、函數的返回值
在函數中添加返回值，需要使用return關鍵字
1
def
fun1():
#
無返回值
2
print
(
"
aa
"
)
3
4
def
fun2():
5
msg =
"
hello world
"
6
return
msg
#
返回msg，一個返回值
7
8
def
fun3():
9
return
1, 2, 3
#
返回多個返回值
10
11
aa = fun1()
#
接收函數的返回值
12
bb =
fun2()
13
cc =
fun3()
14
print
(aa)
15
print
(bb)
16
print
(cc)
17
18
#
輸出結果：
19
#
None
20
#
hello world
21
#
(1, 2, 3)
總結：
- 函數中如果沒有return語句返回，那么python函數會默認返回None
- 函數返回值數為0，函數默認返回None；函數返回值數為1是，則返回object；返回值數大于1時，則返回的是一個tuple
四、函數的參數
?函數參數的原則：
-
形參變量只有在被調用時才分配內存單元，在調用結束時，即刻釋放所分配的內存單元。因此，形參只在函數內部有效。函數調用結束返回主調用函數后則不能再使用該形參變量
-
實參可以是常量、變量、表達式、函數等，無論實參是何種類型的量，在進行函數調用時，它們都必須有確定的值，以便把這些值傳送給形參。因此應預先用賦值，輸入等辦法使參數獲得確定值
-
位置參數和關鍵字（標準調用：實參與形參位置一一對應；關鍵字調用：位置無需固定）
-
默認參數:放在參數列表的最后
-
參數組
4.1 普通參數
1
def
fun1(name):
#
name為形式參數
2
print
(name)
3
4
aa =
"
hello
"
5
fun1(aa)
#
aa為實參
4.2 默認參數
1
def
func(name, age=18
):
2
print
(
"
%s:%s
"
%
(name, age))
3
4
5
#
指定參數
6
func(
'
aa
'
, 19)
#
自定義傳入默認參數，以傳入的為準
7
func(
'
cc
'
, age=20
)
8
func(
'
bb
'
)
#
默認參數不傳，使用默認值
9
10
#
運行結果：
11
#
aa:19
12
#
cc:20
13
#
bb:18
4.3 動態參數
位置參數 > *動態參數 > 默認參數
1
def
func1(*
args):
2
print
(args)
3
print
(type(args))
#
元組
4
5
6
#
執行方式一
7
func1(11, 33, 4, 4454, 5
)
8
9
#
執行方式二
10
li = [11, 2, 2, 3, 3, 4, 54
]
11
func1(*li)
1
def
func2(**
kwargs):
2
print
(kwargs)
3
print
(type(kwargs))
#
注意：
- 加了星號（*）的變量args會存放所有未命名的變量參數，args為元組
- 而加**的變量kwargs會存放命名參數，即形如key=value的參數， kwargs為字典
1
#
萬能參數 可以接收任意的參數
2
def
func(*args, **
kwargs):
3
pass
五、函數的嵌套
1
def
func1():
2
print
(
"
hello world
"
)
3
4
5
def
func2():
6
print
(
"
aa
"
)
7
func1()
8
print
(
"
cc
"
)
9
10
11
func2()
#
按順序執行 先執行print("aa") --> func1() --> print("cc")
六、全局變量與局部變量
6.1 命名空間與作用域
命名空間：
1
.內置命名空間：python解釋內部運行時的變量函數
2
.全局命名空間：我們在py文件中直接聲明出來的變量、函數
3
.局部命名空間：在函數內部聲明的變量和函數
加載順序：
1
.內置命名空間
2
.全局命名空間
3
.局部命名空間
取值順序：
1
.局部命名空間
2
.全部命名空間
3
.內置命名空間
作用域：
1.全局作用域：全局命名空間 +
內置命名空間
2
.局部作用域：局部命名空間
可以通過globals()函數來查看全局作用域中的內容，也可以locals()查看當前作用域中的內容
6.2 全局變量與局部變量
全局變量與局部變量的本質在于作用域的不同
全局變量說白了就是在整個py文件中聲明，全局范圍內都可以使用
局部變量是在某個函數內聲明的，只能在函數內部使用
?
1
#
示例
2
def
fun1():
3
name =
"
aa
"
4
print
(name)
報錯的原因：試圖訪問局部變量而報的錯
6.2.1 局部變量和全局變量名一樣
- 全局變量與局部變量名一致，函數內部會優先使用局部變量
- 修改局部變量不會影響到全局變量
1
name =
"
bb
"
2
def
print_name():
3
name =
"
aa
"
4
print
(name)
5
6
print_name()
7
print
(name)
8
#
打印的結果為
9
#
aa
10
#
bb
6.2.2 global關鍵字
使用global關鍵字：則會告訴python編譯器，這個變量是全局變量而不是局部變量，這樣在函數體內修改變量會影響全局了
1
name =
"
bb
"
2
def
print_name():
3
global
name
4
name =
"
aa
"
5
print
(name)
6
print_name()
7
print
(name)
8
#
打印的結果:
9
#
aa
10
#
aa
6.2.3 nonlocal關鍵字
nonlocal關鍵字在python3中新出現的關鍵字，作用：用來在函數或其他作用域中使用外層(非全局)變量
nonlocal適用于在局部函數中的局部函數，把最內層的局部變量設置成外層局部可用，但是還不是全局的。
注：nonlocal必須要綁定局部變量
1
def
fun1():
2
num = 1
3
4
def
fun2():
5
nonlocal num
#
此處不能使用global，只能使用nonlocal
6
num += 1
7
return
num
8
return
fun2
9
10
11
aa =
fun1()
12
print
(aa())
七、函數名的本質
函數名本質上就是函數的內存地址
7.1 可以被引用
1
def
func():
2
print
(
'
in func
'
)
3
4
5
f =
func
6
print
(f)
#
7.2? 可以被當作容器類型的元素
1
def
f1():
2
print
(
'
f1
'
)
3
4
5
def
f2():
6
print
(
'
f2
'
)
7
8
9
def
f3():
10
print
(
'
f3
'
)
11
12
13
l =
[f1, f2, f3]
14
d = {
'
f1
'
: f1,
'
f2
'
: f2,
'
f3
'
: f3}
15
#
調用
16
l[0]()
17
d[
'
f2
'
]()
7.3 可以作為函數的參數或返回值
7.3.1 作為函數的參數
1
def
func1():
2
print
(
"
aa
"
)
3
4
5
def
func2(f2):
6
f2()
7
8
9
func2(func1) # 作為函數的參數
7.3.2 作為返回值
1
def
func1():
2
3
def
func2():
4
print
(
"
bb
"
)
5
return
func2
#
作為返回值
6
7
8
f =
func1()
9
f()
八、匿名函數
語法格式： lambda [形參 1 ], [形參 2 ], ... : [單行表達式] 或 [函數調用]
1
#
不帶參數
2
my_fun =
lambda
: 10 + 20
3
#
帶參數
4
my_add =
lambda
a, b: a +
b
5
my_add()
注意：
-
函數的參數可以有多個，多個參數之間用逗號隔開
-
匿名函數不管多復雜，只能寫一行，且邏輯結束后直接返回數據
-
返回值和正常的函數一樣，可以是任意數據類型
?
匿名函數并不是說一定沒有名字，這里前面的變量就是一個函數名。說它是函數名原因是我們通過__name__查看的時候是沒有名字的，統一是lambda.在調用的時候沒有什么特別之處，像正常函數一樣調用即可。
?
匿名函數作為函數參數
1
def
my_function(func):
2
3
a = 100
4
b = 200
5
#
把 cucalate_rule 當做函數來調用
6
result =
func(a, b)
7
print
(
'
result:
'
, result)
8
9
10
my_function(
lambda
a, b: a + b)
九、高階函數
9.1 sorted 排序
語法：sorted(Iterable, key=None, reverse=
False)
Iterable:可迭代對象
key：排序規則(排序函數)，在sorted內部會將可迭代對象中的每一個對象傳遞給這個函數的參數，根據函數的運算結果進行排序
1
lst = [5, 7, 6, 12, 1, 13, 9, 18, 5
]
2
#
lst.sort() # sort是list里面的方法
3
#
print(lst)
4
new_lst = sorted(lst, reverse=True)
#
內置函數，返回給你一個新列表,新列表是被排序的
5
print
(new_lst)
6
7
8
#
給列表排序，按照字符串的長度進行排序
9
lst2 = [
"
大陽哥
"
,
"
尼古拉斯
"
,
"
趙四
"
,
"
劉能
"
,
"
廣坤
"
,
"
謝大腳
"
]
10
11
12
def
func(st):
13
return
len(st)
14
15
16
new_lst = sorted(lst2, key=func)
#
內部，把可迭代對象中的每一個元素傳遞給func
17
#
new_lst = sorted(lst2, key=lambda x: len(x)) # 也可以使用匿名函數
18
print
(new_lst)
9.2 filter 過濾
filter(過濾)：遍歷序列中的每個元素，判斷每個元素得到布爾值，如果是True則留下來，組成新的迭代器
語法：filter(function, Iterable) 返回一個迭代器
function:用來篩選的函數，在filter中會自動的把iterable中的元素傳遞給function，然后根據function返回的True或者False來判斷是否保留次數據
Iterable:可迭代對象
1
list1 = [
"
1111aaa
"
,
"
2222aaa
"
,
"
3333aaa
"
,
"
4444
"
,
"
5555
"
,
"
6666
"
]
2
list2 = filter(
lambda
x: x.endswith(
"
aaa
"
), list1)
#
有過濾的作用
3
print
(list(list2))
4
#
運行結果：['1111aaa', '2222aaa', '3333aaa']
9.3 map 映射
語法:map(function, Iterable)
map處理序列中的每個元素，得到一個結果(迭代器)，該迭代器元素個數與位置不變
1
list1 = [1, 2, 3, 4, 5
]
2
list2 = map(
lambda
x: x+1, list1)
#
map的第一個參數為函數，后面的參數為可迭代對象
3
print
(list(list2))
4
#
結果：[2, 3, 4, 5, 6]
5
6
lst1 = [1, 2, 3, 4, 5
]
7
lst2 = [2, 4, 6, 8, 9
]
8
9
10
print
(list(map(
lambda
x, y: x+
y, lst1, lst2)))
11
#
結果：[3, 6, 9, 12, 14]
9.4 reduce
reduce 處理一個序列，把序列進行合并操作
from
functools
import
reduce
list1
= [1, 2, 3, 4, 5
]
aa
= reduce(
lambda
x, y: x+y, list1)
#
前一個參數的函數必須是兩個參數
print
(aa)
#
運行結果：15
?十、遞歸函數
1、遞歸的特點
遞歸算法是一種直接或間接調用自身算法的過程，在計算機編程中，遞歸算法對解決一大類問題是十分，它往往使算法的描述簡潔而且易于理解。
遞歸算法解決問題的特點：
（1）遞歸就是在過程或函數里調用自身
（2）在使用遞歸策略時，必須有一個明確的遞歸結束條件，稱為遞歸出口。
（3）遞歸算法解題通常顯得很簡潔，但遞歸算法解題的運行效率較低，所以一般不提倡用遞歸算法設計程序。
（4）在遞歸調用的過程中系統為每一層的返回點、局部量等開辟了棧來存儲，遞歸次數過多容易造成棧溢出等。
?
2、遞歸的要求
遞歸算法所體現的“重復”一般有三個要求：
（1）每次調用在規模上都有所縮小（通常是減半）
（2）是相鄰兩次重復之間有緊密的聯系，前一次要為后一次做準備（通常前一次的輸出作為后一次的輸入）
（3）在問題的規模極小時必須用直接給出解答而不再進行遞歸調用，因而每次遞歸調用都是有條件的（以規模位達到直接解答的大小為條件）無條件遞歸調用將會成為死循環而不能正常結束。
1
"""
2
1! = 1
3
2! = 2 × 1 = 2 × 1!
4
3! = 3 × 2 × 1 = 3 × 2!
5
4! = 4 × 3 × 2 × 1 = 4 × 3!
6
...
7
n! = n × (n-1)!
8
使用遞歸實現
9
"""
10
11
12
def
cal_num(num):
13
if
num >= 1
:
14
result = num * cal_num(num - 1
)
15
else
:
16
result = 1
17
return
result
18
19
20
print
(cal_num(3))
執行原理：
?
遞歸的執行深度調整：
1
import
sys
2
sys.setrecursionlimit(10000)
#
可以調整遞歸深度，但是不一定跑到這里
#
斐波那契數列：就是前兩個數的和為后一個數的值（0，1，1，2，3，5，8，13.........）:
#
計算第n個數的值
def
foo(num):
"""
實現斐波那契數列
:param num: 第幾個數
:return:
"""
if
num <=
0:
return
0
elif
num == 1
:
return
1
else
:
return
foo(num - 1) + foo((num - 2))
?
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
