Python之路--Python基礎3--函數

時間 2019-11-10

原文原文鏈接

一、函數簡介

　　函數是重（chong）用的程序段。它們容許你給一個語句塊一個名稱，而後你用這個名字可以在你的程序的任何地方，任意屢次地運行這個語句塊。這被稱爲調用函數。咱們已經使用了許多內建的函數，好比 len 和 range 。函數用關鍵字 def 來定義。def 關鍵字後跟一個函數的標識符名稱，而後跟一對圓括號。圓括號之中能夠包括一些變量名，該行以冒號結尾。接下來是一塊語句，它們是函數體。下面這個例子將說明這事實上是十分簡單的：html

def sayhi(name): #函數名(參數)
    print("Hello,I'm %s" % name) sayhi("YL")  #調用函數

二、函數參數、局部變量、全局變量

　　形參變量只有在被調用時才分配內存單元，在調用結束時，即刻釋放所分配的內存單元。所以，形參只在函數內部有效。函數調用結束返回主調用函數後則不能再使用該形參變量python

　　實參能夠是常量、變量、表達式、函數等，不管實參是何種類型的量，在進行函數調用時，它們都必須有肯定的值，以便把這些值傳送給形參。所以應預先用賦值，輸入等辦法使參數得到肯定值linux

默認參數算法

先看下面代碼：數據結構

def stu_register(name,age,country,course): print("----註冊學生信息------") print("姓名:",name) print("age:",age) print("國籍:",country) print("課程:",course) stu_register("Jack",22,"CN","python") stu_register("Tom",21,"CN","linux") stu_register("Alex",25,"JP","C++")

　　country 這個參數基本都是"CN", 就像咱們在網站上註冊用戶，像國籍這種信息，你不填寫，默認就會是「CN」，這就是經過默認參數實現的，把country變成默認參數很是簡單：閉包

　　def stu_register(name,age,course,country="CN"):併發

這樣，country這個參數在調用時不指定，那默認就是CN，指定了的話，就用你指定的值。注意：默認參數只能放到最後面。 app

關鍵參數函數

正常狀況下，給函數傳參數要按順序，不想按順序就能夠用關鍵參數，只需指定參數名便可，但記住一個要求就是，關鍵參數必須放在位置參數以後網站

　　stu_register(age=22,name='alex',course="python")

非固定參數

若你的函數在定義時不肯定用戶想傳入多少個參數，就可使用非固定參數

def stu_register(name,age,*args):  #*args 會把多傳入的參數變成一個元組形式
    print(name,age,args) stu_register("Tom",22) #輸出 #Tom 22 () 　　　　　　　　　　　　　　#後面這個()就是args,只是由於沒傳值,因此爲空
 stu_register("Jack",32,"CN","Python") #輸出 #Jack 32 ('CN', 'Python')

還能夠有一個**kwargs

def stu_register(name,age,*args,**kwargs):  #*kwargs 會把多傳入的參數變成一個dict形式
    print(name,age,args,kwargs) stu_register("Tom",22) #輸出 #Tom 22 () {}　　　　　　　　　　　　　　　　　　 #後面這個{}就是kwargs,只是由於沒傳值,因此爲空
 stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong") #輸出 # Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

調用函數時，沒有對應上的位置參數會傳入*args，變成元組形式；關鍵參數會傳入**kwargs，變成字典形式。

全局變量與局部變量

在子程序中定義的變量稱爲局部變量，在程序的一開始定義的變量稱爲全局變量。

全局變量做用域是整個程序，局部變量做用域是定義該變量的子程序。

當全局變量與局部變量同名時：在定義局部變量的子程序內，局部變量起做用；在其它地方全局變量起做用。

三、返回值

要想獲取函數的執行結果，就能夠用return語句把結果返回

注意:

函數在執行過程當中只要遇到return語句，就會中止執行並返回結果，so 也能夠理解爲 return 語句表明着函數的結束
若是未在函數中指定return,那這個函數的返回值爲None

四、函數嵌套與函數遞歸

啥都別說直接看函數嵌套的代碼1：

name = "YL"
def change_name(): name = "YL2"
    def change_name2(): name = "YL3"
        print("第3層打印", name) change_name2() #調用內層函數
    print("第2層打印", name) change_name() print("最外層打印", name)

#輸出：
第3層打印 YL3
第2層打印 YL2
最外層打印 YL

代碼2：

#嵌套調用
def my_max4(a, b, c, d): res1 = my_max2(a, b) res2 = my_max2(res1, c) res3 = my_max2(res2, d) return res3 def my_max2(x, y): if x > y: return x else: return y print(my_max4(11,35,34,-5))  #35


