python中的變量和java中的變量本質(zhì)是不一樣的，python中的變量實質(zhì)上是一個指針（指針的大小固定的）
十載的無棣網(wǎng)站建設(shè)經(jīng)驗，針對設(shè)計、前端、開發(fā)、售后、文案、推廣等六對一服務(wù)，響應(yīng)快，48小時及時工作處理。全網(wǎng)營銷推廣的優(yōu)勢是能夠根據(jù)用戶設(shè)備顯示端的尺寸不同，自動調(diào)整無棣建站的顯示方式，使網(wǎng)站能夠適用不同顯示終端，在瀏覽器中調(diào)整網(wǎng)站的寬度，無論在任何一種瀏覽器上瀏覽網(wǎng)站，都能展現(xiàn)優(yōu)雅布局與設(shè)計，從而大程度地提升瀏覽體驗。成都創(chuàng)新互聯(lián)公司從事“無棣網(wǎng)站設(shè)計”,“無棣網(wǎng)站推廣”以來，每個客戶項目都認(rèn)真落實執(zhí)行。
is可以用來判斷id是否相等
對于這種賦值，雖然所賦值是相同的，但是他們的id不同，即他們是不同的對象，a is b 即為false ,但是有個特例： a = 1 b = 1 時他們的id相同。其實這是python內(nèi)部的優(yōu)化機制，對于小整數(shù)和小的字符串來說，python在前邊定義一個對象時，下次在遇到時會直接調(diào)用前邊生成的對象，而不會去重新申請一個。
他們的對象內(nèi)存地址不一樣，但是，a和b里的值是相等的，這是由于a和b都為list,而list里有內(nèi)置的魔法函數(shù) eq 通過 eq 魔法函數(shù)可以判斷里邊兩個的值是否相同，若相同則返回True
python中垃圾回收的算法回收的算法是采用引用計數(shù)，當(dāng)程序中有一個變量引用該python對象時，python會自動保證該對象引用計數(shù)為1；當(dāng)程序中有兩個變量引用該python對象時，python會自動保證該對象計數(shù)器為2， 以此類推，當(dāng)一個對象的引用計數(shù)器變?yōu)? 時，則說明程序中不再有變量對其進(jìn)行引用，因此python就會回收該對象。
大多數(shù)情況，python的ARC都能準(zhǔn)確，高效的回收系統(tǒng)中的每一個對象。但如果系統(tǒng)中出現(xiàn)循環(huán)引用時，比如a對象持有一個實例變量引用對象b，而b對象又持有一個實例變量引用對象a，此時 兩個對象的計數(shù)器都為1， 而實際上python不再需要這兩個對象，也沒有程序在引用他們，系統(tǒng)回收他們時python的垃圾回收器就沒有那兒快，要等到專門的循環(huán)垃圾回收器（Cyclic Garbage Collector）來檢測并回收這種引用循環(huán)
當(dāng)一個對象被垃圾回收式，python就會自動調(diào)用該對象的 del 方法
當(dāng)沒有注釋掉x = im時， item對象被兩個變量所引用，所以在執(zhí)行完del im時并不會去回收item對象，所以先輸出--------，當(dāng)程序完全執(zhí)行完成后，引用item的對象的變量被釋放，然后系統(tǒng)便會執(zhí)行 del 方法，回收item對象。
當(dāng) x = im被注釋后，只有一個變量去引用item對象，所以在執(zhí)行完后程序變回去調(diào)用 del 方法，回收item對象，然后在繼續(xù)向下執(zhí)行 輸出-----
python采用的是 引用計數(shù) 機制為主， 標(biāo)記-清除 和 分代收集（隔代回收） 兩種機制為輔的策略。
python里每一個東西都是對象，它們的核心就是一個結(jié)構(gòu)體：PyObject
PyObject是每個對象必有的內(nèi)容，其中ob_refcnt就是做為引用計數(shù)。當(dāng)一個對象有新的引用時，它的ob_refcnt就會增加，當(dāng)引用它的對象被刪除，它的ob_refcnt就會減少
引用計數(shù)為0時，該對象生命就結(jié)束了。
引用計數(shù)機制的優(yōu)點：
1、簡單
2、實時性：一旦沒有引用，內(nèi)存就直接釋放了，不用像其他機制得等到特定時機。實時性還帶來一個好處：處理回收內(nèi)存的時間分?jǐn)偟搅似綍r。
引用計數(shù)機制的缺點：
1、維護(hù)引用計數(shù)消耗資源
2、循環(huán)引用
案例：
循環(huán)引用導(dǎo)致內(nèi)存泄露
有三種情況會觸發(fā)垃圾回收：
gc模塊提供一個接口給開發(fā)者設(shè)置垃圾回收的選項。上面說到，采用引用計數(shù)的方法管理內(nèi)存的一個缺陷是循環(huán)引用，而gc模塊的一個主要功能就是解決循環(huán)引用的問題。
常用函數(shù) ：
gc實踐案例
必須要import gc模塊，并且is_enable()=True才會啟動自動垃圾回收。
這個機制的主要作用就是發(fā)現(xiàn)并處理不可達(dá)的垃圾對象。
在Python中，采用分代收集的方法。把對象分為三代，一開始，對象在創(chuàng)建的時候，放在一代中，如果在一次一代的垃圾檢查中，該對象存活下來，就會被放到二代中，同理在一次二代的垃圾檢查中，該對象存活下來，就會被放到三代中。
gc模塊里面會有一個長度為3的列表的計數(shù)器，可以通過 gc.get_count() 獲取。
gc?？煊幸粋€自動垃圾回收的閥值，即通過 gc.get_threshold 函數(shù)獲取到的長度為3的元組，例如 (700,10,10)
每一次計數(shù)器的增加，gc模塊就會檢查增加后的計數(shù)是否達(dá)到閥值的數(shù)目，如果是，就會執(zhí)行對應(yīng)的代數(shù)的垃圾檢查，然后重置計數(shù)器
注意：
如果循環(huán)引用中，兩個對象都定義了 __del__ 方法，gc模塊不會銷毀這些不可達(dá)對象，因為gc模塊不知道應(yīng)該先調(diào)用哪個對象的 __del__ 方法，所以為了安全起見，gc模塊會把對象放到 gc.garbage 中，但是不會銷毀對象。
標(biāo)記清除（Mark—Sweep）』算法是一種基于追蹤回收（tracing GC）技術(shù)實現(xiàn)的垃圾回收算法。它分為兩個階段：第一階段是標(biāo)記階段，GC會把所有的『活動對象』打上標(biāo)記，第二階段是把那些沒有標(biāo)記的對象『非活動對象』進(jìn)行回收。那么GC又是如何判斷哪些是活動對象哪些是非活動對象的呢？
對象之間通過引用（指針）連在一起，構(gòu)成一個有向圖，對象構(gòu)成這個有向圖的節(jié)點，而引用關(guān)系構(gòu)成這個有向圖的邊。從根對象（root object）出發(fā)，沿著有向邊遍歷對象，可達(dá)的（reachable）對象標(biāo)記為活動對象，不可達(dá)的對象就是要被清除的非活動對象。根對象就是全局變量、調(diào)用棧、寄存器。 mark-sweepg 在上圖中，我們把小黑圈視為全局變量，也就是把它作為root object，從小黑圈出發(fā)，對象1可直達(dá)，那么它將被標(biāo)記，對象2、3可間接到達(dá)也會被標(biāo)記，而4和5不可達(dá)，那么1、2、3就是活動對象，4和5是非活動對象會被GC回收。
標(biāo)記清除算法作為Python的輔助垃圾收集技術(shù)主要處理的是一些容器對象，比如list、dict、tuple，instance等，因為對于字符串、數(shù)值對象是不可能造成循環(huán)引用問題。Python使用一個雙向鏈表將這些容器對象組織起來。不過，這種簡單粗暴的標(biāo)記清除算法也有明顯的缺點：清除非活動的對象前它必須順序掃描整個堆內(nèi)存，哪怕只剩下小部分活動對象也要掃描所有對象。
1.Python的垃圾回收機制原理
Python無需我們手動回收內(nèi)存，它的垃圾回收是如何實現(xiàn)的呢？
引用計數(shù)為主（缺點：循環(huán)引用無法解決）
引入標(biāo)記清除和分代回收解決引用計數(shù)問題
引用計數(shù)為主+標(biāo)記清除和分代回收為輔
垃圾回收（GC）
（1）引用計數(shù)
a = [1] # [1]對象引用計數(shù)增加1，ref=1
b = a # [1]對象引用計數(shù)增加1，ref=2
b = None # [1]對象引用計數(shù)減少1，ref=1
del a # [1]對象引用計數(shù)減少1，ref=0
a = [1],當(dāng)把列表 [1] 賦值給 a 的時候，它的引用計數(shù)就會增加1，此時列表 [1] 對象的引用計數(shù)ref=1 ； b = a 又把 a 賦值給 b ，a和b 同時引用了列表[1]對象，ref又增加1，此時 ref =2。繼續(xù)執(zhí)行 b = None， 讓b指向None，這個時候它就不會指向原來的列表[1]對象，列表[1]對象的引入計數(shù)就會減少1，又變成ref=1。執(zhí)行del a ，引用計數(shù)就會減少1，這個時候 ref = 0。當(dāng)對象的引用計數(shù)為0就可以回收掉，
注意：del 作用就會減少對象引用計數(shù)，并不是銷毀對象。只有當(dāng)引用計數(shù)為0的時候，Python解釋器才回去把對象占用的內(nèi)存回收掉。
// object.h
struct _object {
Py_ssize_t ob_refcnt; # 引用計數(shù)值
}PyObject;
① 什么時候引用計數(shù)增加呢？
② 什么時候引用計數(shù)會減少呢？
（2）引用計數(shù)無法解決循環(huán)引用問題
循環(huán)引用
a = [1] # 對象[1]引用計數(shù)增加1，ref=1
b = [2] # 對象[2]引用計數(shù)增加1，ref=1
a.append(b) # b被a引用，對象[2]引用計數(shù)增加1，ref=2
b.append(a) # a又被b引用，對象[1]引用計數(shù)增加1，ref=2
del a # 對象[1]引用計數(shù)減少1，ref=1
del b # 對象[2]引用計數(shù)減少1，ref=1
（3）標(biāo)記清除（Mark and Sweep）
（4）分代回收
import gc
眾所周知，Python 是一門面向?qū)ο笳Z言，在 Python 的世界一切皆對象。所以一切變量的本質(zhì)都是對象的一個指針而已。
Python 運行過程中會不停的創(chuàng)建各種變量，而這些變量是需要存儲在內(nèi)存中的，隨著程序的不斷運行，變量數(shù)量越來越多，所占用的空間勢必越來越大，如果對變量所占用的內(nèi)存空間管理不當(dāng)?shù)脑?，那么肯定會出現(xiàn) out of memory。程序大概率會被異常終止。
因此，對于內(nèi)存空間的有效合理管理變得尤為重要，那么 Python 是怎么解決這個問題的呢。其實很簡單，對不不可能再使用到的內(nèi)存進(jìn)行回收即可，像 C 語言中需要程序員手動釋放內(nèi)存就是這個道理。但問題是如何確定哪些內(nèi)存不再會被使用到呢？這就是我們今天要說的垃圾回收了。
目前垃圾回收比較通用的解決辦法有三種，引用計數(shù)，標(biāo)記清除以及分代回收。
引用計數(shù)也是一種最直觀，最簡單的垃圾收集技術(shù)。在 Python 中，大多數(shù)對象的生命周期都是通過對象的引用計數(shù)來管理的。其原理非常簡單，我們?yōu)槊總€對象維護(hù)一個 ref 的字段用來記錄對象被引用的次數(shù)，每當(dāng)對象被創(chuàng)建或者被引用時將該對象的引用次數(shù)加一，當(dāng)對象的引用被銷毀時該對象的引用次數(shù)減一，當(dāng)對象的引用次數(shù)減到零時說明程序中已經(jīng)沒有任何對象持有該對象的引用，換言之就是在以后的程序運行中不會再次使用到該對象了，那么其所占用的空間也就可以被釋放了了。
我們來看看下面的例子。
函數(shù) print_memory_info 用來獲取程序占用的內(nèi)存空間大小，在 foo 函數(shù)中創(chuàng)建一個包含一百萬個整數(shù)的列表。從打印結(jié)果我們可以看出，創(chuàng)建完列表之后程序耗用的內(nèi)存空間上升到了 55 MB。而當(dāng)函數(shù) foo 調(diào)用完畢之后內(nèi)存消耗又恢復(fù)正常。
這是因為我們在函數(shù) foo 中創(chuàng)建的 list 變量是局部變量，其作用域是當(dāng)前函數(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)生的列表返回并在主程序中接收之后，這樣就會導(dǎo)致該列表的引用依然存在，該對象后續(xù)仍有可能被使用到，垃圾回收便不會回收該對象。
那么，什么時候?qū)ο蟮囊么螖?shù)才會增加呢。下面四種情況都會導(dǎo)致對象引用次數(shù)加一。
同理，對象引用次數(shù)減一的情況也有四種。
引用計數(shù)看起來非常簡單，實現(xiàn)起來也不復(fù)雜，只需要維護(hù)一個字段保存對象被引用的次數(shù)即可，那么是不是就代表這種算法沒有缺點了呢。實則不然，我們知道引用次數(shù)為零的對象所占用的內(nèi)存空間肯定是需要被回收的。那引用次數(shù)不為零的對象呢，是不是就一定不能回收呢？
我們來看看下面的例子，只是對函數(shù) foo 進(jìn)行了改造，其余未做更改。
我們看到，在函數(shù) foo 內(nèi)部生成了兩個列表 list_a 和 list_b，然后將兩個列表分別添加到另外一個中。由結(jié)果可以看出，即使 foo 函數(shù)結(jié)束之后其所占用的內(nèi)存空間依然未被釋放。這是因為對于 list_a 和 list_b 來說雖然沒有被任何外部對象引用，但因為二者之間交叉引用，以至于每個對象的引用計數(shù)都不為零，這也就造成了其所占用的空間永遠(yuǎn)不會被回收的尷尬局面。這個缺點是致命的。
為了解決交叉引用的問題，Python 引入了標(biāo)記清除算法和分代回收算法。
顯然，可以包含其他對象引用的容器對象都有可能產(chǎn)生交叉引用問題，而標(biāo)記清除算法就是為了解決交叉引用的問題的。
標(biāo)記清除算法是一種基于對象可達(dá)性分析的回收算法，該算法分為兩個步驟，分別是標(biāo)記和清除。標(biāo)記階段，將所有活動對象進(jìn)行標(biāo)記，清除階段將所有未進(jìn)行標(biāo)記的對象進(jìn)行回收即可。那么現(xiàn)在的為問題變?yōu)榱?GC 是如何判定哪些是活動對象的？
事實上 GC 會從根結(jié)點出發(fā)，與根結(jié)點直接相連或者間接相連的對象我們將其標(biāo)記為活動對象（該對象可達(dá)），之后進(jìn)行回收階段，將未標(biāo)記的對象（不可達(dá)對象）進(jìn)行清除。前面所說的根結(jié)點可以是全局變量，也可以是調(diào)用棧。
標(biāo)記清除算法主要用來處理一些容器對象，雖說該方法完全可以做到不誤殺不遺漏，但 GC 時必須掃描整個堆內(nèi)存，即使只有少量的非可達(dá)對象需要回收也需要掃描全部對象。這是一種巨大的性能浪費。
由于標(biāo)記清除算法需要掃描整個堆的所有對象導(dǎo)致其性能有所損耗，而且當(dāng)可以回收的對象越少時性能損耗越高。因此 Python 引入了分代回收算法，將系統(tǒng)中存活時間不同的對象劃分到不同的內(nèi)存區(qū)域，共三代，分別是 0 代，1 代 和 2 代。新生成的對象是 0 代，經(jīng)過一次垃圾回收之后，還存活的對象將會升級到 1 代，以此類推，2 代中的對象是存活最久的對象。
那么什么時候觸發(fā)進(jìn)行垃圾回收算法呢。事實上隨著程序的運行會不斷的創(chuàng)建新的對象，同時也會因為引用計數(shù)為零而銷毀大部分對象，Python 會保持對這些對象的跟蹤，由于交叉引用的存在，以及程序中使用了長時間存活的對象，這就造成了新生成的對象的數(shù)量會大于被回收的對象數(shù)量，一旦二者之間的差值達(dá)到某個閾值就會啟動垃圾回收機制，使用標(biāo)記清除算法將死亡對象進(jìn)行清除，同時將存活對象移動到 1 代。 以此類推，當(dāng)二者的差值再次達(dá)到閾值時又觸發(fā)垃圾回收機制，將存活對象移動到 2 代。
這樣通過對不同代的閾值做不同的設(shè)置，就可以做到在不同代使用不同的時間間隔進(jìn)行垃圾回收，以追求性能最大。
事實上，所有的程序都有一個相識的現(xiàn)象，那就是大部分的對象生存周期都是相當(dāng)短的，只有少量對象生命周期比較長，甚至?xí)ｑv內(nèi)存，從程序開始運行持續(xù)到程序結(jié)束。而通過分代回收算法，做到了針對不同的區(qū)域采取不同的回收頻率，節(jié)約了大量的計算從而提高 Python 的性能。
除了上面所說的差值達(dá)到一定閾值會觸發(fā)垃圾回收之外，我們還可以顯示的調(diào)用 gc.collect() 來觸發(fā)垃圾回收，最后當(dāng)程序退出時也會進(jìn)行垃圾回收。
本文介紹了 Python 的垃圾回收機制，垃圾回收是 Python 自帶的功能，并不需要程序員去手動管理內(nèi)存。
其中引用計數(shù)法是最簡單直接的，但是需要維護(hù)一個字段且針對交叉引用無能為力。
標(biāo)記清除算法主要是為了解決引用計數(shù)的交叉引用問題，該算法的缺點就是需要掃描整個堆的所有對象，有點浪費性能。
而分代回收算法的引入則完美解決了標(biāo)記清除算法需要掃描整個堆對象的性能浪費問題。該算法也是建立在標(biāo)記清除基礎(chǔ)之上的。
最后我們可以通過 gc.collect() 手動觸發(fā) GC 的操作。
題外話，如果你看過 JVM 的垃圾回收算法之后會發(fā)現(xiàn) Python 的垃圾回收算法與其是如出一轍的，事實再次證明，程序語言設(shè)計時是會相互參考的。
重慶分公司
重慶分公司
