摘要：函數(shù)內(nèi)的變量被稱為局部變量，這是與全局變量相反的概念。有一些進(jìn)行函數(shù)式編程的機(jī)制。繼承以通用的類為基礎(chǔ)建立專門的類對(duì)象。

假設(shè)有如下函數(shù)：

def add(x,y): return x+y

比如說有個(gè)包含由兩個(gè)相加的數(shù)字組成的元組：

params = (1,2)

使用*運(yùn)算符對(duì)參數(shù)進(jìn)行“分配”，不過是在調(diào)用而不是在定義時(shí)使用：

>>> add(*params)
3

======

同樣，可以使用 雙星號(hào) 運(yùn)算符來處理字典。

假設(shè)之前定義了hello_3，那么可以這樣使用：

>>> params = {"name":Sir Robin","greeting":"Well met"}
>>> hello_3(**params)
Well met.Sir Robin

星號(hào)只在 定義函數(shù)（允許使用不定數(shù)目的參數(shù)）或者 調(diào)用（“分割”字典或者序列)時(shí)才有用。

在執(zhí)行x=1賦值語句后，名稱x引用到值1。這就像是使用字典一樣，鍵引用值。當(dāng)然，變量和所對(duì)應(yīng)的值用的是個(gè)“不可見”的字典。

內(nèi)建的vars函數(shù)可以返回這個(gè)字典：

>>> x = 1
>>> scope = vars()
>>> scope["x"]
1
>>> scope["x"] += 1
>>> x
2

這類“不可見字典”叫做 命名空間 或者 作用域 。除了全局作用域外，每個(gè)函數(shù)調(diào)用都會(huì)創(chuàng)建一個(gè)新的作用域：

>>> def foo(): x = 42
...
>>> x = 1
>>> foo()
>>> x
1

這里的foo函數(shù)改變（重綁定）了變量x，但是在最后的時(shí)候，x并沒有變。這是因?yàn)楫?dāng)調(diào)用foo的時(shí)候，新的命名空間就被創(chuàng)建了，它作用于foo內(nèi)的代碼塊。賦值語句x=42只在內(nèi)部作用域（局部命名空間）起作用，所以它并不影響外部（全局）作用域中的x。

函數(shù)內(nèi)的變量被稱為局部變量（local variable），這是與全局變量相反的概念。參數(shù)的工作原理類似于局部變量，所以用全局變量的名字作為參數(shù)名并沒有問題。

>>> def output(x): print x
...
>>> x = 1
>>> y = 2
>>> output(y)
2

======

重綁定全局變量：

如果在函數(shù)內(nèi)部將值賦予一個(gè)變量，它將會(huì)自動(dòng)成為局部變量——除非告知Python將其聲明為全局變量：

>>> x = 1
>>> def change_global():
        global x
        x = x + 1
        
>>> change_global()
>>> x
2

======

Python的函數(shù)是可以嵌套的：

def foo():
    def bar():
        print "Hello,World！"
    bar()

函數(shù)嵌套有一個(gè)很突出的應(yīng)用，例如需要一個(gè)函數(shù)“創(chuàng)建”另一個(gè)。也就意味著可以像下面這樣（在其他函數(shù)內(nèi)）書寫函數(shù)：

def multiplier(factor):
    def multiplier(number):
        return number*factor
    returnmultiplyByFactor

一個(gè)函數(shù)位于另外一個(gè)里面，外層函數(shù)返回里層函數(shù)。也就是說函數(shù)本身被返回了，但并沒有被調(diào)用。重要的是返回的函數(shù)還可以訪問它的定義所在的作用域。換句話說，它“帶著”它的環(huán)境（和相關(guān)的局部變量）。