#嵌套定義(一般2到3層，多了很差看懂)
x = 3
def f1(): x = 1
    def f2(): x = 2
        print(x) return f2 func = f1() func() #2

遞歸：若是一個函數在內部調用本身，這個函數就是遞歸函數

def calc(n): print(n) if int(n/2) ==0: return n return calc(int(n/2)) calc(10) 輸出： 10
5
2
1

遞歸特性:

1. 必須有一個明確的結束條件

2. 每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減小

3. 遞歸效率不高，遞歸層次過多會致使棧溢出（在計算機中，函數調用是經過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。因爲棧的大小不是無限的，因此，遞歸調用的次數過多，會致使棧溢出

堆棧掃盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

遞歸函數的實際應用：二分查找

def binary_search(find_str, data_set, count):  #參數說明：要找的數據，數據集合，查找計數器
    mid = int(len(data_set)/2) if mid == 0: if data_set[mid] == find_str: print("找到了->:", find_str, count) else: print("沒找到:", find_str, count) return
    if data_set[mid] == find_str: print("找到了：", data_set[mid], count) elif data_set[mid] > find_str: print("Going to search in left:", data_set[mid], data_set[0:mid]) binary_search(find_str, data_set[0:mid], count+1) else: print("Going to search in right:", data_set[mid], data_set[mid+1:]) binary_search(find_str, data_set[mid+1:], count+1) binary_search(585, data, 0)

五、匿名函數

匿名函數就是不須要顯式的指定函數

#這段代碼
def calc(n): return n**n print(calc(10)) #換成匿名函數
calc = lambda n:n**n print(calc(10))

這個看不出啥NB之處，那就看看下面的：

res = map(lambda x:x**2,[1,5,7,4,8]) for i in res: print(i) #輸出：
1
25
49
16
64

#匿名函數最複雜的函數就是三元運算，不能再複雜了
calc2 = lambda x, y: x**y print(calc2(10, 12)) for i in map(calc, [1, 2, 3]): print(i) for i in map(lambda x: x*x, [1, 2, 3]):  #逼格高
    print(i) for i in map(lambda x: x*2 if x>5 else x-1, [1, 2, 3]): print(i)

map()函數是Python內置函數，第一個參數接受一個函數名，後面的參數接受一個或多個可迭代的序列，返回的是一個集合。（後面的博客中會有詳細介紹）

六、高階函數

# 高階函數：1.把一個函數的內存地址當作參數傳給另外一個函數 # 2.一個函數把另外一個函數當作返回值 返回


def add(x, y, f): return f(x) + f(y) res = add(3, -6, abs)  #abs絕對值函數
print(res)

七、閉包函數

若是在一個內部函數裏，對在外部做用域（但不是在全局做用域）的變量進行引用，那麼內部函數就被認爲是閉包。

舉個栗子：

def closure(): x = 5
    def sub(): return x * x return sub

如上，在內部函數sub中包含了對函數closure中局部變量x的引用，這就是閉包。

閉包的意義：返回的函數對象，不只僅是一個函數對象，在該函數外還包裹了一層做用域，這使得，該函數不管在何處調用，優先使用本身外層包裹的做用域

應用領域：延遲計算（原來咱們是傳參，如今咱們是包起來）

再看一個nb一點的栗子：

from urllib.request import urlopen def page(url): #url = http//:www.baidu.com
    def get(): return urlopen(url).read() return get baidu = page('http://www.baidu.com') #爬取百度頁面 # python = page('http://www.python.org')

# print("python:", python())
print("baidu:", baidu().decode("utf-8")) #這裏要轉碼

八、裝飾器

裝飾器就是閉包函數的一種應用場景

裝飾器遵循開放封閉原則：對修改封閉，對擴展開放

裝飾器自己能夠是任意可調用對象，被裝飾者也能夠是任意可調用對象。

裝飾器的原則：一、不修改被裝飾對象的源代碼

　　　　　　　二、不修改被裝飾對象的調用方式

裝飾器的目標：在遵循以上兩點原則的前提下，爲被裝飾對象添加上新功能

#裝飾器語法
#被裝飾函數的正上方，單獨一行
@deco1 @deco2 @deco3 def foo(): pass

#此時調用foo就至關於---> foo=deco1(deco2(deco3(foo)))

舉個栗子：

#無參裝飾器
import time def timer(func): def wrapper(*arg, **kwargs): #任意參數傳入
        strat_time = time.time() res = func(*arg, **kwargs)#運行最原始的index
        stop_time = time.time() print("run time is %s" % (stop_time-strat_time)) return res return wrapper @timer #index = timer(index)
def index(msg): print("in the index:%s" % (msg)) @timer def home(user, msg): print("in the home:%s,%s" % (user, msg)) return "home return 1" index("hello world") print(home("jack", msg="123456")) #輸出-------------------
in the index:hello world run time is 0.0
in the home:jack,123456 run time is 0.0 home return 1

