OOP編程是利用“類(lèi)”和“對(duì)象”來(lái)創(chuàng)建各種模型來(lái)實(shí)現(xiàn)對(duì)真實(shí)世界的描述，使用面向?qū)ο缶幊痰脑蛞环矫媸且驗(yàn)樗梢允钩绦虻木S護(hù)和擴(kuò)展變得更簡(jiǎn)單，并且可以大大提高程序開(kāi)發(fā)效率 ，另外，基于面向?qū)ο蟮某绦蚩梢允顾烁尤菀桌斫饽愕拇a邏輯，從而使團(tuán)隊(duì)開(kāi)發(fā)變得更從容

面向?qū)ο蟮膸状蠛诵奶匦裕?/p>

Class 類(lèi)：一個(gè)類(lèi)指相同事物相同特征提取，把相同的屬性方法提煉出來(lái)定義在類(lèi)中

Object 對(duì)象：一個(gè)對(duì)象是類(lèi)的實(shí)例，對(duì)象是具體的，類(lèi)是抽象

封裝:對(duì)外部世界隱藏對(duì)象的工作細(xì)節(jié)

繼承：一個(gè)子類(lèi)繼承基類(lèi)的字段和方法

多態(tài)：對(duì)不同類(lèi)的對(duì)象使用同樣的操作

首先創(chuàng)建類(lèi)的語(yǔ)法

class ClassName(object):
    pass

python中使用class關(guān)鍵字修飾類(lèi)，類(lèi)名一般采用首字母大寫(xiě)，小闊號(hào)里面表示繼承，所有類(lèi)最后都繼承自object。
在類(lèi)中我們可以定義屬性和方法，注意這個(gè)地方有一個(gè)叫法問(wèn)題，方法其實(shí)和之前寫(xiě)的函數(shù)一樣，但是在類(lèi)中定義的稱(chēng)為方法，兩個(gè)的區(qū)別在調(diào)用的時(shí)候，方法需要特定的對(duì)象，而函數(shù)不需要
下面我們來(lái)自己寫(xiě)一個(gè)簡(jiǎn)單的類(lèi)看下

class Lufei:
    name="蒙奇·D·路飛"
    age=10
    def eatmeat(self):
        print("吃肉")


l=Lufei()      #實(shí)例化
print(l.name)  #調(diào)用類(lèi)的屬性
l.eatmeat()    #調(diào)用類(lèi)的方法

在eatmeat的方法參數(shù)中有一個(gè)self,這個(gè)需要注意下一定不可以省略，對(duì)于在類(lèi)中定義方法的要求，就是第一個(gè)參數(shù)必須時(shí)self,除第一個(gè)參數(shù)外，類(lèi)的方法和普通函數(shù)沒(méi)有什么區(qū)別，前面學(xué)會(huì)的可變參數(shù)、默認(rèn)參數(shù)、關(guān)鍵字參數(shù)等等都可以直接使用。

不僅是__init__需要self作為第一個(gè)參數(shù)，類(lèi)中定義的所有方法都需要。類(lèi)代碼設(shè)計(jì)為在所有對(duì)象實(shí)例間共享，self可以幫助標(biāo)示要處理哪個(gè)對(duì)象實(shí)例的數(shù)據(jù)。
python要求每個(gè)方法的第一個(gè)參數(shù)為調(diào)用對(duì)象實(shí)例，其實(shí)我們來(lái)看下下面代碼就懂了，來(lái)看下當(dāng)我們實(shí)例話(huà)后python解釋器做了什么

#我們寫(xiě)的
l=Lufei（）
l.eatmeat（）
#python執(zhí)行的代碼
Lufei.__init__（l）
l.eatmeat（l）

class Lufei:
    def __init__(self,dream):
        print("類(lèi)初始化的時(shí)候執(zhí)行__init__")
        self.dream=dream

    name="蒙奇·D·路飛"
    age=10
    def eatmeat(self):
        print("吃肉"+self.dream)


l=Lufei("夢(mèng)想是找到傳說(shuō)中的One Piece，成為海賊王")      #實(shí)例化
l.eatmeat()    #調(diào)用類(lèi)的方法