每次調(diào)用外層函數(shù)，它內(nèi)部的函數(shù)都被重新綁定。factor變量每次都有一個(gè)新的值。由于Python的嵌套作用域，來自（`multiplier的)外部作用域的這個(gè)變量，稍后會(huì)被內(nèi)層函數(shù)訪問：

>>> double = multiplier(2)
>>> double(5)
10
>>> triple = multiplier(3)
>>> triple(3)
9
>>> multiplier(5)(4)
20

類似multiplayByFactor函數(shù)存儲(chǔ)子封閉作用域的行為叫做閉包（closure）。

遞歸的定義（包括遞歸函數(shù)定義）包括它們自身定義內(nèi)容的引用。

關(guān)于遞歸，一個(gè)類似的函數(shù)定義如下：

def recursion():
    return recursion()

理論上講，上述程序應(yīng)該永遠(yuǎn)地運(yùn)行下去，然而每次調(diào)用函數(shù)都會(huì)用掉一點(diǎn)內(nèi)存，在足夠的函數(shù)調(diào)用發(fā)生后（在之前的調(diào)用返回后），空間就不夠了，程序會(huì)以一個(gè)“超過最大遞歸深度”的錯(cuò)誤信息結(jié)束。

這類遞歸就做無窮遞歸（infinite recursion），類似于以while True開始的無窮循環(huán)，中間沒有break或者return語句。因?yàn)椋ɡ碚撋现v）它永遠(yuǎn)不會(huì)結(jié)束。

有用的遞歸函數(shù)包含以下幾個(gè)部分：

當(dāng)函數(shù)直接返回值時(shí)有基本實(shí)例（最小可能性問題）

遞歸實(shí)例，包括一個(gè)或者多個(gè)問題較小部分的遞歸調(diào)用。

這里的關(guān)鍵就是將問題分解成小部分，遞歸不可能永遠(yuǎn)繼續(xù)下去，因?yàn)樗偸且宰钚】赡苄詥栴}結(jié)束，而這些問題又存儲(chǔ)在基本實(shí)例中的。

當(dāng)每次函數(shù)被調(diào)用時(shí)，針對(duì)這個(gè)調(diào)用的新命名空間會(huì)被創(chuàng)建，意味著當(dāng)函數(shù)調(diào)用“自身”時(shí)，實(shí)際上運(yùn)行的是兩個(gè)不同的函數(shù)（或者說是同一個(gè)函數(shù)具有兩個(gè)不同的命名空間）。實(shí)際上，可以將它想象成和同種類的一個(gè)生物進(jìn)行對(duì)話的另一個(gè)生物對(duì)話。

計(jì)算數(shù)n的的階乘：

def factorial(n):
    result = n
    for i in range(1,n):
        result *= 1
        return result

遞歸實(shí)現(xiàn)：

1的階乘是1；

大于1的數(shù)n的階乘是n乘n-1的階乘。

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

======

計(jì)算冪

例子：power(x,n)(x為n的冪次）是x自乘n-1次的結(jié)果（所以x用作乘數(shù)n次。

def power(x,n):
    result = 1
    for i in range(n):
        result *= x
    return result

遞歸實(shí)現(xiàn)：

對(duì)于任意數(shù)字x來說，`power(x,0)是1；

對(duì)于任何大于0的書來說，power(x,n)是x乘以(x,n-1)的結(jié)果。

def power(x,n):
    if n == 0:
        return 1
    else:
        return x * power(x,n-1)

遞歸實(shí)現(xiàn)：

如果上下限相同，那么就是數(shù)字所在位置，返回；

否則找到兩者的中點(diǎn)（上下限的平均值），查找數(shù)字是在左側(cè)還是在右側(cè)，繼續(xù)查找數(shù)字所在的那半部分。

def search(sequence,number,lower,upper):
    if lower == upper:
        assert number == sequence[upper]
        return upper
    else:
        #整數(shù)除法//,浮點(diǎn)數(shù)除法/
        middle = (lower + upper) // 2 
        if number > sequence[middle]:
            return search(sequence,number,middle+1,upper)
        else:
            return search(sequence,number,lower,middle)

提示：標(biāo)準(zhǔn)庫中的bisect模塊可以非常有效地實(shí)現(xiàn)二分查找。

Python在應(yīng)對(duì)“函數(shù)式編程”方面有一些有用的函數(shù)：map、filter和reduce函數(shù)（Python3.0中都被移至fuctools模塊中）。

map和filter在目前版本的Python并非特別有用，并且可以使用列表推導(dǎo)式代替。不過可以使用map函數(shù)將序列中的元素全部傳遞給一個(gè)函數(shù)：

