No.1 一切皆對象

眾所周知，Java中強調“一切皆對象”，但是Python中的面向對象比Java更加徹底，因為Python中的類（class）也是對象，函數（function）也是對象，而且Python的代碼和模塊也都是對象。

Python中函數和類可以賦值給一個變量

Python中函數和類可以存放到集合對象中

Python中函數和類可以作為一個函數的參數傳遞給函數

Python中函數和類可以作為返回值

Step.1

# 首先創建一個函數和一個Python3.x的新式類class Demo（object）： def __init__（self）： print（“Demo Class”）# 定義一個函數def function（）： print（“function”）# 在Python無論是函數，還是類，都是對象，他們可以賦值給一個變量class_value = Demofunc_value = function# 并且可以通過變量調用class_value（） # Demo Classfunc_value（） # function

Step.2

‘’‘遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學習教程和PDF電子書！’‘’# 將函數和類添加到集合中obj_list = ［］obj_list.append（Demo）obj_list.append（function）# 遍歷列表for i in obj_list： print（i） # 《class ‘__main__.Demo’》 # 《function function at 0x0000020D681B3E18》

Step.3

# 定義一個具體函數def test_func（class_name， func_name）： class_name（） func_name（）# 將類名和函數名傳入形參列表test_func（Demo， function）# Demo Class# function

Step.4

# 定義函數實現返回類和函數def test_func2（）： return Demodef test_func3（）： return function# 執行函數test_func2（）（） # Demo Classtest_func3（）（） # function

No.2 關鍵字type、object、class之間的關系

在Python中，object的實例是type，object是頂層類，沒有基類；type的實例是type，type的基類是object。Python中的內置類型的基類是object，但是他們都是由type實例化而來，具體的值由內置類型實例化而來。在Python2.x的語法中用戶自定義的類沒有明確指定基類就默認是沒有基類，在Python3.x的語法中，指定基類為object。

‘’‘遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學習教程和PDF電子書！’‘’# object是誰實例化的？print（type（object）） # 《class ‘type’》# object繼承自哪個類？print（object.__bases__） # （）# type是誰實例化的？print（type（type）） # 《class ‘type’》# type繼承自哪個類？print（type.__bases__） # （《class ‘object’》，）# 定義一個變量value = 100# 100由誰實例化？print（type（value）） # 《class ‘int’》# int由誰實例化？print（type（int）） # 《class ‘type’》# int繼承自哪個類？print（int.__bases__） # （《class ‘object’》，）# Python 2.x的舊式類class OldClass（）： pass# Python 3.x的新式類class NewClass（object）： pass

No.3 Python的內置類型

在Python中，對象有3個特征屬性：

在內存中的地址，使用id（）函數進行查看

對象的類型

對象的默認值

Step.1 None類型

在Python解釋器啟動時，會創建一個None類型的None對象，并且None對象全局只有一個。

Step.2 數值類型

ini類型

float類型

complex類型

bool類型

Step.3 迭代類型

在Python中，迭代類型可以使用循環來進行遍歷。

Step.4 序列類型

list

tuple

str

array

range

bytes， bytearray， memoryvie（二進制序列）

Step.5 映射類型

dict

Step.6 集合類型

set

frozenset

Step.7 上下文管理類型

with語句

Step.8 其他類型

模塊

class

實例

函數

方法

代碼

object對象

type對象

ellipsis（省略號）

notimplemented

NO.4 魔法函數

Python中的魔法函數使用雙下劃線開始，以雙下劃線結尾。關于詳細介紹請看我的文章——《全面總結Python中的魔法函數》。

No.5 鴨子類型與白鵝類型

鴨子類型是程序設計中的推斷風格，在鴨子類型中關注對象如何使用而不是類型本身。鴨子類型像多態一樣工作但是沒有繼承。鴨子類型的概念來自于：“當看到一只鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那么這只鳥就可以被稱為鴨子。”