通過(guò)上面我們來(lái)認(rèn)識(shí)一個(gè)新的方法，__init__()方法是一個(gè)特殊的方法，在對(duì)象實(shí)例化的時(shí)候調(diào)用（init表示初始化的意思，是initialization的簡(jiǎn)寫(xiě)）注意前后兩個(gè)下劃線(xiàn)不可以省略，這個(gè)方法也叫構(gòu)造方法
在定義類(lèi)的時(shí)候，如果沒(méi)有顯示定義一個(gè)__init__()方法，程序默認(rèn)調(diào)用一個(gè)無(wú)參的__init__()方法，但是要注意，一個(gè)類(lèi)中只定義一個(gè)構(gòu)造函數(shù)，編寫(xiě)多個(gè)實(shí)例化的時(shí)候會(huì)調(diào)用最后一個(gè)。

#正常創(chuàng)建一個(gè)類(lèi)
class Bird:
    def fly(self):
        print("i can fly")
 

print(Bird.__class__) #輸出  
#那么我們知道Bird其實(shí)也是一個(gè)對(duì)象，通過(guò)type這個(gè)類(lèi)進(jìn)行實(shí)例化的

#通過(guò)type構(gòu)造函數(shù)來(lái)參加一個(gè)類(lèi)
# def fly(self):
#     print("i can fly")

# #type(“類(lèi)名”,"基類(lèi)"，類(lèi)的成員)
# Bird=type("Bird",(object,),{"fly":fly})    

b=Bird()
b.fly()

class Bird:
    def __init__(self):
        print("init") #先執(zhí)行new 再執(zhí)行init

    def fly(self):
        print("fly")

    def __new__(self):
        print("new")
        return object.__new__(self) #如果沒(méi)有return，這個(gè)對(duì)象并沒(méi)有創(chuàng)建成功

b=Bird()
b.fly()

new 用來(lái)創(chuàng)建實(shí)例，在返回的實(shí)例上執(zhí)行__init__，如果不返回實(shí)例那么__init__將不會(huì)執(zhí)行
init 用來(lái)初始化實(shí)例，設(shè)置屬性什么的

class Lufei:
    def __init__(self):
        # pass
        self.name="路飛"  #實(shí)例變量,以self.開(kāi)頭

    name="蒙奇·D·路飛" #類(lèi)變量
    age=10

l=Lufei()      #實(shí)例化
print(l.name) #訪(fǎng)問(wèn)實(shí)例變量，輸出路飛
print(Lufei.name) #訪(fǎng)問(wèn)類(lèi)變量，輸出蒙奇·D·路飛

首先我們先來(lái)說(shuō)下，實(shí)例的屬性和類(lèi)屬性分別存儲(chǔ)在對(duì)應(yīng)的dict中，當(dāng)我們輸出查找的時(shí)候，它的順序是 實(shí)例dict->類(lèi)的dict->基類(lèi)
那么我們區(qū)分類(lèi)變量和實(shí)例變量的目的是什么呢，他們有什么區(qū)別：很重要的一點(diǎn)，實(shí)例變量為每個(gè)實(shí)例獨(dú)有，類(lèi)變量為所有實(shí)例共享，我們來(lái)通過(guò)修改和打印來(lái)看下

class Lufei:
    def __init__(self):
        pass
        # self.name="路飛"  #實(shí)例變量,以self.開(kāi)頭

    name="蒙奇·D·路飛" #類(lèi)變量
    age=10

l=Lufei()      #實(shí)例化
# l.name="777"
Lufei.name="666" #修改的是類(lèi)變量
print(l.name) #訪(fǎng)問(wèn)實(shí)例變量 
print(Lufei.name) #訪(fǎng)問(wèn)類(lèi)變量 

l1=Lufei()   #實(shí)例化
print(l1.name) 

如果通過(guò)Lufei.name="666" 這句修改的話(huà)，則三個(gè)輸出都是 666，因?yàn)轭?lèi)變量作用所有實(shí)例，如果通過(guò)l.name="777"這句話(huà)修改，則只有l(wèi)這個(gè)實(shí)例輸出777，l1實(shí)例輸出蒙奇·D·路飛
類(lèi)變量的用途：大家共用的屬性放在類(lèi)變量中