>>> map(str,range(10))        #Equivalent to [str(i) for i in range(10)]
["0","1","2","3","4","5","6","7","8","9"]

filter函數(shù)可以基于一個(gè)返回布爾值的函數(shù)對(duì)元素進(jìn)行過濾。

#island 判斷字符變量是否為字母或數(shù)字，
#若是則返回非零，否則返回零

>>> def fun(x):
        return x.isalnum()
        
>>> seq = ["foo","x41","?!","***"]
>>> filter(func,seq)
["foo","x41"]

本例中，使用列表推導(dǎo)式可以不用專門定義一個(gè)函數(shù)：

>>> [x for x in seq if x.isalnum()]
["foo","x41"]

事實(shí)上，還有個(gè)叫做lambda表達(dá)式的特性，可以創(chuàng)建短小的函數(shù)。

>>> filter(lambda x: x.isalnum().seq)
["foo","x41"]

=======

reduce函數(shù)一般來說不能輕松被列表推導(dǎo)式替代，但是通常用不到這個(gè)功能。它會(huì)將序列的前兩個(gè)元素與給定的函數(shù)聯(lián)合使用，并且將它們的返回值和第3個(gè)元素繼續(xù)聯(lián)合使用，直到整個(gè)序列都處理完畢，并且得到一個(gè)最終結(jié)果。

可以使用reduce函數(shù)加上lambda x,y:x+y（繼續(xù)使用相同的數(shù)字）:

>>> numbers = [72,101,108,108,111,44,32,119,111,114,108,100,33]
>>> reduce(lambda x,y:x+y,numbers)
1161

當(dāng)然，這里也可以使用內(nèi)建函數(shù)sum。

抽象。抽象是隱藏多余細(xì)節(jié)的藝術(shù)。定義處理細(xì)節(jié)的函數(shù)可以讓程序更抽象。

函數(shù)定義。函數(shù)使用def語句定義。它們是由語句組成的塊，可以從“外部世界”獲取值（參數(shù)），也可以返回一個(gè)或者多個(gè)值作為運(yùn)算的結(jié)果。

參數(shù)。函數(shù)從參數(shù)中得到需要的信息，也就是函數(shù)調(diào)用時(shí)設(shè)定的變量。Python中有兩類參數(shù)：位置參數(shù) 和 關(guān)鍵數(shù)參數(shù)。參數(shù)在給定默認(rèn)值時(shí)是可選的。

作用域。變量存儲(chǔ)在作用域（也叫作命名空間）中。Python有兩類主要的作用域——全局作用域 和 局部作用域。作用域可以嵌套。

遞歸。 函數(shù)可以調(diào)用自身即遞歸。一切用遞歸實(shí)現(xiàn)的功能都能用循環(huán)實(shí)現(xiàn)，但是有些時(shí)候遞歸函數(shù)更易讀。

函數(shù)式編程。Python有一些進(jìn)行函數(shù)式編程的機(jī)制。包括lambda表達(dá)式以及map、filter和reduce函數(shù)。