‘’‘遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學習教程和PDF電子書！’‘’# 定義狗類class Dog（object）： def eat（self）： print（“dog is eatting.。.”）# 定義貓類class Cat（object）： def eat（self）： print（“cat is eatting.。.”）# 定義鴨子類class Duck（object）： def eat（self）： print（“duck is eatting.。.”）# 以上Python中多態的體現# 定義動物列表an_li = ［］# 將動物添加到列表an_li.append（Dog）an_li.append（Cat）an_li.append（Duck）# 依次調用每個動物的eat（）方法for i in an_li： i（）.eat（）# dog is eatting.。.# cat is eatting.。.# duck is eatting.。.

白鵝類型是指只要 cls 是抽象基類，即 cls 的元類是 abc.ABCMeta ，就可以使用 isinstance（obj， cls）。

No.6 協議、 抽象基類、abc模塊和序列之間的繼承關系

協議：Python中的非正式接口，是允許Python實現多態的方式，協議是非正式的，不具備強制性，由約定和文檔定義。

接口：泛指實體把自己提供給外界的一種抽象化物（可以為另一實體），用以由內部操作分離出外部溝通方法，使其能被內部修改而不影響外界其他實體與其交互的方式。

我們可以使用猴子補丁來實現協議，那么什么是猴子補丁呢？

猴子補丁就是在運行時修改模塊或類，不去修改源代碼，從而實現目標協議接口操作，這就是所謂的打猴子補丁。

Tips：猴子補丁的叫法起源于Zope框架，開發人員在修改Zope的Bug時，經常在程序后面追加更新的部分，這些雜牌軍補丁的英文名字叫做guerilla patch，后來寫成gorllia，接著就變成了monkey。

猴子補丁的主要作用是：

在運行時替換方法、屬性

在不修改源代碼的情況下對程序本身添加之前沒有的功能

在運行時對象中添加補丁，而不是在磁盤中的源代碼上

應用案例：假設寫了一個很大的項目，處處使用了json模塊來解析json文件，但是后來發現ujson比json性能更高，修改源代碼是要修改很多處的，所以只需要在程序入口加入：

import json# pip install ujsonimport ujson def monkey_patch_json（）： json.__name__ = ‘ujson’ json.dumps = ujson.dumps json.loads = ujson.loads monkey_patch_json（）

Python 的抽象基類有一個重要實用優勢：可以使用 register 類方法在終端用戶的代碼中把某個類 “聲明” 為一個抽象基類的 “虛擬” 子 類（為此，被注冊的類必腨滿足抽象其類對方法名稱和簽名的要求，最重要的是要滿足底 層語義契約；但是，開發那個類時不用了解抽象基類，更不用繼承抽象基類 。有時，為了讓抽象類識別子類，甚至不用注冊。要抑制住創建抽象基類的沖動。濫用抽象基類會造成災難性后果，表明語言太注重表面形式 。

抽象基類不能被實例化（不能創建對象），通常是作為基類供子類繼承，子類中重寫虛函數，實現具體的接口。

判定某個對象的類型

強制子類必須實現某些方法

抽象基類的定義與使用

import abc# 定義緩存類class Cache（metaclass=abc.ABCMeta）： @abc.abstractmethod def get（self， key）： pass @abc.abstractmethod def set（self， key， value）： pass# 定義redis緩存類實現Cache類中的get（）和set（）方法class RedisCache（Cache）： def set（self， key）： pass def get（self， key， value）： pass

值得注意的是：Python 3.0-Python3.3之間，繼承抽象基類的語法是class ClassName（metaclass=adc.ABCMeta），其他版本是：class ClassName（abc.ABC）。

collections.abc模塊中各個抽象基類的UML類圖

35個高級Python知識點總結

No.7 isinstence和type的區別

class A（object）： passclass B（A）： passb = B（）print（isinstance（b， B））print（isinstance（b， A））print（type（b） is B）print（type（b） is A）# True# True# True# False

No.8 類變量和實例變量

實例變量只能通過類的實例進行調用

修改模板對象創建的對象的屬性，模板對象的屬性不會改變

修改模板對象的屬性，由模板對象創建的對象的屬性會改變

