Python中一切皆對象
關於Python，你肯定聽過這么一句話："Python中一切皆對象"。沒錯，在Python的世界里，一切都是對象。整型是一個對象、字符串是一個對象、字典是一個對象，甚至int、str、list等等，再加上我們使用class自定義的類，它們也是對象。
像int、str、list等基本類型，以及我們自定義的類，由於它們可以表示類型，因此我們稱之為類型對象；類型對象實例化得到的對象，我們稱之為實例對象。不管是哪種對象，它們都屬於對象。
因此Python中面向對象的理念貫徹的非常徹底，面向對象中的"類"和"對象"在Python中都是通過"對象"實現的。
在面向對象理論中，存在着"類"和"對象"兩個概念，像int、dict、tuple、以及使用class關鍵字自定義的類型對象實現了面向對象理論中"類"的概念，而123、(1, 2, 3)，"xxx"等等這些實例對象則實現了面向對象理論中"對象"的概念。但是在Python中，面向對象的"類"和"對象"都是通過對象實現的。
我們舉個栗子：
>>> # int它是一個類，因此它屬於類型對象, 類型對象實例化得到的對象屬於實例對象
>>> int
<class 'int'>
>>> int('0123')
123
>>>
因此可以用一張圖來描述面向對象在Python中的體現：
類型、對象體系
a是一個整數(實例對象)，其類型是int(類型對象)。
>>> a = 123
>>> a
123
>>> type(a)
<class 'int'>
>>> isinstance(a, int)
True
>>>
但是問題來了，按照面向對象的理論來說，對象是由類實例化得到的，這在Python中也是適用的。既然是對象，那么就必定有一個類來實例化它，換句話說對象一定要有類型。至於一個對象的類型是什么，就看這個對象是被誰實例化的，被誰實例化那么類型就是誰。而我們說Python中一切皆對象，所以像int、str、tuple這些內置的類型也是具有相應的類型的，那么它們的類型又是誰呢？
我們使用type函數查看一下就好了。
>>> type(int)
<class 'type'>
>>> type(str)
<class 'type'>
>>> type(dict)
<class 'type'>
>>> type(type)
<class 'type'>
>>>
我們看到類型對象的類型，無一例外都是type。type應該是初學Python的時候就接觸了，當時使用type都是為了查看一個對象的類型，然而type的作用遠沒有這么簡單，我們后面會說，總之我們目前看到類型對象的類型是type。
所以int、str等類型對象是type的對象，而type我們也稱其為元類，表示類型對象的類型。至於type本身，它的類型還是type，所以它連自己都沒放過，把自己都變成自己的對象了。
因此在Python中，你能看到的任何對象都是有類型的，我們可以使用type函數查看，也可以獲取該對象的__class__屬性查看。
所以：實例對象、類型對象、元類，Python中任何一個對象都逃不過這三種身份。
Python中還有一個特殊的類型(對象)，叫做object，它是所有類型對象的基類。不管是什么類，內置的類也好，我們自定義的類也罷，它們都繼承自object。因此，object是所有類型對象的"基類"、或者說"父類"。
>>> issubclass(int, object)
True
>>>
因此，綜合以上關系，我們可以得到下面這張關系圖：
我們自定義的類型也是如此，舉個栗子：
class Female:
pass
print(type(Female)) # <class 'type'>
print(issubclass(Female, object)) # True
在Python3中，自定義的類即使不顯式的繼承object，也會默認繼承自object。
那么我們自定義再自定義一個子類，繼承自Female呢？
class Female:
pass
class Girl(Female):
pass
# 自定義類的類型都是type
print(type(Girl)) # <class 'type'>
# 但Girl繼承自Female, 所以它是Female的子類
print(issubclass(Girl, Female)) # True
# 而Female繼承自object, 所以Girl也是object的子類
print(issubclass(Girl, object)) # True
# 這里需要額外多提一句實例對象, 我們之前使用type得到的都是該類的類型對象
# 換句話說誰實例化得到的它, 那么對它使用type得到的就是誰
print(type(Girl())) # <class '__main__.Girl'>
print(type(Female())) # <class '__main__.Female'>
# 但是我們說Girl的父類是Female, Female的父類是object
# 所以Girl的實例對象也是Female和object的實例對象, Female的實例對象也是object的實例對象
print(isinstance(Girl(), Female)) # True
print(isinstance(Girl(), object)) # True
因此上面那張關系圖就可以變成下面這樣：
我們說可以使用type和__class__查看一個對象的類型，並且還可以通過isinstance來判斷該對象是不是某個已知類型的實例對象；那如果想查看一個類型對象都繼承了哪些類該怎么做呢？我們目前都是使用issubclass來判斷某個類型對象是不是另一個已知類型對象的子類，那么可不可以直接獲取某個類型對象都繼承了哪些類呢？
答案是可以的，方法有三種，我們分別來看一下：
class A: pass
class B: pass
class C(A): pass
class D(B, C): pass
# 首先D繼承自B和C, C又繼承A, 我們現在要來查看D繼承的父類
# 方法一: 使用__base__
print(D.__base__) # <class '__main__.B'>
# 方法二: 使用__bases__
print(D.__bases__) # (<class '__main__.B'>, <class '__main__.C'>)
# 方法三: 使用__mro__
print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
__base__: 如果繼承了多個類, 那么只顯示繼承的第一個類, 沒有顯示繼承則返回一個<class 'object'>;__bases__: 返回一個元組, 會顯示所有直接繼承的父類, 如果沒有顯示的繼承, 則返回(<class 'object'>,);__mro__: mro表示Method Resolution Order, 表示方法查找順序, 會從自身除法, 找到最頂層的父類, 因此返回自身、繼承的基類、以及基類繼承的基類, 一直找到object;
最后我們來看一下type和object，估計這兩個老鐵之間的關系會讓很多人感到困惑。
我們說type是所有類的元類，而object是所有的基類，這就說明type是要繼承自object的，而object的類型是type。
>>> type.__base__
<class 'object'>
>>> object.__class__
<class 'type'>
>>>
這就怪了，這難道不是一個先有雞還是先有蛋的問題嗎？其實不是的，這兩個對象是共存的，它們之間的定義其實是互相依賴的。至於到底是怎么肥事，我們后面在看解釋器源碼的時候就會很清晰了。
總之目前記住兩點：
1. type站在類型金字塔的最頂端, 任何的對象按照類型追根溯源, 最終得到的都是type;2. object站在繼承金字塔的最頂端, 任何的類型對象按照繼承追根溯源, 最終得到的都是object;
我們說type的類型還是type，但是object的基類則不再是object，而是一個None。為什么呢？其實答案很簡單，我們說Python在查找屬性或方法的時候，會回溯繼承鏈，自身如果沒有的話，就會按照__mro__指定的順序去基類中查找。所以繼承鏈一定會有一個終點，否則就會像沒有出口的遞歸一樣出現死循環了。
最后將上面那張關系圖再完善一下的話：
因此上面這種圖才算是完整，其實只看這張圖我們就能解讀出很多信息。比如：實例對象的類型是類型對象，類型對象的類型是元類；所有的類型對象的基類都收斂於object，所有對象的類型都收斂於type。因此Python算是將一切皆對象的理念貫徹到了極致，也正因為如此，Python才具有如此優秀的動態特性。
事實上，目前介紹的有些基礎了，但Python中的對象的概念確實非常重要。為了后面再分析源碼的時候能夠更輕松，因此我們有必要系統地回顧一下，並且上面的關系圖會使我們在后面的學習變得輕松。因為等到看解釋器的時候，我們可就沒完了，就不那么輕松了(なん～～～てね)。
Python中的變量只是個名字
Python中的變量只是個名字，站在C語言的角度來說的話，Python中的變量存儲的只是對象的內存地址，或者說指針，這個指針指向的內存存儲的才是對象。
所以在Python中，我們都說變量指向了某個對象。在其它靜態語言中，變量相當於是為某塊內存起的別名，獲取變量等於獲取這塊內存所存儲的值。而Python中變量代表的內存存儲的不是對象，只是對象的指針。
我們用兩段代碼，一段C語言的代碼，一段Python的代碼，來看一下差別。
#include <stdio.h>
void main()
{
int a = 123;
printf("address of a = %p\n", &a);
a = 456
printf("address of a = %p\n", &a);
}
//輸出結果
/*
address of a = 0x7fffa94de03c
address of a = 0x7fffa94de03c
*/
我們看到前后輸出的地址是一樣的，再來看看Python的。
a = 666
print(hex(id(a))) # 0x1b1333394f0
a = 667
print(hex(id(a))) # 0x1b133339510
然而我們看到Python中變量a的地址前后發生了變化，我們分析一下原因。
首先在C中，創建一個變量的時候必須規定好類型，比如int a = 666，那么變量a就是int類型，以后在所處的作用域中就不可以變了。如果這時候，再設置a = 777，那么等於是把內存中存儲的666換成777，a的地址和類型是不會變化的。
而在Python中，a = 666等於是先開辟一塊內存，存儲的值為666，然后讓變量a指向這片內存，或者說讓變量a存儲這塊內存的指針。然后a = 777的時候，再開辟一塊內存，然后讓a指向存儲777的內存，由於是兩塊不同的內存，所以它們的地址是不一樣的。
所以Python中的變量只是一個和對象關聯的名字罷了，它代表的是對象的指針。換句話說Python中的變量就是個便利貼，可以貼在任何對象上，一旦貼上去了，就代表這個對象被引用了。
我們再來看看變量之間的傳遞，在Python中是如何體現的。
a = 666
print(hex(id(a))) # 0x1e6c51e3cf0
b = a
print(hex(id(b))) # 0x1e6c51e3cf0
我們看到打印的地址是一樣的，我們再用一張圖解釋一下。
我們說a = 666的時候，先開辟一份內存，再讓a存儲對應內存的指針；然后b = a的時候，會把a的地址拷貝一份給b，所以b存儲了和a相同的地址，它們都指向了同一個對象。
因此說Python是值傳遞、或者引用傳遞都是不准確的，准確的說Python是變量之間的賦值傳遞，對象之間的引用傳遞。
因為Python中的變量本質上就是一個指針，所以在b = a的時候，等於把a指向的對象的地址（a本身）拷貝一份給b，所以對於變量來說是賦值傳遞；然后a和b又都是指向對象的指針，因此對於對象來說是引用傳遞。
另外還有最關鍵的一點，我們說Python中的變量是一個指針，當傳遞一個變量的時候，傳遞的是指針；但是在操作一個變量的時候，會操作變量指向的內存。
所以id(a)獲取的不是a的地址，而是a指向的內存的地址(在底層其實就是a)，同理b = a，是將a本身，或者說將a存儲的、指向某個具體的對象的地址傳遞給了b。
另外在C的層面上，a和b屬於指針變量，那么a和b有沒有地址呢？顯然是有的，只不過在Python中你是看不到的，Python解釋器只允許你看到對象的地址。
最后提一下變量的類型
我們說變量的類型其實不是很准確，應該是變量指向(引用)的對象的類型，因為我們說Python中變量是個指針，操作指針會操作指針指向的內存，所以我們使用type(a)查看的是變量a指向的內存的類型，當然為了方便也會直接說變量的類型，理解就行。那么問題來了，我們在創建一個變量的時候，並沒有顯示的指定類型啊，但Python顯然是有類型的，那么Python是如何判斷一個變量指向的是什么類型的數據呢？
答案是：解釋器是通過靠猜的方式，通過你賦的值(或者說變量引用的值)來推斷類型。所以在Python中，如果你想創建一個變量，那么必須在創建變量的時候同時賦值，否則解釋器就不知道這個變量指向的數據是什么類型。所以Python是先創建相應的值，這個值在C中對應一個結構體，結構體里面有一個成員專門用來存儲該值對應的類型。當創建完值之后，再讓這個變量指向它，所以Python中是先有值后有變量。但顯然C中不是這樣的，因為C中變量代表的內存所存儲的就是具體的值，所以C中可以直接聲明一個變量的同時不賦值。因為C要求聲明變量的同時必須指定類型，所以聲明變量的同時，其類型和內存大小就已經固定了。而Python中變量代表的內存是個指針，它只是指向了某個對象，所以由於其便利貼的特性，可以貼在任意對象上面，但是不管貼在哪個對象，你都必須先有對象才可以，不然變量貼誰去？
另外，盡管Python在創建變量的時候不需要指定類型，但Python是強類型語言，強類型語言，強類型語言，重要的事情說三遍。而且是動態強類型，因為類型的強弱和是否需要顯示聲明類型之間沒有關系。
可變對象與不可變對象
我們說一個對象其實就是一片被分配的內存空間，內存中存儲了相應的值，不過這些空間可以是連續的，也可以是不連續的。
不可變對象一旦創建，其內存中存儲的值就不可以再修改了。如果想修改，只能創建一個新的對象，然后讓變量指向新的對象，所以前后的地址會發生改變。而可變對象在創建之后，其存儲的值可以動態修改。
像整型就是一個不可變對象。
>>> a = 666
>>> id(a)
1365442984464
>>> a += 1
>>> id(a)
1365444032848
>>>
我們看到在對a執行+1操作時，前后地址發生了變化，所以整型不支持本地修改，因此是一個不可變對象；
原來a = 666，而我們說操作一個變量等於操作這個變量指向的內存，所以a+=1，會將a指向的整型對象666和1進行加法運算，得到667。所以會開辟新的空間來存儲這個667，然后讓a指向這片新的空間，至於原來的666所占的空間怎么辦，Python解釋器會看它的引用計數，如果不為0代表還有變量引用(指向)它，如果為0證明沒有變量引用了，所以會被回收。
關於引用計數，我們后面會詳細說，目前只需要知道當一個對象被一個變量引用的時候，那么該對象的引用計數就會加1。有幾個變量引用，那么它的引用計數就是幾。
可能有人覺得，每次都要創建新對象，銷毀舊對象，效率肯定會很低吧。事實上確實如此，但是后面我們會從源碼的角度上來看Python如何通過小整數對象池等手段進行優化。
而列表是一個可變對象，它是可以修改的。
這里先多提一句，Python中的對象本質上就是C中malloc函數為結構體實例在堆區申請的一塊內存。Python中的任何對象在C中都會對應一個結構體，這個結構體除了存放具體的值之外，還存放了一些額外的信息，這個我們在剖析Python中的內置類型的實例對象的時候會細說。
首先Python中列表，當然不光是列表，還有元組、集合，這些容器它們的內部存儲的也不是具體的對象，而是對象的指針。比如：lst = [1, 2, 3]，你以為lst存儲的是三個整型對象嗎？其實不是的，lst存儲的是三個整型對象的指針，當我們使用lst[0]的時候，拿到的是第一個元素的指針，但是操作(比如print)的時候會自動操作(print)指針指向的內存。
不知道你是否思考過，Python底層是C來實現的，所以Python中的列表的實現必然要借助C中的數組。可我們知道C中的數組里面的所有元素的類型必須一致，但列表卻可以存放任意的元素，因此從這個角度來講，列表里面的元素它就就不可能是對象，因為不同的對象在底層對應的結構體是不同的，所以這個元素只能是指針。
可能有人又好奇了，不同對象的指針也是不同的啊，是的，但C中的指針是可以轉化的。Python底層將所有對象的指針，都轉成了PyObject的指針，這樣不就是同一種類型的指針了嗎？關於這個PyObject，它是我們后面要剖析的重中之重，這個PyObject貫穿了我們的整個系列。目前只需要知道Python中的列表存儲的值，在底層是通過一個PyObject *類型的數據來維護的。
>>> lst = [1, 2, 3]
>>> id(lst)
1365442893952
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]
>>> id(lst)
1365442893952
>>>
我們看到列表在添加元素的時候，前后地址並沒有改變。列表在C中是通過PyListObject實現的，我們在介紹列表的時候會細說。這個PyListObject內部除了一些基本信息之外，還有一個成員叫ob_item，它是一個PyObject的二級指針，指向了我們剛才說的PyObject *類型的數組的首個元素的地址。
結構圖如下：
顯然圖中的指針數組是用來存儲具體的對象的指針的，每一個指針都指向了相應的對象(這里是整型對象)。可能有人注意到，整型對象的順序有點怪，其實我是故意這么畫的。因為PyObject *數組內部的元素是連續且有順序的，但是指向的整型對象則是存儲在堆區的，它們的位置是任意性的。但是不管這些整型對象存儲在堆區的什么位置，它們和數組中的指針都是一一對應的，我們通過索引是可以正確獲取到指向的對象的。
另外我們還可以看到一個現象，那就是Python中的列表在底層是分開存儲的，因為PyListObject結構體實例並沒有存儲相應的指針數組，而是存儲了指向這個指針數組的二級指針。顯然我們添加、刪除、修改元素等操作，都是通過這個二級指針來間接操作這個指針數組。
為什么要這么做？
因為在Python中一個對象一旦被創建，那么它在內存中的大小就不可以變了。所以這就意味着那些可以容納可變長度數據的可變對象，要在內部維護一個指向可變大小的內存區域的指針。而我們看到PyListObject正是這么做的，指針數組的長度、內存大小是可變的，所以PyListObject內部並沒有直接存儲它，而是存儲了指向它的二級指針。但是Python在計算內存大小的時候是會將這個指針數組也算進去的，所以Python中列表的大小是可變的，但是底層對應的PyListObject實例的大小是不變的，因為可變長度的指針數組沒有存在PyListObject里面。但為什么要這么設計呢？
這么做的原因就在於，遵循這樣的規則可以使通過指針維護對象的工作變得非常簡單。一旦允許對象的大小可在運行期改變，那么我們就可以考慮如下場景。在內存中有對象A，並且其后面緊跟着對象B。如果運行的某個時候，A的大小增大了，這就意味着必須將A整個移動到內存中的其他位置，否則A增大的部分會覆蓋掉原本屬於B的數據。只要將A移動到內存的其他位置，那么所有指向A的指針就必須立即得到更新。可想而知這樣的工作是多么的繁瑣，而通過一個指針去操作就變得簡單多了。
定長對象與變長對象
Python中一個對象占用的內存有多大呢？相同類型的實例對象的大小是否相同呢？試一下就知道了，我們可以通過sys模塊中getsizeof函數查看一個對象所占的內存。
import sys
print(sys.getsizeof(0)) # 24
print(sys.getsizeof(1)) # 28
print(sys.getsizeof(2 << 33)) # 32
print(sys.getsizeof(0.)) # 24
print(sys.getsizeof(3.14)) # 24
print(sys.getsizeof((2 << 33) + 3.14)) # 24
我們看到整型對象的大小不同，所占的內存也不同，像這種內存大小不固定的對象，我們稱之為變長對象；而浮點數所占的內存都是一樣的，像這種內存大小固定的對象，我們稱之為定長對象。
至於Python是如何計算對象所占的內存，我們在剖析具體對象的時候會說，因為這要涉及到底層對應的結構體。
而且我們知道Python中的整數是不會溢出的，而C中的整型顯然是有最大范圍的，那么Python是如何做到的呢？答案是Python在底層是通過C的32位整型數組來存儲自身的整型對象的，通過多個32位整型組合起來，以支持存儲更大的數值，所以整型越大，就需要越多的32位整數。而32位整數是4字節，所以我們上面代碼中的那些整型，都是4字節、4字節的增長。
當然Python中的對象在底層都是一個結構體，這個結構體中除了維護具體的值之外，還有其它的成員信息，在計算內存大小的時候，它們也是要考慮在內的，當然這些我們后面會說。
而浮點數的大小是不變的，因為Python的浮點數的值在C中是通過一個double來維護的。而C中的值的類型一旦確定，大小就不變了，所以Python的float也是不變的。
但是既然是固定的類型，肯定范圍是有限的，所以當浮點數不斷增大，會犧牲精度來進行存儲。如果實在過大，那么會拋出OverFlowError。
>>> int(1000000000000000000000000000000000.) # 犧牲了精度
999999999999999945575230987042816
>>> 10 ** 1000 # 不會溢出
1000000000000000......
>>>
>>> 10. ** 1000 # 報錯了
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
OverflowError: (34, 'Result too large')
>>>
還有字符串，字符串毫無疑問肯定是變長對象，因為長度不同大小不同。
import sys
print(sys.getsizeof("a")) # 50
print(sys.getsizeof("abc")) # 52
我們看到多了兩個字符，多了兩個字節，這很好理解。但是這些說明了一個空字符串要占49個字節，我們來看一下。
import sys
print(sys.getsizeof("")) # 49
顯然是的，顯然這49個字節是用來維護其它成員信息的，因為底層的結構體除了維護具體的值之外，還要維護其它的信息，比如：引用計數等等，這些在分析源碼的時候會詳細說。
小結
我們這一節介紹了Python中的對象體系，我們說Python中一切皆對象，類型對象和實例對象都屬於對象；還說了對象的種類，根據是否支持本地修改可以分為可變對象和不可變對象，根據占用的內存是否不變可以分為定長對象和變長對象；還說了Python中變量的本質，Python中的變量本質上是一個指針，而變量的名字則存儲在對應的名字空間(或者說命名空間)中，當然名字空間我們沒有說，是因為這些在后續系列會詳細說(又是后續, 不管咋樣, 坑先挖出來)，不過這里可以先補充一下。
名字空間分為：全局名字空間(存儲全局變量)、局部名字空間(存儲局部變量)、閉包名字空間(存儲閉包變量)、內建名字空間(存儲內置變量, 比如int、str, 它們都在這里)，而名字空間又分為靜態名字空間和動態名字空間：比如局部名字空間，因為函數中的局部變量在編譯的時候就可以確定，所以函數對應的局部名字空間使用一個數組存儲；而全局變量在運行時可以進行動態添加、刪除，因此全局名字空間使用的是一個字典來保存，字典的key就是變量的名字(依舊是個指針，底層是指向字符串(PyUnicodeObject)的指針)，字典的value就是變量指向的對象的指針(或者說變量本身)。
a = 123
b = "xxx"
# 通過globals()即可獲取全局名字空間
print(globals()) #{..., 'a': 123, 'b': 'xxx'}
# 我們看到雖然顯示的是變量名和變量指向的值
# 但是在底層，字典存儲的鍵值對也是指向具體對象的指針
# 只不過我們說操作指針會操作指向的內存，所以這里print打印之后，顯示的也是具體的值，但是存儲的是指針
# 至於對象本身，則存儲在堆區，並且被指針指向
# 此外，我們往全局名字空間中設置一個鍵值對，也等價於創建了一個全局變量
globals()["c"] = "hello"
print(c) # hello
# 此外這個全局名字空間是唯一的，即使你把它放在函數中也是一樣
def foo():
globals()["d"] = "古明地覺"
# foo一旦執行，{"d": "古明地覺"}就設置進了全局名字空間中
foo()
print(d) # 古明地覺
怎么樣，是不是有點神奇呢？所以名字空間是Python作用域的靈魂，它嚴格限制了變量的活動范圍，當然這些后面都會慢慢的說，因為飯要一口一口吃。因此這一節算是回顧基礎吧，雖說是基礎但是其實也涉及到了一些解釋器的知識，不過這一關我們遲早是要過的，所以就提前接觸一下吧。