| 函數(shù) | 描述 |
| ------------- |:-------------|
| map(func,seq[,seq,...])| 對(duì)序列中的每個(gè)元素應(yīng)用函數(shù) |
| filter(fuc,seq) | 返回其函數(shù)為真的元素的列表 |
| reduce(func,seq[,initial]) | 等同于func(func(func(seq[0],seq[1],se1[2]... |
| sum(seq) | 返回seq所有元素的和 |
| apply(func,args[,kwargs]] | 調(diào)用函數(shù)，可以提供參數(shù) |

在面對(duì)對(duì)象程序設(shè)計(jì)中，術(shù)語對(duì)象（object）基本上可以看做數(shù)據(jù)（特性）以及由一系列可以存取、操作這些數(shù)據(jù)的方法所組成的集合。使用對(duì)象替代全局變量和函數(shù)的原因可能有很多，其中對(duì)象最重要的優(yōu)點(diǎn)包括以下幾方面：

多態(tài)（Polymorphism）：意味著可以對(duì)不同類的對(duì)象使用同樣的操作，它們會(huì)像“被施了魔法一般”工作。

封裝（Encapsulation）：對(duì)外部世界隱藏對(duì)象的工作細(xì)節(jié)。

繼承（Inheritance)：以通用的類為基礎(chǔ)建立專門的類對(duì)象。

術(shù)語多態(tài)的意思是“有多種形式”。多態(tài)意味著就算不知道變量所引用的對(duì)象類型是什么，還是能它進(jìn)行操作，而它也會(huì)根據(jù)對(duì)象（或類）類型的不同而表現(xiàn)出不同的行為。

repr函數(shù)是多態(tài)特性的代表之一，可以對(duì)任何東西使用：

def length_message(x):
    print "The length of",repr(x),"is",len（x）

>>> length_message("Fnord")
The length of "Fnord" is 5
>>> length_message([1,2,3])
The length of [1,2,3] is 3

很多函數(shù)和運(yùn)算符都是多態(tài)的——你寫的絕大多數(shù)程序可能都是，只要使用多態(tài)函數(shù)和運(yùn)算符，就會(huì)與“多態(tài)”發(fā)生關(guān)聯(lián)。事實(shí)上，唯一能毀掉多態(tài)的就是使用函數(shù)顯式地檢查類型，比如type、isinstance以及issubclass函數(shù)等等。如果可能的話，應(yīng)該盡力避免使用這些毀掉多態(tài)的方式。真正重要的是如何讓對(duì)象按照你所希望的方式工作，不管它是不是真正的類型（或者類）。

封裝是指向程序中的其他部分隱藏對(duì)象的具體實(shí)現(xiàn)細(xì)節(jié)的原則。

但是封裝并不等同于多態(tài)，多態(tài)可以讓用戶對(duì)于不知道什么是類（對(duì)象類型）的對(duì)象進(jìn)行方法調(diào)用，而封裝是可以不用關(guān)心對(duì)象是如何構(gòu)建的而直接進(jìn)行使用。

基本上，需要將對(duì)象進(jìn)行抽象，調(diào)用方法的時(shí)候不用關(guān)心其他的東西，比如它是否干擾了全局變量。

可以將其作為 特性（attribute） 存儲(chǔ)。特性是作為變量構(gòu)成對(duì)象的一部分，事實(shí)上方法更像是綁定到函數(shù)上的屬性。

對(duì)象有著自己的狀態(tài)（state）。對(duì)象的狀態(tài)由它的特性（比如名稱）來描述。對(duì)象的方法可以改變它的特性。所以就像是將一大堆函數(shù)（方法）捆在一起，并且給予他們?cè)L問變量（特性）的權(quán)力。它們可以在函數(shù)調(diào)用之間保持保存的值。

略

類是一種對(duì)象，所有的對(duì)象都屬于某一個(gè)類，稱為類的實(shí)例（instance）。

當(dāng)一個(gè)對(duì)象所屬的類是另外一個(gè)對(duì)象所屬類的子集時(shí)，前者就被稱為后者的 子類（subclass），所以“百靈鳥類”是“鳥類”的子類。相反，“鳥類”是“百靈鳥類”的“超類”（superclass）。但是，在面向程序設(shè)計(jì)中，子類的關(guān)系是隱式的，因?yàn)橐粋€(gè)類的定義取決于它所支持的方法。類的所有實(shí)例都會(huì)包含這些方法，所以所有子類的所有實(shí)例都有這些方法。定義子類只是個(gè)定義更多（也有可能是重載已經(jīng)存在的）方法的過程。

事實(shí)上，self參數(shù)正是方法和參數(shù)的區(qū)別。方法（更專業(yè)一點(diǎn)可以稱為綁定方法）將它們的第一個(gè)參數(shù)綁定到所屬的實(shí)例上，因此無需顯式提供該參數(shù)。當(dāng)然也可以將特性綁定到一個(gè)普通函數(shù)上，這樣就不會(huì)有特殊的self參數(shù)了：

>>> class Class:
    def method(self):
        print "I hava a self"

>>> def function():
    print "I don"t..."
 
>>> instance = Class()
>>> instance.method()
I hava a self!
>>> instance.method =function
>>> instance.method()
I don"t...   

