1. 函式
在python中，函式通過def關鍵字、函式名和可選的引數串列定義，通過return關鍵字回傳值，我們舉例來說明如何定義和呼叫一個簡單的函式：
>>> def foo():
... return 1
>>> foo()
1
方法體（當然多行也是一樣的）是必須的，通過縮進來表示，在方法名的后面加上雙括號()就能夠呼叫函式
2. 作用域
在python中，函式會創建一個新的作用域，python開發者可能會說函式有自己的命名空間，差不多一個意思，這意味著在函式內部碰到一個變數的時候函式會優先在自己的命名空間里面去尋找，讓我們寫一個簡單的函式看一下 本地作用域 和 全域作用域有什么不同：
>>> a_string = "This is a global variable"
>>> def foo():
... print locals()
>>> print globals()
{..., 'a_string': 'This is a global variable'}
>>> foo() # 2
{}
內置的函式globals回傳一個包含所有python解釋器知道的變數名稱的字典（為了干凈和洗的白白的，我省略了python自行創建的一些變數），在#2我呼叫了函式 foo 把函式內部本地作用域里面的內容列印出來，我們能夠看到，函式foo有自己獨立的命名空間，雖然暫時命名空間里面什么都還沒有，
3. 變數決議規則
當然這并不是說我們在函式里面就不能訪問外面的全域變數，在python的作用域規則里面，創建變數一定會一定會在當前作用域里創建一個變數，但是訪問或者修改變數時會先在當前作用域查找變數，沒有找到匹配變數的話會依次向上在閉合的作用域里面進行查看找，所以如果我們修改函式foo的實作讓它列印全域的作用域里的變數也是可以的：
>>> a_string = "This is a global variable"
>>> def foo():
... print a_string # 1
>>> foo()
This is a global variable
在#1處，python解釋器會嘗試查找變數a_string，當然在函式的本地作用域里面是找不到的，所以接著會去上層的作用域里面去查找，
但是另一方面，假如我們在函式內部給全域變數賦值，結果卻和我們想的不一樣：
>>> a_string = "This is a global variable"
>>> def foo():
... a_string = "test" # 1
... print locals()
>>> foo()
{'a_string': 'test'}
>>> a_string # 2
'This is a global variable'
我們能夠看到，全域變數能夠被訪問到（如果是可變資料型別(像list,dict這些)甚至能夠被更改）但是賦值不行，在函式內部的#1處，我們實際上新創建了一個區域變數，隱藏全域作用域中的同名變數，我們可以通過列印出區域命名空間中的內容得出這個結論，我們也能看到在#2處列印出來的變數a_string的值并沒有改變，
4. 變數生存周期
值得注意的一個點是，變數不僅是生存在一個個的命名空間內，他們都有自己的生存周期，請看下面這個例子：
>>> def foo():
... x = 1
>>> foo()
>>> print x # 1
Traceback (most recent call last):
...
NameError: name 'x' is not defined
1處發生的錯誤不僅僅是因為作用域規則導致的（盡管這是拋出了NameError的錯誤的原因）它還和python以及其它很多編程語言中函式呼叫實作的機制有關，在這個地方這個執行時間點并沒有什么有效的語法讓我們能夠獲取變數x的值，因為它這個時候壓根不存在！函式foo的命名空間隨著函式呼叫開始而開始，結束而銷毀，
5. 函式引數
python允許我們向函式傳遞引數，引數會變成本地變數存在于函式內部，
>>> def foo(x):
... print locals()
>>> foo(1)
{'x': 1}
在Python里有很多的方式來定義和傳遞引數，完整版可以查看 python官方檔案，我們這里簡略的說明一下：函式的引數可以是必須的位置引數或者是可選的命名，默認引數，
>>> def foo(x, y=0): # 1
... return x - y
>>> foo(3, 1) # 2
2
>>> foo(3) # 3
3
>>> foo() # 4
Traceback (most recent call last):
...
TypeError: foo() takes at least 1 argument (0 given)
>>> foo(y=1, x=3) # 5
2
在#1處我們定義了函式foo,它有一個位置引數x和一個命名引數y，在#2處我們能夠通過常規的方式來呼叫函式，盡管有一個命名引數，但引數依然可以通過位置傳遞給函式，在呼叫函式的時候，對于命名引數y我們也可以完全不管就像#3處所示的一樣，如果命名引數沒有接收到任何值的話，python會自動使用宣告的默認值也就是0，需要注意的是我們不能省略第一個位置引數x, 否則的話就會像#5處所示發生錯誤，
目前還算簡潔清晰吧， 但是接下來可能會有點令人困惑，python支持函式呼叫時的命名引數（個人覺得應該是命名實參），看看#5處的函式呼叫，我們傳遞的是兩個命名實參，這個時候因為有名稱標識，引數傳遞的順序也就不用在意了，
當然相反的情況也是正確的：函式的第二個形參是y，但是我們通過位置的方式傳遞值給它，在#2處的函式呼叫foo(3,1)，我們把3傳遞給了第一個引數，把1傳遞給了第二個引數，盡管第二個引數是一個命名引數，
桑不起，感覺用了好大一段才說清楚這么一個簡單的概念：函式的引數可以有名稱和位置，這意味著在函式的定義和呼叫的時候會稍稍在理解上有點兒不同，我們可以給只定義了位置引數的函式傳遞命名引數（實參），反之亦然！如果覺得不夠可以查看官方檔案
6. 嵌套函式
Python允許創建嵌套函式，這意味著我們可以在函式里面定義函式而且現有的作用域和變數生存周期依舊適用，
>>> def outer():
... x = 1
... def inner():
... print x # 1
... inner() # 2
...
>>> outer()
1
這個例子有一點兒復雜，但是看起來也還行，想一想在#1發生了什么：python解釋器需找一個叫x的本地變數，查找失敗之后會繼續在上層的作用域里面尋找，這個上層的作用域定義在另外一個函式里面，對函式outer來說，變數x是一個本地變數，但是如先前提到的一樣，函式inner可以訪問封閉的作用域（至少可以讀和修改），
在#2處，我們呼叫函式inner，非常重要的一點是，inner也僅僅是一個遵循python變數決議規則的變數名，python解釋器會優先在outer的作用域里面對變數名inner查找匹配的變數.
7. 函式是python世界里的一級類物件
顯而易見，在python里函式和其他東西一樣都是物件，（此處應該大聲歌唱）啊！包含變數的函式，你也并不是那么特殊！
>>> issubclass(int, object) # all objects in Python inherit from a common baseclass
True
>>> def foo():
... pass
>>> foo.__class__ # 1
<type 'function'>
>>> issubclass(foo.__class__, object)
True
你也許從沒有想過，你定義的函式居然會有屬性，沒辦法，函式在python里面就是物件，和其他的東西一樣，也許這樣描述會太學院派太官方了點：在python里，函式只是一些普通的值而已和其他的值一毛一樣，這就是說你尅一把函式想引數一樣傳遞給其他的函式或者說從函式了里面回傳函式！如果你從來沒有這么想過，那看看下面這個例子：
>>> def add(x, y):
... return x + y
>>> def sub(x, y):
... return x - y
>>> def apply(func, x, y): # 1
... return func(x, y) # 2
>>> apply(add, 2, 1) # 3
3
>>> apply(sub, 2, 1)
1
這個例子對你來說應該不會很奇怪，add和sub是非常普通的兩個python函式，接受兩個值，回傳一個計算后的結果值，在#1處你們能看到準備接收一個函式的變數只是一個普通的變數而已，和其他變數一樣，在#2處我們呼叫傳進來的函式：“()代表著呼叫的操作并且呼叫變數包含的值，
在#3處，你們也能看到傳遞函式并沒有什么特殊的語法，” 函式的名稱只是很其他變數一樣的表識別符號而已，
你們也許看到過這樣的行為：“python把頻繁要用的操作變成函式作為引數進行使用，像通過傳遞一個函式給內置排序函式的key引數從而來自定義排序規則，那把函式當做回傳值回事這樣的情況呢：
>>> def outer():
... def inner():
... print "Inside inner"
... return inner # 1
...
>>> foo = outer() #2
>>> foo
<function inner at 0x...>
>>> foo()
Inside inner
這個例子看起來也許會更加的奇怪，在#1處我把恰好是函式識別符號的變數inner作為回傳值回傳出來，這并沒有什么特殊的語法：”把函式inner回傳出來，否則它根本不可能會被呼叫到，“還記得變數的生存周期嗎？每次函式outer被呼叫的時候，函式inner都會被重新定義，如果它不被當做變數回傳的話，每次執行過后它將不復存在，
在#2處我們捕獲住回傳值 - 函式inner，將它存在一個新的變數foo里，我們能夠看到，當對變數foo進行求值，它確實包含函式inner，而且我們能夠對他進行呼叫，初次看起來可能會覺得有點奇怪，但是理解起來并不困難是吧，堅持住，因為奇怪的轉折馬上就要來了
8. 閉包
我們先不急著定義什么是閉包，先來看看一段代碼，僅僅是把上一個例子簡單的調整了一下：
>>> def outer():
... x = 1
... def inner():
... print x # 1
... return inner
>>> foo = outer()
>>> foo.func_closure
(<cell at 0x...: int object at 0x...>,)
在上一個例子中我們了解到，inner作為一個函式被outer回傳，保存在一個變數foo，并且我們能夠對它進行呼叫foo()，不過它會正常的運行嗎？我們先來看看作用域規則，
所有的東西都在python的作用域規則下進行作業：“x是函式outer里的一個區域變數，當函式inner在#1處列印x的時候，python解釋器會在inner內部查找相應的變數，當然會找不到，所以接著會到封閉作用域里面查找，并且會找到匹配，
但是從變數的生存周期來看，該怎么理解呢？我們的變數x是函式outer的一個本地變數，這意味著只有當函式outer正在運行的時候才會存在，根據我們已知的python運行模式，我們沒法在函式outer回傳之后繼續呼叫函式inner，在函式inner被呼叫的時候，變數x早已不復存在，可能會發生一個運行時錯誤，
萬萬沒想到，回傳的函式inner居然能夠正常作業，Python支持一個叫做函式閉包的特性，用人話來講就是，嵌套定義在非全域作用域里面的函式能夠記住它在被定義的時候它所處的封閉命名空間，這能夠通過查看函式的func_closure屬性得出結論，這個屬性里面包含封閉作用域里面的值（只會包含被捕捉到的值，比如x，如果在outer里面還定義了其他的值，封閉作用域里面是不會有的）
記住，每次函式outer被呼叫的時候，函式inner都會被重新定義，現在變數x的值不會變化，所以每次回傳的函式inner會是同樣的邏輯，假如我們稍微改動一下呢？
>>> def outer(x):
... def inner():
... print x # 1
... return inner
>>> print1 = outer(1)
>>> print2 = outer(2)
>>> print1()
1
>>> print2()
2
從這個例子中你能夠看到閉包 - 被函式記住的封閉作用域 - 能夠被用來創建自定義的函式，本質上來說是一個硬編碼的引數，事實上我們并不是傳遞引數1或者2給函式inner，我們實際上是創建了能夠列印各種數字的各種自定義版本，
閉包單獨拿出來就是一個非常強大的功能， 在某些方面，你也許會把它當做一個類似于面向物件的技術：outer像是給inner服務的構造器，x像一個私有變數，使用閉包的方式也有很多：你如果熟悉python內置排序方法的引數key，你說不定已經寫過一個lambda方法在排序一個串列的串列的時候基于第二個元素而不是第一個，現在你說不定也可以寫一個itemgetter方法，接收一個索引值來回傳一個完美的函式，傳遞給排序函式的引數key，
不過，我們現在不會用閉包做這么low的事(⊙o⊙)…！相反，讓我們再爽一次，寫一個高大上的裝飾器!
9. 裝飾器
裝飾器其實就是一個閉包，把一個函式當做引數然后回傳一個替代版函式，我們一步步從簡到繁來瞅瞅：
>>> def outer(some_func):
... def inner():
... print "before some_func"
... ret = some_func() # 1
... return ret + 1
... return inner
>>> def foo():
... return 1
>>> decorated = outer(foo) # 2
>>> decorated()
before some_func
2
仔細看看上面這個裝飾器的例子，們定義了一個函式outer，它只有一個some_func的引數，在他里面我們定義了一個嵌套的函式inner，inner會列印一串字串，然后呼叫some_func，在#1處得到它的回傳值，在outer每次呼叫的時候some_func的值可能會不一樣，但是不管some_func的之如何，我們都會呼叫它，最后，inner回傳some_func() + 1的值 - 我們通過呼叫在#2處存盤在變數decorated里面的函式能夠看到被列印出來的字串以及回傳值2，而不是期望中呼叫函式foo得到的回傳值1，
我們可以認為變數decorated是函式foo的一個裝飾版本，一個加強版本，事實上如果打算寫一個有用的裝飾器的話，我們可能會想愿意用裝飾版本完全取代原先的函式foo，這樣我們總是會得到我們的”加強版“foo，想要達到這個效果，完全不需要學習新的語法，簡單地賦值給變數foo就行了：
>>> foo = outer(foo)
>>> foo # doctest: +ELLIPSIS
<function inner at 0x...>
現在，任何怎么呼叫都不會牽扯到原先的函式foo，都會得到新的裝飾版本的foo，現在我們還是來寫一個有用的裝飾器，
想象我們有一個庫，這個庫能夠提供類似坐標的物件，也許它們僅僅是一些x和y的坐標對，不過可惜的是這些坐標物件不支持數學運算子，而且我們也不能對源代碼進行修改，因此也就不能直接加入運算子的支持，我們將會做一系列的數學運算，所以我們想要能夠對兩個坐標物件進行合適加減運算的函式，這些方法很容易就能寫出：
>>> class Coordinate(object):
... def __init__(self, x, y):
... self.x = x
... self.y = y
... def __repr__(self):
... return "Coord: " + str(self.__dict__)
>>> def add(a, b):
... return Coordinate(a.x + b.x, a.y + b.y)
>>> def sub(a, b):
... return Coordinate(a.x - b.x, a.y - b.y)
>>> one = Coordinate(100, 200)
>>> two = Coordinate(300, 200)
>>> add(one, two)
Coord: {'y': 400, 'x': 400}
如果不巧我們的加減函式同時也需要一些邊界檢查的行為那該怎么辦呢？搞不好你只能夠對正的坐標物件進行加減操作，任何回傳的值也都應該是正的坐標，所以現在的期望是這樣：
>>> one = Coordinate(100, 200)
>>> two = Coordinate(300, 200)
>>> three = Coordinate(-100, -100)
>>> sub(one, two)
Coord: {'y': 0, 'x': -200}
>>> add(one, three)
Coord: {'y': 100, 'x': 0}
我們期望在不更改坐標物件one, two, three的前提下one減去two的值是{x: 0, y: 0}，one加上three的值是{x: 100, y: 200}，與其給每個方法都加上引數和回傳值邊界檢查的邏輯，我們來寫一個邊界檢查的裝飾器！
>>> def wrapper(func):
... def checker(a, b): # 1
... if a.x < 0 or a.y < 0:
... a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)
... if b.x < 0 or b.y < 0:
... b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)
... ret = func(a, b)
... if ret.x < 0 or ret.y < 0:
... ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)
... return ret
... return checker
>>> add = wrapper(add)
>>> sub = wrapper(sub)
>>> sub(one, two)
Coord: {'y': 0, 'x': 0}
>>> add(one, three)
Coord: {'y': 200, 'x': 100}
IDE演示
'''
學習中遇到問題沒人解答？小編創建了一個Python學習交流QQ群：711312441
尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！
'''
class Coordinate(object):
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "Coord: " + str(self.__dict__)
def add(a, b):
return Coordinate(a.x + b.x, a.y + b.y)
def sub(a, b):
return Coordinate(a.x - b.x, a.y - b.y)
one = Coordinate(100, 200)
two = Coordinate(300, 200)
print(add(one, two))
#Coord: {'y': 400, 'x': 400}
print("------------------------------------")
one = Coordinate(100, 200)
two = Coordinate(300, 200)
three = Coordinate(-100, -100)
print(sub(one, two))
#Coord: {'y': 0, 'x': -200}
print(add(one, three))
#Coord: {'y': 100, 'x': 0}
print("------------------------------------")
def wrapper(func):
def checker(a, b): # 1
if a.x < 0 or a.y < 0:
a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)
if b.x < 0 or b.y < 0:
b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)
ret = func(a, b)
if ret.x < 0 or ret.y < 0:
ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)
return ret
return checker
add = wrapper(add)
sub = wrapper(sub)
print(sub(one, two))
#Coord: {'y': 0, 'x': 0}
print(add(one, three))
#Coord: {'y': 200, 'x': 100}
結果：
Coord: {'x': 400, 'y': 400}
------------------------------------
Coord: {'x': -200, 'y': 0}
Coord: {'x': 0, 'y': 100}
------------------------------------
Coord: {'x': 0, 'y': 0}
Coord: {'x': 100, 'y': 200}
這個裝飾器能想先前的裝飾器例子一樣進行作業，回傳一個經過修改的函式，但是在這個例子中，它能夠對函式的輸入引數和回傳值做一些非常有用的檢查和格式化作業，將負值的x和 y替換成0，
顯而易見，通過這樣的方式，我們的代碼變得更加簡潔：將邊界檢查的邏輯隔離到單獨的方法中，然后通過裝飾器包裝的方式應用到我們需要進行檢查的地方，另外一種方式通過在計算方法的開始處和回傳值之前呼叫邊界檢查的方法也能夠達到同樣的目的，但是不可置否的是，使用裝飾器能夠讓我們以最少的代碼量達到坐標邊界檢查的目的，事實上，如果我們是在裝飾自己定義的方法的話，我們能夠讓裝飾器應用的更加有逼格，
10. 使用 @ 識別符號將裝飾器應用到函式
Python2.4支持使用識別符號@將裝飾器應用在函式上，只需要在函式的定義前加上@和裝飾器的名稱，在上一節的例子里我們是將原本的方法用裝飾后的方法代替:
>>> add = wrapper(add)
這種方式能夠在任何時候對任意方法進行包裝，但是如果我們自定義一個方法，我們可以使用@進行裝飾：
>>> @wrapper
... def add(a, b):
... return Coordinate(a.x + b.x, a.y + b.y)
需要明白的是，這樣的做法和先前簡單的用包裝方法替代原有方法是一毛一樣的， python只是加了一些語法糖讓裝飾的行為更加的直接明確和優雅一點，
def login(func): #傳入引數func = tv
def inner(arg):
print("passed user verifcation...")
func(arg)
return inner
def tv(name):
print("Welcome [%s] to TV page" % (name))
tv = login(tv)
tv(("Amu"))
結果：
passed user verifcation...
Welcome [Amu] to TV page
使用識別符號@將裝飾器應用在函式
def login(func): #傳入引數func = tv
def inner(arg):
print("passed user verifcation...")
func(arg)
return inner
@login #裝飾器 使用識別符號@將裝飾器應用在函式
def tv(name):
print("Welcome [%s] to TV page" % (name))
#tv = login(tv)
tv(("Amu"))
結果：
passed user verifcation...
Welcome [Amu] to TV page
11. *args and **kwargs
我們已經完成了一個有用的裝飾器，但是由于硬編碼的原因它只能應用在一類具體的方法上，這類方法接收兩個引數，傳遞給閉包捕獲的函式，如果我們想實作一個能夠應用在任何方法上的裝飾器要怎么做呢？再比如，如果我們要實作一個能應用在任何方法上的類似于計數器的裝飾器，不需要改變原有方法的任何邏輯，這意味著裝飾器能夠接受擁有任何簽名的函式作為自己的被裝飾方法，同時能夠用傳遞給它的引數對被裝飾的方法進行呼叫，
非常巧合的是Python正好有支持這個特性的語法，可以閱讀 Python Tutorial 獲取更多的細節，當定義函式的時候使用了，意味著那些通過位置傳遞的引數將會被放在帶有前綴的變數中， 所以：
>>> def one(*args):
... print args # 1
>>> one()
()
>>> one(1, 2, 3)
(1, 2, 3)
>>> def two(x, y, *args): # 2
... print x, y, args
>>> two('a', 'b', 'c')
a b ('c',)
第一個函式one只是簡單地講任何傳遞過來的位置引數全部列印出來而已，你們能夠看到，在代碼#1處我們只是參考了函式內的變數args, *args僅僅只是用在函式定義的時候用來表示位置引數應該存盤在變數args里面，Python允許我們制定一些引數并且通過args捕獲其他所有剩余的未被捕捉的位置引數，就像#2處所示的那樣，
*運算子在函式被呼叫的時候也能使用，意義基本是一樣的，當呼叫一個函式的時候，一個用*標志的變數意思是變數里面的內容需要被提取出來然后當做位置引數被使用，同樣的，來看個例子：
>>> def add(x, y):
... return x + y
>>> lst = [1,2]
>>> add(lst[0], lst[1]) # 1
3
>>> add(*lst) # 2
3
1處的代碼和#2處的代碼所做的事情其實是一樣的，在#2處，python為我們所做的事其實也可以手動完成，這也不是什么壞事，*args要么是表示呼叫方法大的時候額外的引數可以從一個可迭代串列中取得，要么就是定義方法的時候標志這個方法能夠接受任意的位置引數，
接下來提到的**會稍多更復雜一點，**代表著鍵值對的引數字典，和*所代表的意義相差無幾，也很簡單對不對：
'''
學習中遇到問題沒人解答？小編創建了一個Python學習交流群：711312441
尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！
'''
>>> def foo(**kwargs):
... print kwargs
>>> foo()
{}
>>> foo(x=1, y=2)
{'y': 2, 'x': 1}
當我們定義一個函式的時候，我們能夠用**kwargs來表明，所有未被捕獲的關鍵字引數都應該存盤在kwargs的字典中，如前所訴，argshe kwargs并不是python語法的一部分，但在定義函式的時候，使用這樣的變數名算是一個不成文的約定，和*一樣，我們同樣可以在定義或者呼叫函式的時候使用**，
>>> dct = {'x': 1, 'y': 2}
>>> def bar(x, y):
... return x + y
>>> bar(**dct)
3
12. 更通用的裝飾器
有了這招新的技能，我們隨隨便便就可以寫一個能夠記錄下傳遞給函式引數的裝飾器了，先來個簡單地把日志輸出到界面的例子：
>>> def logger(func):
... def inner(*args, **kwargs): #1
... print "Arguments were: %s, %s" % (args, kwargs)
... return func(*args, **kwargs) #2
... return inner
請注意我們的函式inner，它能夠接受任意數量和型別的引數并把它們傳遞給被包裝的方法，這讓我們能夠用這個裝飾器來裝飾任何方法，
>>> @logger
... def foo1(x, y=1):
... return x * y
>>> @logger
... def foo2():
... return 2
>>> foo1(5, 4)
Arguments were: (5, 4), {}
20
>>> foo1(1)
Arguments were: (1,), {}
1
>>> foo2()
Arguments were: (), {}
2
隨便呼叫我們定義的哪個方法，相應的日志也會列印到輸出視窗，和我們預期的一樣，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/498705.html
標籤：Python