在類(lèi)中我們定義自己的屬性和方法，通過(guò)實(shí)例化后的對(duì)象，可以在外部進(jìn)行調(diào)用，但是我們也可以對(duì)屬性和方法的訪(fǎng)問(wèn)權(quán)限進(jìn)行設(shè)置，讓外界無(wú)法訪(fǎng)問(wèn)。
在python中實(shí)例的變量名以__開(kāi)頭，就會(huì)變成私有變量（private）外部不能訪(fǎng)問(wèn)

class Lufei:
    def __init__(self,dream):
        print("類(lèi)初始化的時(shí)候執(zhí)行__init__")
        self.__dream=dream

    __name="蒙奇·D·路飛" #加__前綴變成私有變量
    age=10
    def eatmeat(self):
        print("吃肉"+self.__dream) #私有變量在外部無(wú)法訪(fǎng)問(wèn)，內(nèi)部可以訪(fǎng)問(wèn)


l=Lufei("夢(mèng)想是找到傳說(shuō)中的One Piece，成為海賊王")      #實(shí)例化
print(l.__name) #報(bào)錯(cuò) "Lufei" object has no attribute "name"
l.eatmeat()    #調(diào)用類(lèi)的方法

上面的代碼中我們可以進(jìn)行設(shè)置私有變量，那么私有變量都無(wú)法訪(fǎng)問(wèn)了，如果想要對(duì)其進(jìn)行操作有什么方式呢，我們可以通過(guò)方法來(lái)解決，比如我們修改下私有變量為age

class Lufei:
    def __init__(self,dream):
        print("類(lèi)初始化的時(shí)候執(zhí)行__init__")
        self.__dream=dream

    name="蒙奇·D·路飛" 
    __age=10#加__前綴變成私有變量
    #通過(guò)方法或者私有變量返回
    def getage(self):
        return self.__age
    #通過(guò)方法對(duì)私有變量進(jìn)行賦值操作，并可以進(jìn)行數(shù)據(jù)安全驗(yàn)證
    def setage(self,age):
        if age<0:
            return "太小了"
        else:
            self.__age=age
            return "ok"
    def eatmeat(self):
        print("吃肉"+self.__dream) #私有變量在外部無(wú)法訪(fǎng)問(wèn)，內(nèi)部可以訪(fǎng)問(wèn)


l=Lufei("夢(mèng)想是找到傳說(shuō)中的One Piece，成為海賊王")      #實(shí)例化
l.eatmeat()    #調(diào)用類(lèi)的方法

l.setage(100)#對(duì)私有變量年齡進(jìn)行設(shè)置
print(l.getage()) #獲取私有變量年齡

可以看到通過(guò)上面的代碼，我們既可以獲取到私有變量，又可以對(duì)你參數(shù)進(jìn)行安全檢查，既然變量可以，那方法是不是能設(shè)置為私有方法呢，答案肯定可以，和私有變量一樣，在名字的前面加上__即可

#定義一個(gè)私有方法    
def __getdream(self):
   print(self.__dream)  #class外界無(wú)法訪(fǎng)問(wèn)，內(nèi)部可以同self.__getdream()訪(fǎng)問(wèn)

class Bird:
    name="lalal"
    def fly(self):
        print("fly")
        print(self) #輸出: <__main__.Bird object at 0x00000000022032E8>

    @classmethod
    def eat(cls):
        # 一個(gè)類(lèi)方法就可以通過(guò)類(lèi)或它的實(shí)例來(lái)調(diào)用的方法, 不管你是用類(lèi)來(lái)調(diào)用這個(gè)方法還是類(lèi)實(shí)例調(diào)用這個(gè)方法,該方法的第一個(gè)參數(shù)總是定義該方法的類(lèi)對(duì)象。 
        # 記住:方法的第一個(gè)參數(shù)都是類(lèi)對(duì)象而不是實(shí)例對(duì)象
        #類(lèi)方法
        print("eat")
        print(cls) #輸出：

    @staticmethod
    def sleep():
        #使用靜態(tài)方法的好處是，不需要定義實(shí)例即可使用這個(gè)方法。另外，多個(gè)實(shí)例共享此靜態(tài)方法。
        #使用了靜態(tài)方法，則不能再使用self
        #靜態(tài)方法不能訪(fǎng)問(wèn)類(lèi)變量和實(shí)例變量
        # print(name)#報(bào)錯(cuò)
        print("sleep")  