下面是有參裝飾器的栗子：

#有參裝飾器
accounts = {} current_logon_user = None def auth(auth_type): def auth_deco(func): def wrapper(*args, **kwargs): if current_logon_user not in accounts: #以前沒有驗證成功過
                username = input("username:") password = input("password:") if auth_type == "file": if username == "YL" and password == "123": accounts[username] = True global current_logon_user  #修改全局變量
                        current_logon_user = username return func(*args, **kwargs) elif auth_type == "ldap": print("----->ldap") return func(*args, **kwargs) else: return func(*args, **kwargs)   #若是驗證成功了的直接返回執行最原始的函數
        return wrapper return auth_deco @auth("file") def index(msg): print("in the index %s" %(msg)) @auth("ldap") def home(msg): print("in the home %s" %(msg)) index("hello")  #只要第一次驗證經過，後面就不須要驗證了
home("hello")

九、生成器

如今有個需求，將列表[0,1,2,3,4,5,6,7,8,9]裏的每個值都加一，有下面三種方法：

#普通青年版--->使用enumerate函數
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] for index, i in enumerate(a):  #將列表中的各項加一
    #print(index, i) 　　　　　　#打印下標和元素值
    a[index] += 1

print(a)

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #文藝青年版--->使用匿名函數和map函數
a = map(lambda x: x+1, a) for i in a: print(i)

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #nb青年版----->使用列表生成
a = [i+1 for i in a] print(a)           　　　　　　　　　　　　#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#列表生成式還可使用三元運算 #a = [i*i if i>5 else i-1 for i in a] #大於5的進行平方運算，小於5的進行減1運算 #print(a) 　　　　　　　　　　　　 #[-1, 0, 1, 2, 3, 4, 36, 49, 64, 81]

　　經過上面的列表生成式，咱們能夠直接建立一個列表。可是，受到內存限制，列表容量確定是有限的。並且，若是建立一個包含100萬個元素的列表，就會佔用很大的存儲空間，若是咱們僅僅須要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了。

　　因此，若是列表元素能夠按照某種算法推算出來，那咱們是否能夠在循環的過程當中不斷推算出後續的元素呢？這樣就沒必要建立完整的list，從而節省大量的空間。在Python中，這種一邊循環一邊計算的機制，稱爲生成器：generator。

　　要建立一個generator，有不少種方法。第一種方法很簡單，只要把一個列表生成式的[]改爲()，就建立了一個generator：

L = [x * x for x in range(10)] print(L)   #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 g = (x * x for x in range(10)) print(g)   #<generator object <genexpr> at 0x00000133F4CE6FC0>

建立L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。

　　咱們能夠直接打印出list的每個元素，但咱們怎麼打印出generator的每個元素呢？若是要一個一個打印出來，能夠經過next()函數得到generator的下一個返回值：

g = (x * x for x in range(4)) print(g)   #<generator object <genexpr> at 0x00000133F4CE6FC0>

print(next(g))       #0
print(g.__next__())  #1
print(g.__next__())  #4
print(next(g))       #9 #print(next(a)) #最後一個元素已經計算出了，再調用next(g)就會報錯

generator保存的是算法，每次調用next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，拋出StopIteration的錯誤。固然，上面這種不斷調用next(g)實在是太變態了，正確的方法是使用for循環，由於generator也是可迭代對象：

for n in g: print(n) #輸出：
0 1
4
9

　　因此，咱們建立了一個generator後，基本上永遠不會調用next()，而是經過for循環來迭代它，而且不須要關心StopIteration的錯誤。generator很是強大。若是推算的算法比較複雜，用相似列表生成式的for循環沒法實現的時候，還能夠用函數來實現。

　　好比，著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數均可由前兩個數相加獲得：1, 1, 2, 3, 5, 8, 13, 21, 34, ...

　　斐波拉契數列用列表生成式寫不出來，可是，用函數把它打印出來卻很容易：

def fib(max): n, a, b = 0, 0, 1
    while n < max: print(b) a, b = b, a + b n = n + 1
    return 'done'

注意：

賦值語句：a, b = b, a + b 至關於： t = (b, a + b)  # t是一個tuple
            a = t[0] b = t[1]

調用上面的函數能夠輸出斐波那契數列的前N個數：

>>> fib(10) 1
1
2
3
5
8
13
21
34
55 done

　　仔細觀察，能夠看出，fib函數其實是定義了斐波拉契數列的推算規則，能夠從第一個元素開始，推算出後續任意的元素，這種邏輯其實很是相似generator。也就是說，上面的函數和generator僅一步之遙。要把fib函數變成generator，只須要把print(b)改成yield b就能夠了：

