No.1 一切皆對象

眾所周知，Java中強調(diào)“一切皆對象”，但是Python中的面向?qū)ο蟊菾ava更加徹底，因為Python中的類（class）也是對象，函數(shù)（function）也是對象，而且Python的代碼和模塊也都是對象。

Python中函數(shù)和類可以賦值給一個變量

Python中函數(shù)和類可以存放到集合對象中

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

Python中函數(shù)和類可以作為返回值

Step.1

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

Step.2

‘’‘遇到問題沒人解答？小編創(chuàng)建了一個Python學(xué)習(xí)交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學(xué)習(xí)教程和PDF電子書！’‘’# 將函數(shù)和類添加到集合中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

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

Step.4

# 定義函數(shù)實現(xiàn)返回類和函數(shù)def test_func2（）： return Demodef test_func3（）： return function# 執(zhí)行函數(shù)test_func2（）（） # Demo Classtest_func3（）（） # function

No.2 關(guān)鍵字type、object、class之間的關(guān)系

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

‘’‘遇到問題沒人解答？小編創(chuàng)建了一個Python學(xué)習(xí)交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學(xué)習(xí)教程和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的內(nèi)置類型

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

在內(nèi)存中的地址，使用id（）函數(shù)進行查看

對象的類型

對象的默認值

Step.1 None類型

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

Step.2 數(shù)值類型

ini類型

float類型

complex類型

bool類型

Step.3 迭代類型

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

Step.4 序列類型

list

tuple

str

array

range

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

Step.5 映射類型

dict

Step.6 集合類型

set

frozenset

Step.7 上下文管理類型

with語句

Step.8 其他類型

模塊

class

實例

函數(shù)

方法

代碼

object對象

type對象

ellipsis（省略號）

notimplemented

NO.4 魔法函數(shù)

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

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

鴨子類型是程序設(shè)計中的推斷風(fēng)格，在鴨子類型中關(guān)注對象如何使用而不是類型本身。鴨子類型像多態(tài)一樣工作但是沒有繼承。鴨子類型的概念來自于：“當看到一只鳥走起來像鴨子、游泳起來像鴨子、叫起來也像鴨子，那么這只鳥就可以被稱為鴨子?！?/p>

‘’‘遇到問題沒人解答？小編創(chuàng)建了一個Python學(xué)習(xí)交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學(xué)習(xí)教程和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中多態(tài)的體現(xiàn)# 定義動物列表an_li = ［］# 將動物添加到列表an_li.append（Dog）an_li.append（Cat）an_li.append（Duck）# 依次調(diào)用每個動物的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 協(xié)議、 抽象基類、abc模塊和序列之間的繼承關(guān)系

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

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

我們可以使用猴子補丁來實現(xiàn)協(xié)議，那么什么是猴子補丁呢？

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

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

猴子補丁的主要作用是：

在運行時替換方法、屬性

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

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

應(yīng)用案例：假設(shè)寫了一個很大的項目，處處使用了json模塊來解析json文件，但是后來發(fā)現(xiàn)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 的抽象基類有一個重要實用優(yōu)勢：可以使用 register 類方法在終端用戶的代碼中把某個類 “聲明” 為一個抽象基類的 “虛擬” 子 類（為此，被注冊的類必腨滿足抽象其類對方法名稱和簽名的要求，最重要的是要滿足底 層語義契約；但是，開發(fā)那個類時不用了解抽象基類，更不用繼承抽象基類 。有時，為了讓抽象類識別子類，甚至不用注冊。要抑制住創(chuàng)建抽象基類的沖動。濫用抽象基類會造成災(zāi)難性后果，表明語言太注重表面形式 。

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

判定某個對象的類型

強制子類必須實現(xiàn)某些方法

抽象基類的定義與使用

import abc# 定義緩存類class Cache（metaclass=abc.ABCMeta）： @abc.abstractmethod def get（self， key）： pass @abc.abstractmethod def set（self， key， value）： pass# 定義redis緩存類實現(xiàn)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知識點總結(jié)

No.7 isinstence和type的區(qū)別

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 類變量和實例變量

實例變量只能通過類的實例進行調(diào)用

修改模板對象創(chuàng)建的對象的屬性，模板對象的屬性不會改變

修改模板對象的屬性，由模板對象創(chuàng)建的對象的屬性會改變

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

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

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

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

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

經(jīng)典類沒有MRO和instance.mro（）調(diào)用的

假定存在以下繼承關(guān)系：

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

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

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

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

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

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

‘’‘遇到問題沒人解答？小編創(chuàng)建了一個Python學(xué)習(xí)交流QQ群：857662006 尋找有志同道合的小伙伴，互幫互助，群里還有不錯的視頻學(xué)習(xí)教程和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’》］

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

No.10 類方法、實例方法和靜態(tài)方法

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

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

class Home（object）： # 房間中人數(shù) __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__方法，調(diào)用object的__new__ return super（）.__new__（self）class Person（Home）： def __init__（self）： # 房間人員姓名 self.name = ‘name’ # 創(chuàng)建人員對象時調(diào)用Home的__new__（）方法tom = Person（）print（type（tom）） # 《class ‘__main__.Person’》alice = Person（）bob = Person（）test = Person（）print（Home.get_person_number（））