b=Bird()
# Bird.fly(b) 傳遞self進(jìn)去，不傳遞只是一個(gè)語(yǔ)法糖
b.fly()  #實(shí)例方法只能被實(shí)例對(duì)象調(diào)用
# 靜態(tài)方法(由@staticmethod裝飾的方法)、類(lèi)方法(由@classmethod裝飾的方法)，可以被類(lèi)或類(lèi)的實(shí)例對(duì)象調(diào)用
b.eat()
b.sleep()
#可以被類(lèi)或類(lèi)的實(shí)例對(duì)象調(diào)用
Bird.eat()
Bird.sleep()

#實(shí)例方法、類(lèi)方法、靜態(tài)方法區(qū)別：
#1.實(shí)例方法隱含的參數(shù)為類(lèi)實(shí)例ｓｅｌｆ，而類(lèi)方法隱含的參數(shù)為類(lèi)本身ｃｌｓ。
#靜態(tài)方法無(wú)隱含參數(shù)，主要為了類(lèi)實(shí)例也可以直接調(diào)用靜態(tài)方法。
#2.靜態(tài)方法是無(wú)法訪(fǎng)問(wèn)實(shí)例變量的
#3.類(lèi)成員方法也同樣無(wú)法訪(fǎng)問(wèn)實(shí)例變量，但可以訪(fǎng)問(wèn)類(lèi)變量；
# 靜態(tài)方法有點(diǎn)像函數(shù)工具庫(kù)的作用，而類(lèi)成員方法則更接近類(lèi)似Java面向?qū)ο蟾拍钪械撵o態(tài)方法。

總結(jié)兩點(diǎn)：

靜態(tài)方法：無(wú)法訪(fǎng)問(wèn)類(lèi)屬性、實(shí)例屬性，相當(dāng)于一個(gè)相對(duì)獨(dú)立的方法，跟類(lèi)其實(shí)沒(méi)什么關(guān)系，換個(gè)角度來(lái)講，其實(shí)就是放在一個(gè)類(lèi)的作用域里的函數(shù)而已。

類(lèi)成員方法：可以訪(fǎng)問(wèn)類(lèi)屬性，無(wú)法訪(fǎng)問(wèn)實(shí)例屬性。上述的變量val1，在類(lèi)里是類(lèi)變量，在實(shí)例中又是實(shí)例變量，所以容易混淆。

我們先來(lái)說(shuō)下繼承的概念，實(shí)現(xiàn)重用的方法之一就是通過(guò)繼承機(jī)制，就像生活中，子女繼承父母的財(cái)產(chǎn)，當(dāng)然也有可能是螞蟻花唄
繼承的語(yǔ)法，在定義好的類(lèi)小括號(hào)里面寫(xiě)上要繼承的類(lèi)名，這個(gè)時(shí)候，被繼承的類(lèi)我們稱(chēng)為父類(lèi)或者基類(lèi)，繼承的類(lèi)的稱(chēng)為子類(lèi)或者派生類(lèi)，我們來(lái)看下具體的代碼實(shí)現(xiàn)

#父類(lèi)
class Long:
    name="蒙奇·D·龍"
    def Getdream(self):
        print("推翻世界政府，改變世界抹去不需要人的規(guī)則。建立和諧，自由，平等，充滿(mǎn)夢(mèng)想的世界。")
#子類(lèi)
class Lufei(Long):
    pass

l=Lufei() #實(shí)例化子類(lèi)
l.Getdream() #從父類(lèi)繼承來(lái)的

Lufei是子類(lèi)，Long是父類(lèi)，子類(lèi)可以繼承父類(lèi)非私有的所有屬性和方法
上面代碼中屬于單繼承，python還支持多重繼承，在小括號(hào)里面可以通過(guò)都好分隔寫(xiě)多個(gè)父類(lèi)的名稱(chēng)，需要注意的是當(dāng)多個(gè)父類(lèi)的時(shí)候，python會(huì)從左到右搜索

#父類(lèi)
class Long:
    name="蒙奇·D·龍"
    def Getdream(self):
        print("推翻世界政府，改變世界抹去不需要人的規(guī)則。建立和諧，自由，平等，充滿(mǎn)夢(mèng)想的世界。")
class Hongfa:
    name="香克斯"

#子類(lèi)
class Lufei(Long,Hongfa):
    pass

