眾所周知，Python 是一門面向?qū)ο笳Z言，在 Python 的世界一切皆對象。所以一切變量的本質(zhì)都是對象的一個指針而已。
創(chuàng)新互聯(lián)公司專業(yè)為企業(yè)提供寶山網(wǎng)站建設、寶山做網(wǎng)站、寶山網(wǎng)站設計、寶山網(wǎng)站制作等企業(yè)網(wǎng)站建設、網(wǎng)頁設計與制作、寶山企業(yè)網(wǎng)站模板建站服務，十多年寶山做網(wǎng)站經(jīng)驗，不只是建網(wǎng)站，更提供有價值的思路和整體網(wǎng)絡服務。
Python 運行過程中會不停的創(chuàng)建各種變量，而這些變量是需要存儲在內(nèi)存中的，隨著程序的不斷運行，變量數(shù)量越來越多，所占用的空間勢必越來越大，如果對變量所占用的內(nèi)存空間管理不當?shù)脑?，那么肯定會出現(xiàn) out of memory。程序大概率會被異常終止。
因此，對于內(nèi)存空間的有效合理管理變得尤為重要，那么 Python 是怎么解決這個問題的呢。其實很簡單，對不不可能再使用到的內(nèi)存進行回收即可，像 C 語言中需要程序員手動釋放內(nèi)存就是這個道理。但問題是如何確定哪些內(nèi)存不再會被使用到呢？這就是我們今天要說的垃圾回收了。
目前垃圾回收比較通用的解決辦法有三種，引用計數(shù)，標記清除以及分代回收。
引用計數(shù)也是一種最直觀，最簡單的垃圾收集技術(shù)。在 Python 中，大多數(shù)對象的生命周期都是通過對象的引用計數(shù)來管理的。其原理非常簡單，我們?yōu)槊總€對象維護一個 ref 的字段用來記錄對象被引用的次數(shù)，每當對象被創(chuàng)建或者被引用時將該對象的引用次數(shù)加一，當對象的引用被銷毀時該對象的引用次數(shù)減一，當對象的引用次數(shù)減到零時說明程序中已經(jīng)沒有任何對象持有該對象的引用，換言之就是在以后的程序運行中不會再次使用到該對象了，那么其所占用的空間也就可以被釋放了了。
我們來看看下面的例子。
函數(shù) print_memory_info 用來獲取程序占用的內(nèi)存空間大小，在 foo 函數(shù)中創(chuàng)建一個包含一百萬個整數(shù)的列表。從打印結(jié)果我們可以看出，創(chuàng)建完列表之后程序耗用的內(nèi)存空間上升到了 55 MB。而當函數(shù) foo 調(diào)用完畢之后內(nèi)存消耗又恢復正常。
這是因為我們在函數(shù) foo 中創(chuàng)建的 list 變量是局部變量，其作用域是當前函數(shù)內(nèi)部，一旦函數(shù)執(zhí)行完畢，局部變量的引用會被自動銷毀，即其引用次數(shù)會變?yōu)榱?，所占用的?nèi)存空間也會被回收。
為了驗證我們的想法，我們對函數(shù) foo 稍加改造。代碼如下：
稍加改造之后，即使 foo 函數(shù)調(diào)用結(jié)束其所消耗的內(nèi)存也未被釋放。
主要是因為我們將函數(shù) foo 內(nèi)部產(chǎn)生的列表返回并在主程序中接收之后，這樣就會導致該列表的引用依然存在，該對象后續(xù)仍有可能被使用到，垃圾回收便不會回收該對象。
那么，什么時候?qū)ο蟮囊么螖?shù)才會增加呢。下面四種情況都會導致對象引用次數(shù)加一。
同理，對象引用次數(shù)減一的情況也有四種。
引用計數(shù)看起來非常簡單，實現(xiàn)起來也不復雜，只需要維護一個字段保存對象被引用的次數(shù)即可，那么是不是就代表這種算法沒有缺點了呢。實則不然，我們知道引用次數(shù)為零的對象所占用的內(nèi)存空間肯定是需要被回收的。那引用次數(shù)不為零的對象呢，是不是就一定不能回收呢？
我們來看看下面的例子，只是對函數(shù) foo 進行了改造，其余未做更改。
我們看到，在函數(shù) foo 內(nèi)部生成了兩個列表 list_a 和 list_b，然后將兩個列表分別添加到另外一個中。由結(jié)果可以看出，即使 foo 函數(shù)結(jié)束之后其所占用的內(nèi)存空間依然未被釋放。這是因為對于 list_a 和 list_b 來說雖然沒有被任何外部對象引用，但因為二者之間交叉引用，以至于每個對象的引用計數(shù)都不為零，這也就造成了其所占用的空間永遠不會被回收的尷尬局面。這個缺點是致命的。
為了解決交叉引用的問題，Python 引入了標記清除算法和分代回收算法。
顯然，可以包含其他對象引用的容器對象都有可能產(chǎn)生交叉引用問題，而標記清除算法就是為了解決交叉引用的問題的。
標記清除算法是一種基于對象可達性分析的回收算法，該算法分為兩個步驟，分別是標記和清除。標記階段，將所有活動對象進行標記，清除階段將所有未進行標記的對象進行回收即可。那么現(xiàn)在的為問題變?yōu)榱?GC 是如何判定哪些是活動對象的？
事實上 GC 會從根結(jié)點出發(fā)，與根結(jié)點直接相連或者間接相連的對象我們將其標記為活動對象（該對象可達），之后進行回收階段，將未標記的對象（不可達對象）進行清除。前面所說的根結(jié)點可以是全局變量，也可以是調(diào)用棧。
標記清除算法主要用來處理一些容器對象，雖說該方法完全可以做到不誤殺不遺漏，但 GC 時必須掃描整個堆內(nèi)存，即使只有少量的非可達對象需要回收也需要掃描全部對象。這是一種巨大的性能浪費。
由于標記清除算法需要掃描整個堆的所有對象導致其性能有所損耗，而且當可以回收的對象越少時性能損耗越高。因此 Python 引入了分代回收算法，將系統(tǒng)中存活時間不同的對象劃分到不同的內(nèi)存區(qū)域，共三代，分別是 0 代，1 代 和 2 代。新生成的對象是 0 代，經(jīng)過一次垃圾回收之后，還存活的對象將會升級到 1 代，以此類推，2 代中的對象是存活最久的對象。
那么什么時候觸發(fā)進行垃圾回收算法呢。事實上隨著程序的運行會不斷的創(chuàng)建新的對象，同時也會因為引用計數(shù)為零而銷毀大部分對象，Python 會保持對這些對象的跟蹤，由于交叉引用的存在，以及程序中使用了長時間存活的對象，這就造成了新生成的對象的數(shù)量會大于被回收的對象數(shù)量，一旦二者之間的差值達到某個閾值就會啟動垃圾回收機制，使用標記清除算法將死亡對象進行清除，同時將存活對象移動到 1 代。 以此類推，當二者的差值再次達到閾值時又觸發(fā)垃圾回收機制，將存活對象移動到 2 代。
這樣通過對不同代的閾值做不同的設置，就可以做到在不同代使用不同的時間間隔進行垃圾回收，以追求性能最大。
事實上，所有的程序都有一個相識的現(xiàn)象，那就是大部分的對象生存周期都是相當短的，只有少量對象生命周期比較長，甚至會常駐內(nèi)存，從程序開始運行持續(xù)到程序結(jié)束。而通過分代回收算法，做到了針對不同的區(qū)域采取不同的回收頻率，節(jié)約了大量的計算從而提高 Python 的性能。
除了上面所說的差值達到一定閾值會觸發(fā)垃圾回收之外，我們還可以顯示的調(diào)用 gc.collect() 來觸發(fā)垃圾回收，最后當程序退出時也會進行垃圾回收。
本文介紹了 Python 的垃圾回收機制，垃圾回收是 Python 自帶的功能，并不需要程序員去手動管理內(nèi)存。
其中引用計數(shù)法是最簡單直接的，但是需要維護一個字段且針對交叉引用無能為力。
標記清除算法主要是為了解決引用計數(shù)的交叉引用問題，該算法的缺點就是需要掃描整個堆的所有對象，有點浪費性能。
而分代回收算法的引入則完美解決了標記清除算法需要掃描整個堆對象的性能浪費問題。該算法也是建立在標記清除基礎之上的。
最后我們可以通過 gc.collect() 手動觸發(fā) GC 的操作。
題外話，如果你看過 JVM 的垃圾回收算法之后會發(fā)現(xiàn) Python 的垃圾回收算法與其是如出一轍的，事實再次證明，程序語言設計時是會相互參考的。
一般來說是一個函數(shù)名或者是一個變量，沒有什么特別的意思，大家都這么寫。就像說某人時會叫他張三李四是一樣的...
裝飾器是程序開發(fā)中經(jīng)常會用到的一個功能，用好了裝飾器，開發(fā)效率如虎添翼，所以這也是Python面試中必問的問題，但對于好多小白來講，這個功能 有點繞，自學時直接繞過去了，然后面試問到了就掛了，因為裝飾器是程序開發(fā)的基礎知識，這個都 不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。
1、先明白這段代碼
####?第一波?####
def?foo():
print?'foo'
foo?????#表示是函數(shù)
foo()???#表示執(zhí)行foo函數(shù)
####?第二波?####
def?foo():
print?'foo'
foo?=?lambda?x:?x?+?1
foo()???#?執(zhí)行下面的lambda表達式，而不再是原來的foo函數(shù)，因為函數(shù)?foo?被重新定義了
2、需求來了
初創(chuàng)公司有N個業(yè)務部門，1個基礎平臺部門，基礎平臺負責提供底層的功能，如：數(shù)據(jù)庫操作、redis調(diào)用、監(jiān)控API等功能。業(yè)務部門使用基礎功能時，只需調(diào)用基礎平臺提供的功能即可。如下：
###############?基礎平臺提供的功能如下?###############
def?f1():
print?'f1'
def?f2():
print?'f2'
def?f3():
print?'f3'
def?f4():
print?'f4'
###############?業(yè)務部門A?調(diào)用基礎平臺提供的功能?###############
f1()
f2()
f3()
f4()
###############?業(yè)務部門B?調(diào)用基礎平臺提供的功能?###############
f1()
f2()
f3()
f4()
目前公司有條不紊的進行著，但是，以前基礎平臺的開發(fā)人員在寫代碼時候沒有關(guān)注驗證相關(guān)的問題，即：基礎平臺的提供的功能可以被任何人使用。現(xiàn)在需要對基礎平臺的所有功能進行重構(gòu)，為平臺提供的所有功能添加驗證機制，即：執(zhí)行功能前，先進行驗證。
老大把工作交給 Low B，他是這么做的：
跟每個業(yè)務部門交涉，每個業(yè)務部門自己寫代碼，調(diào)用基礎平臺的功能之前先驗證。誒，這樣一來基礎平臺就不需要做任何修改了。
當天Low B 被開除了…
老大把工作交給 Low BB，他是這么做的：
###############?基礎平臺提供的功能如下?###############
def?f1():
#?驗證1
#?驗證2
#?驗證3
print?'f1'
def?f2():
#?驗證1
#?驗證2
#?驗證3
print?'f2'
def?f3():
#?驗證1
#?驗證2
#?驗證3
print?'f3'
def?f4():
#?驗證1
#?驗證2
#?驗證3
print?'f4'
###############?業(yè)務部門不變?###############
###?業(yè)務部門A?調(diào)用基礎平臺提供的功能###
f1()
f2()
f3()
f4()
###?業(yè)務部門B?調(diào)用基礎平臺提供的功能?###
f1()
f2()
f3()
f4()
過了一周 Low BB 被開除了…
老大把工作交給 Low BBB，他是這么做的：
只對基礎平臺的代碼進行重構(gòu)，其他業(yè)務部門無需做任何修改
###############?基礎平臺提供的功能如下?###############
def?check_login():
#?驗證1
#?驗證2
#?驗證3
pass
def?f1():
check_login()
print?'f1'
def?f2():
check_login()
print?'f2'
def?f3():
check_login()
print?'f3'
def?f4():
check_login()
print?'f4'
老大看了下Low BBB 的實現(xiàn)，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：
老大說：
寫代碼要遵循開發(fā)封閉原則，雖然在這個原則是用的面向?qū)ο箝_發(fā)，但是也適用于函數(shù)式編程，簡單來說，它規(guī)定已經(jīng)實現(xiàn)的功能代碼不允許被修改，但可以被擴展，即：
封閉：已實現(xiàn)的功能代碼塊
開放：對擴展開發(fā)
如果將開放封閉原則應用在上述需求中，那么就不允許在函數(shù) f1 、f2、f3、f4的內(nèi)部進行修改代碼，老板就給了Low BBB一個實現(xiàn)方案：
def?w1(func):
def?inner():
#?驗證1
#?驗證2
#?驗證3
return?func()
return?inner
@w1
def?f1():
print?'f1'
@w1
def?f2():
print?'f2'
@w1
def?f3():
print?'f3'
@w1
def?f4():
print?'f4'
對于上述代碼，也是僅僅對基礎平臺的代碼進行修改，就可以實現(xiàn)在其他人調(diào)用函數(shù) f1 f2 f3 f4 之前都進行【驗證】操作，并且其他業(yè)務部門無需做任何操作。
Low BBB心驚膽戰(zhàn)的問了下，這段代碼的內(nèi)部執(zhí)行原理是什么呢？
老大正要生氣，突然Low BBB的手機掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，交定了Low BBB這個朋友。詳細的開始講解了：
單獨以f1為例：
def?w1(func):
def?inner():
#?驗證1
#?驗證2
#?驗證3
return?func()
return?inner
@w1
def?f1():
print?'f1'
當寫完這段代碼后（函數(shù)未被執(zhí)行、未被執(zhí)行、未被執(zhí)行），python解釋器就會從上到下解釋代碼，步驟如下：
def w1(func): ?==將w1函數(shù)加載到內(nèi)存
@w1
沒錯，從表面上看解釋器僅僅會解釋這兩句代碼，因為函數(shù)在沒有被調(diào)用之前其內(nèi)部代碼不會被執(zhí)行。
從表面上看解釋器著實會執(zhí)行這兩句，但是 @w1 這一句代碼里卻有大文章，@函數(shù)名?是python的一種語法糖。
如上例@w1內(nèi)部會執(zhí)行一下操作：
執(zhí)行w1函數(shù)，并將 @w1 下面的?函數(shù)?作為w1函數(shù)的參數(shù)，即：@w1 等價于 w1(f1)
所以，內(nèi)部就會去執(zhí)行：
def inner:
#驗證
return f1() ? # func是參數(shù)，此時 func 等于 f1
return inner ? ? # 返回的 inner，inner代表的是函數(shù)，非執(zhí)行函數(shù)
其實就是將原來的 f1 函數(shù)塞進另外一個函數(shù)中
將執(zhí)行完的 w1 函數(shù)返回值賦值給@w1下面的函數(shù)的函數(shù)名
w1函數(shù)的返回值是：
def inner:
#驗證
return 原來f1() ?# 此處的 f1 表示原來的f1函數(shù)
然后，將此返回值再重新賦值給 f1，即：
新f1 =?def inner:
#驗證
return 原來f1()
所以，以后業(yè)務部門想要執(zhí)行 f1 函數(shù)時，就會執(zhí)行 新f1 函數(shù)，在 新f1 函數(shù)內(nèi)部先執(zhí)行驗證，再執(zhí)行原來的f1函數(shù)，然后將 原來f1 函數(shù)的返回值 返回給了業(yè)務調(diào)用者。
如此一來， 即執(zhí)行了驗證的功能，又執(zhí)行了原來f1函數(shù)的內(nèi)容，并將原f1函數(shù)返回值 返回給業(yè)務調(diào)用著
Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家?guī)湍憬鉀Q吧！?。?/p>
先把上述流程看懂，之后還會繼續(xù)更新…
3、問答時間
問題：被裝飾的函數(shù)如果有參數(shù)呢？
#一個參數(shù)
def?w1(func):
def?inner(arg):
#?驗證1
#?驗證2
#?驗證3
return?func(arg)
return?inner
@w1
def?f1(arg):
print?'f1'
#兩個參數(shù)
def?w1(func):
def?inner(arg1,arg2):
#?驗證1
#?驗證2
#?驗證3
return?func(arg1,arg2)
return?inner
@w1
def?f1(arg1,arg2):
print?'f1'
#三個參數(shù)
def?w1(func):
def?inner(arg1,arg2,arg3):
#?驗證1
#?驗證2
#?驗證3
return?func(arg1,arg2,arg3)
return?inner
@w1
def?f1(arg1,arg2,arg3):
print?'f1'
問題：可以裝飾具有處理n個參數(shù)的函數(shù)的裝飾器？
def?w1(func):
def?inner(*args,**kwargs):
#?驗證1
#?驗證2
#?驗證3
return?func(*args,**kwargs)
return?inner
@w1
def?f1(arg1,arg2,arg3):
print?'f1'
問題：一個函數(shù)可以被多個裝飾器裝飾嗎？
def?w1(func):
def?inner(*args,**kwargs):
#?驗證1
#?驗證2
#?驗證3
return?func(*args,**kwargs)
return?inner
def?w2(func):
def?inner(*args,**kwargs):
#?驗證1
#?驗證2
#?驗證3
return?func(*args,**kwargs)
return?inner
@w1
@w2
def?f1(arg1,arg2,arg3):
print?'f1'
問題：還有什么更吊的裝飾器嗎？
#!/usr/bin/env?python
#coding:utf-8
def?Before(request,kargs):
print?'before'
def?After(request,kargs):
print?'after'
def?Filter(before_func,after_func):
def?outer(main_func):
def?wrapper(request,kargs):
before_result?=?before_func(request,kargs)
if(before_result?!=?None):
return?before_result;
main_result?=?main_func(request,kargs)
if(main_result?!=?None):
return?main_result;
after_result?=?after_func(request,kargs)
if(after_result?!=?None):
return?after_result;
return?wrapper
return?outer
@Filter(Before,?After)
def?Index(request,kargs):
print?'index'
重慶分公司
重慶分公司