注意，self參數(shù)并不依賴于調(diào)用方法的方式，前面使用的是instance.method(實(shí)例.方法)的形式，可以隨意使用其他變量引用同一個(gè)方法：

>>> class Bird:
    song = "Squaawk!"
    def sing(self):
        print self.song

>>> bird = Bird()
>>> bird.sing()
Squaawk!

>>> birdsong = bird.sing
>>> birdsong()
Squaawk!

盡管最后一個(gè)方法調(diào)用看起來與函數(shù)調(diào)用十分相似，但是變量birdsongs引用綁定方法bird.sing上，也就意味著這還是會(huì)對(duì)self參數(shù)進(jìn)行訪問（也就是說，它仍舊綁定到類的相同實(shí)例上）。

默認(rèn)情況下，程序可以從外部訪問一個(gè)對(duì)象的特性：

>>> c.name
"Sir Lancelot"
>>> c.name = "Sir Gumby"
>>> c.getName()
"Sir Gumby"

為了避免這類事情的發(fā)生，應(yīng)該使用私有（private）特性，這是外部對(duì)象無法訪問到，但getName和setName等訪問器（accessor）能夠訪問的特性。

Python并不直接支持私有防暑，為了讓方法或者特性變?yōu)樗接校◤耐獠繜o法訪問），只要在它的名字前面加上雙下劃線即可。

class Secretive:
    def __inacessible(self):
        print "Bet you can"t see me.."
       
    def accessible(self):
        print "The secret message is:"
        self.__inaccessible

現(xiàn)在，__inaccessible從外界是無法訪問的，而在類內(nèi)部還能使用（比如從accessible）訪問：

>>> s = Secretive()
>>> s.__inaccessible()
Traceback (most recent call last):
    File "",;ine 1, in ?
    s.__inaccessible()
AttributeError: Secretive instance has no attribute "__inaccessible"
>>> s.accessible()
The secret message is:
Bet you can"t see me...

盡管雙下劃線有些奇怪，但是看起來像是其他魚魚中的標(biāo)準(zhǔn)的私有方法。而在類的內(nèi)部定義中，所有以雙下劃線開始的名字都被“翻譯”成前面加上單下劃線類名的形式。

>>> Secretive._Secret__inaccsible

但實(shí)際上還是能夠在類外訪問這些私有方法，盡管不應(yīng)該這么做：

>>> s._Secretive.__inaccessible
Bet you can"t see me..

簡(jiǎn)而言之，確保他人不會(huì)訪問對(duì)象的方法和特性是不可能的，但是這類“名稱變化”是提醒他們不應(yīng)該訪問這些函數(shù)或者特性的強(qiáng)有力信號(hào)。

如果不需要使用這種方法但是又想讓其他對(duì)象不要訪問內(nèi)部數(shù)據(jù)，那么可以使用單下劃線，這不過是個(gè)習(xí)慣，但的確有實(shí)際效果。例如，前面有下劃線的名字都不會(huì)被帶星號(hào)的import語句（from module import *）導(dǎo)入。

下面的兩個(gè)語句幾乎等價(jià)：

def foo(x):return x*x
foo = lambda X:x*x

兩者都創(chuàng)建了返回參數(shù)平方的函數(shù)，而且都將變量foo綁定到函數(shù)上。變量foo可以在全局（模塊）范圍內(nèi)進(jìn)行定義，也可處在局部的函數(shù)或方法內(nèi)。定義類時(shí)，太陽的事情也會(huì)發(fā)生，所有位于class語句中的代碼塊都在特殊的命名空間中執(zhí)行——類命名空間（class namespace）。這個(gè)命名空間可由類內(nèi)所有成員訪問。但并不是所有Python程序員都知道類的定義其實(shí)就是執(zhí)行代碼塊。

子類可以拓展超類的定義。將其他類名寫在class語句后的圓括號(hào)內(nèi)可以指定超類。

如果想要查看一個(gè)類是否是另一個(gè)的子類，可以使用內(nèi)建的issubclass函數(shù)。

如果想要知道已知類的基類（們），可以直接使用它的特殊特性__base__:

同樣，還能使用isinstance方法檢查一個(gè)對(duì)象是否是一個(gè)類的實(shí)例：