l=Lufei() #實(shí)例化子類(lèi)
print(l.name) #當(dāng)訪(fǎng)問(wèn)的屬性?xún)蓚€(gè)父類(lèi)中都有定義的時(shí)候以第一個(gè)為主
l.Getdream() #從父類(lèi)繼承來(lái)的

好了，我們這就完成了多重繼承，一個(gè)子類(lèi)繼承了多個(gè)父類(lèi)，同時(shí)獲得了多個(gè)父類(lèi)的所有非私有功能

在類(lèi)的繼承中，如果重定義某個(gè)方法，該方法會(huì)覆蓋父類(lèi)的同名方法，但有時(shí)，我們希望能同時(shí)實(shí)現(xiàn)父類(lèi)的功能，這時(shí)，我們就需要調(diào)用父類(lèi)的方法了，可通過(guò)使用 super 來(lái)實(shí)現(xiàn)

class Animal(object):
    def __init__(self, name):
        self.name = name
    def greet(self):
        print("父類(lèi)中的")

class Dog(Animal):
    def greet(self):
        super().greet()  #通過(guò)super訪(fǎng)問(wèn)父類(lèi)中的方法
        # 當(dāng)然 Python 2 里super() 是一定要參數(shù)的 super(Dog, self).greet()
        print("子類(lèi)中的")

d=Dog("旺財(cái)")
d.greet()       

在子類(lèi)中除了super還可以通過(guò)父類(lèi)名稱(chēng).方法去進(jìn)行調(diào)用，但是我們選擇super的另一個(gè)好處是他避免硬編碼和在多重繼承上面所發(fā)揮的

什么是硬編碼？硬編碼一般指在代碼中寫(xiě)死的，與它相對(duì)應(yīng)的是配置項(xiàng)，可以在程序發(fā)布后進(jìn)行修改

對(duì)于支持繼承的編程語(yǔ)言來(lái)說(shuō)，其方法（屬性）可能定義在當(dāng)前類(lèi)，也可能來(lái)自于基類(lèi)，所以在方法調(diào)用時(shí)就需要對(duì)當(dāng)前類(lèi)和基類(lèi)進(jìn)行搜索以確定方法所在的位置。而搜索的順序就是所謂的「方法解析順序」（Method Resolution Order，或MRO）。對(duì)于只支持單繼承的語(yǔ)言來(lái)說(shuō)，MRO 一般比較簡(jiǎn)單；而對(duì)于 Python 這種支持多繼承的語(yǔ)言來(lái)說(shuō)，MRO 就復(fù)雜很多。

super在上面的代碼訪(fǎng)問(wèn)父類(lèi)的方法沒(méi)任何問(wèn)題，那么如果是訪(fǎng)問(wèn)父類(lèi)的父類(lèi)呢，我們先初始化一個(gè)場(chǎng)景

class A(object):
    def __init__(self):
        print("A")
    def show(self):
        print("A中的show")           
class B(A):
    def __init__(self):
        super().__init__()
        print("B")
 
class C(A):
    def __init__(self):
        super().__init__()
        print("C")
    def show(self):
        #重寫(xiě)了父類(lèi)中的show
        print("C中的show")  

class D(B,C):
    def __init__(self):
        super().__init__()
        print("D")  

通過(guò)上面的代碼，我們可以得到下圖

那么問(wèn)題來(lái)了，這個(gè)時(shí)候 d1.show()的結(jié)果會(huì)是什么？

說(shuō)會(huì)MRO,事實(shí)上，對(duì)于你定義的每一個(gè)類(lèi)，Python 會(huì)計(jì)算出一個(gè)方法解析順序（Method Resolution Order, MRO）列表，它代表了類(lèi)繼承的順序，我們可以使用下面的方式獲得某個(gè)類(lèi)的 MRO 列表：

print(D.__mro__) #輸出(, , , , )

Python 至少有三種不同的 MRO：
1.經(jīng)典類(lèi)（classic class）的深度遍歷。
經(jīng)典類(lèi)采用了一種很簡(jiǎn)單的 MRO 方法：從左至右的深度優(yōu)先遍歷。以上述「菱形繼承」為例，其查找順序?yàn)?[D, B, A, C, A]，如果只保留重復(fù)類(lèi)的第一個(gè)則結(jié)果為 [D,B,A,C]
2.Python 2.2 的新式類(lèi)（new-style class）預(yù)計(jì)算。
3.Python 2.3 的新式類(lèi)的C3 算法。它也是 Python 3 唯一支持的方式。