def generator(max): n, a, b = 0, 0, 1
    while n<max: #print(b)
        yield b             #生成器yield 保存了函數的中斷狀態
        a, b = b, a + b n = n+1
    return "done" g = generator(5) print(next(g)) print(g.__next__()) print("do something else") print(g.__next__()) print(g.__next__()) print(next(g)) # 輸出： # 1 # 1 # do something else # 2 # 3 # 5

這就是定義generator的另外一種方法。若是一個函數定義中包含yield關鍵字，那麼這個函數就再也不是一個普通函數，而是一個generator：

　　注意，最難理解的就是generator和函數的執行流程不同。函數是順序執行，遇到return語句或者最後一行函數語句就返回。而變成generator的函數，在每次調用next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

　　在上面generator(max)的例子中，咱們在循環過程當中不斷調用yield，就會不斷中斷。固然要給循環設置一個條件來退出循環，否則就會產生一個無限數列出來。

一樣的，把函數改爲generator後，咱們基本上歷來不會用next()來獲取下一個返回值，而是直接使用for循環來迭代：

for n in generator(6): print(n) #輸出
1
1
2
3
5
8

可是用for循環調用generator時，發現拿不到generator的return語句的返回值「done」。若是想要拿到返回值，必須捕獲StopIteration錯誤，返回值包含在StopIteration的value中。（關於如何捕獲錯誤，後面的錯誤處理還會詳細講解）

還可經過yield實如今單線程的狀況下實現併發運算的效果：

#吃包子 #經過生成器實現協程並行運算
import time def consumer(name): print("%s 準備吃包子啦!" % name) while True:       #死循環
       baozi = yield  #接收到producer send 過來的值

       print("包子[%s]來了,被[%s]吃了!" % (baozi, name)) def producer(): c = consumer('A') c2 = consumer('B') c.__next__() c2.__next__() print("開始準備作包子啦!") for i in range(10): time.sleep(1) print("作了2個包子!") c.send(i) #調用next 並傳了一個值給yield
 c2.send(i) producer()

十、迭代器

咱們已經知道，能夠直接做用於for循環的數據類型有如下幾種：

　　一類是集合數據類型，如list、tuple、dict、set、str等；

　　一類是generator，包括生成器和帶yield的generator function。

這些能夠直接做用於for循環的對象統稱爲可迭代對象：Iterable。

可使用isinstance()判斷一個對象是不是Iterable對象：

>>> from collections import Iterable >>> isinstance([], Iterable) True >>> isinstance({}, Iterable) True >>> isinstance('abc', Iterable) True >>> isinstance((x for x in range(10)), Iterable) True >>> isinstance(100, Iterable) False

而生成器不但能夠做用於for循環，還能夠被next()函數不斷調用並返回下一個值，直到最後拋出StopIteration錯誤表示沒法繼續返回下一個值了。

能夠被next()函數調用並不斷返回下一個值的對象稱爲迭代器：Iterator。

可使用isinstance()判斷一個對象是不是Iterator對象：

>>> from collections import Iterator >>> isinstance((x for x in range(10)), Iterator) True >>> isinstance([], Iterator) False >>> isinstance({}, Iterator) False >>> isinstance('abc', Iterator) False

生成器都是Iterator迭代器對象，但list、dict、str雖然是Iterable可迭代對象，卻不是Iterator迭代器。

把list、dict、str等Iterable變成Iterator可使用iter()函數：

>>> isinstance(iter([]), Iterator) True >>> isinstance(iter('abc'), Iterator) True

那麼，爲何list、dict、str等數據類型不是Iterator？

　　這是由於Python的Iterator迭代器對象表示的是一個數據流，Iterator對象能夠被next()函數調用並不斷返回下一個數據，直到沒有數據時拋出StopIteration錯誤。能夠把這個數據流看作是一個有序序列，但咱們卻不能提早知道序列的長度，只能不斷經過next()函數實現按需計算下一個數據，因此Iterator的計算是惰性的，只有在須要返回下一個數據時它纔會計算。

　　Iterator甚至能夠表示一個無限大的數據流，例如全體天然數。而使用list是永遠不可能存儲全體天然數的。

小結：

　　凡是可做用於for循環的對象都是Iterable類型；

　　凡是可做用於next()函數的對象都是Iterator類型，它們表示一個惰性計算的序列；

　　集合數據類型如list、dict、str等是Iterable但不是Iterator，不過能夠經過iter()函數得到一個Iterator對象。

Python的for循環本質上就是經過不斷調用next()函數實現的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

等價於下面的代碼：

# 首先得到Iterator對象:
it = iter([1, 2, 3, 4, 5])
# 循環:
while True:
    try:
        # 得到下一個值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循環
        break