‘’‘遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學習教程和PDF電子書！’‘’# 此處的類也是模板對象，Python中一切皆對象class A（object）： #類變量 number = 12 def __init__（self）： # 實例變量 self.number_2 = 13# 實例變量只能通過類的實例進行調用print（A.number） # 12print（A（）.number） # 12print（A（）.number_2） # 13# 修改模板對象創建的對象的屬性，模板對象的屬性不會改變a = A（）a.number = 18print（a.number） # 18print（A（）.number） # 12print（A.number） # 12# 修改模板對象的屬性，由模板對象創建的對象的屬性會改變A.number = 19print（A.number） # 19print（A（）.number） # 19

No.9 類和實例屬性以及方法的查找順序

在Python 2.2之前只有經典類，到Python2.7還會兼容經典類，Python3.x以后只使用新式類，Python之前版本也會兼容新式類

Python 2.2 及其之前類沒有基類，Python新式類需要顯式繼承自object，即使不顯式繼承也會默認繼承自object

經典類在類多重繼承的時候是采用從左到右深度優先原則匹配方法的。而新式類是采用C3算法

經典類沒有MRO和instance.mro（）調用的

假定存在以下繼承關系：

class D（object）： def say_hello（self）： passclass E（object）： passclass B（D）： passclass C（E）： passclass A（B， C）： pass

采用DFS（深度優先搜索算法）當調用了A的say_hello（）方法的時候，系統會去B中查找如果B中也沒有找到，那么去D中查找，很顯然D中存在這個方法，但是DFS對于以下繼承關系就會有缺陷：

class D（object）： passclass B（D）： passclass C（D）： def say_hello（self）： passclass A（B， C）： pass

在A的實例對象中調用say_hello方法時，系統會先去B中查找，由于B類中沒有該方法的定義，所以會去D中查找，D類中也沒有，系統就會認為該方法沒有定義，其實該方法在C中定義了。所以考慮使用BFS（廣度優先搜索算法），那么問題回到第一個繼承關系，假定C和D具備重名方法，在調用A的實例的方法時，應該先在B中查找，理應調用D中的方法，但是使用BFS的時候，C類中的方法會覆蓋D類中的方法。在Python 2.3以后的版本中，使用C3算法：

# 獲取解析順序的方法類名.mro（）類名.__mro__inspect.getmro（類名）

使用C3算法后的第二種繼承順序：

‘’‘遇到問題沒人解答？小編創建了一個Python學習交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學習教程和PDF電子書！’‘’class D（object）： passclass B（D）： passclass C（D）： def say_hello（self）： passclass A（B， C）： passprint（A.mro（）） # ［《class ‘__main__.A’》， 《class ‘__main__.B’》， 《class ‘__main__.C’》， 《class ‘__main__.D’》， 《class ‘object’》］

使用C3算法后的第一種繼承順序：

class D（object）： passclass E（object）： passclass B（D）： passclass C（E）： passclass A（B， C）： passprint（A.mro（）） # ［《class ‘__main__.A’》， 《class ‘__main__.B’》， 《class ‘__main__.D’》， 《class ‘__main__.C’》， 《class ‘__main__.E’》， 《class ‘object’》］

在這里僅介紹了算法的作用和演變歷史，關于深入詳細解析，請看我的其他文章——《從Python繼承談起，到C3算法落筆》。

No.10 類方法、實例方法和靜態方法

class Demo（object）： # 類方法 @classmethod def class_method（cls， number）： pass # 靜態方法 @staticmethod def static_method（number）： pass # 對象方法/實例方法 def object_method（self， number）： pass

實例方法只能通過類的實例來調用；靜態方法是一個獨立的、無狀態的函數，緊緊依托于所在類的命名空間上；類方法在為了獲取類中維護的數據，比如：

class Home（object）： # 房間中人數 __number = 0 @classmethod def add_person_number（cls）： cls.__number += 1 @classmethod def get_person_number（cls）： return cls.__number def __new__（self）： Home.add_person_number（） # 重寫__new__方法，調用object的__new__ return super（）.__new__（self）class Person（Home）： def __init__（self）： # 房間人員姓名 self.name = ‘name’ # 創建人員對象時調用Home的__new__（）方法tom = Person（）print（type（tom）） # 《class ‘__main__.Person’》alice = Person（）bob = Person（）test = Person（）print（Home.get_person_number（））