多態(tài)來(lái)自于希臘語(yǔ)，意思是有多種形式，多態(tài)意味著即使不知道變量所引用的對(duì)象類(lèi)型是什么，也能對(duì)對(duì)象進(jìn)行操作，多態(tài)會(huì)根據(jù)對(duì)象的不同而表現(xiàn)出不同的行為

#父類(lèi)
class Long:
    name="蒙奇·D·龍"
    def Getdream(self):
        print("推翻世界政府，改變世界抹去不需要人的規(guī)則。建立和諧，自由，平等，充滿(mǎn)夢(mèng)想的世界。")

#子類(lèi)
class Lufei(Long):
    name="蒙奇·D·路飛"
    def Uniqueskills(self):
        print("三檔")
#子類(lèi)
class Aisi(Long):
    name="艾斯"
    def Uniqueskills(self):
        print("火拳")   

#定義父類(lèi)作為參數(shù)，所有的子類(lèi)都可以傳參進(jìn)去
def Show(Long):
    Long.Uniqueskills()

Show(Lufei()) #輸出三擋
Show(Aisi())  #輸出火拳

有沒(méi)有理解多態(tài)，其實(shí)很簡(jiǎn)單，多態(tài)我們不用對(duì)具體的子類(lèi)型進(jìn)行了解，到底調(diào)用哪一個(gè)方法，在運(yùn)行的時(shí)候會(huì)由該對(duì)象的確切類(lèi)型決定，使用多態(tài)，我們只管調(diào)用，不用管細(xì)節(jié)

其實(shí)我們從學(xué)習(xí)函數(shù)以來(lái)都在提及封裝的概念，封裝我們可以理解為，不用管具體的實(shí)現(xiàn)細(xì)節(jié)，直接調(diào)用即可，就像我們看電視，完全不用管電視是怎么播放的，只需要按下按鈕可以觀(guān)看即可

當(dāng)使用del 刪除對(duì)象時(shí)，會(huì)調(diào)用他本身的析構(gòu)函數(shù)，另外當(dāng)對(duì)象在某個(gè)作用域中調(diào)用完畢，在跳出其作用域的同時(shí)析構(gòu)函數(shù)也會(huì)被調(diào)用一次，這樣可以用來(lái)釋放內(nèi)存空間。
__del__()也是可選的，如果不提供，則Python 會(huì)在后臺(tái)提供默認(rèn)析構(gòu)函數(shù)

class Lufei:
    def __init__(self):
        self.name="路飛" 

    def __del__(self):
        print("掛了")

析構(gòu)函數(shù)：在實(shí)例釋放、銷(xiāo)毀的時(shí)候執(zhí)行、通常用于做一些收尾工作，如關(guān)閉一些數(shù)據(jù)

class BigBrid:
    """描述類(lèi)的信息""" #BigBrid.__doc__ 可以看到    
    name="bb"
    def eat(self):
        print("吃")
    def __str__(self):
        return "lidao"
    
b=BigBrid()
b.name="lala"
print(b.__doc__) #輸出：描述類(lèi)的信息
print(b.__module__)#輸出：__main__
print(b.__class__)#輸出：
#__init__ 構(gòu)造方法，通過(guò)類(lèi)創(chuàng)建對(duì)象時(shí)，自動(dòng)觸發(fā)執(zhí)行
#__del__析構(gòu)方法，當(dāng)對(duì)象在內(nèi)存中被釋放時(shí)，自動(dòng)觸發(fā)執(zhí)行。
print(BigBrid.__dict__) #獲取類(lèi)的成員 輸出：{"__module__": "__main__", "__doc__": "描述類(lèi)的信息", "name": "bb", "eat": , "__dict__": , "__weakref__": }
print(b.__dict__) #獲取 對(duì)象b 的成員 輸出：{"name": "lala"}
#__str__ 如果一個(gè)類(lèi)中定義了__str__方法，那么在打印 對(duì)象 時(shí)，默認(rèn)輸出該方法的返回值。
print(b) #輸出 lidao