面向物件-有解無憂

1.什么是面向物件和面向程序編程思想

面向程序：

1.核心是‘程序’二字
2.程序的含義是將程式流程化
3.程序是流水線，用來分步驟解決問題的

面向物件：

1.核心是‘物件’二字
2.物件的含義是將程式進行整合
3.物件是‘容器’，用來盛放資料和功能（變數和函式）

總結：以做西紅柿雞蛋面為例：

面向程序：我需要買西紅柿--》買雞蛋、面--》把西紅柿洗好、雞蛋打好...等等
面向物件：找個人幫我干活，我只需要告訴那個人我需要吃西紅柿雞蛋面（呼叫該物件），具體的程序交給別人干，

python中可以用來盛放資料和功能的‘容器’可以是字典、串列、集合等，但是這些容器在存放功能的時候，并不能把功能的具體代碼全部傳進去（只能傳一個函式名），這就有一定的局限性！

那么，python中提供了什么樣的語法來讓我們更好的存放資料和功能呢？？

2.類

類，其實也是‘容器’，它是用來存放物件1、物件2、物件3...等共有的資料和功能！！

它能夠更好的節省空間并且幫我們更好完成面向物件的編程！

2.1 類的引入

# 所有類體中最常見的就是變數和功能的定義，但是類體中也可以包含其他代碼
# 注意：類體中的代碼是在定義階段就會執行的，也就是說在定義階段就開辟了名稱空間

class ClassName: # 類的定義 class 類名：
    # 變數(資料)的定義
    var = 111
    # 功能的定義
    def send(self):
        pass

    def rcv(self):
        pass
		
# 類中提供了一個方法查看類的名稱空間.__dict__,得到一個字典
print(ClassName.__dict__)
# __dict__[key]呼叫類體中的變數值或者功能
print(ClassName.__dict__['send'])
# 為了簡便上述的呼叫方式，類提供了.變數/.函式名的方法來呼叫,注意不加括號
print(ClassName.send)

2.2 類的呼叫--產生物件

# 類的呼叫，類名()的方式回傳了一個class_obj物件，就是把類和該物件建立了一個聯系，該物件就可以使用類里面的定義的變數和功能了
class_obj = ClassName()

# 該物件的.__dict__方法得到的是一個空字典，可以使用物件.屬性名=屬性值的方式給該字典添加值
print(class_obj.__dict__)

# 類名.變數名/類名.函式名 呼叫類的變數和功能
print(class_obj.var)

2.3 類的init方法

當物件1、物件2、物件3...等的屬性都一樣，只是值不同的時候，我們不斷的使用物件.屬性=屬性值給物件賦值的時候，不免需要個每個物件都這樣操作，這樣會使得代碼冗余，

因此類中有一個 __init__的初始化方法，會自動幫你封裝好這個物件獨有的屬性，你只需要在呼叫的時候傳入對應的屬性值就行，

class ClassName:
    # 引數self表示呼叫類時產生的物件，x和y是呼叫類時對應傳人的引數
    def __init__(self,x,y):
        self.name = x
        self.age = y

# 呼叫類產生物件的操作，實際上是類的實體化的程序，這個程序發生了三件事
# 1.產生了一個空物件
# 2.自動呼叫類里面的__init__方法，并將呼叫時候的引數對應傳給__init__方法
# 3.回傳初始化好的物件class_obj
class_obj = ClassName('zhang',18)

總結：

1.該方法會在呼叫類的時候自動執行，用來為物件初始化自己獨有的屬性
2.該方法記憶體放的是為物件初始化屬性的功能，但是也可以存放其他需要在呼叫時就執行的代碼
3.該方法的回傳值只能是none

2.4 類中的屬性查找

1.資料屬性

類中屬性查找的順序是物件先從自己那查找，如果找不到該屬性，則去類里面查找，物件修改添加屬性和屬性值，這并不會影響類里面對應的屬性，其余物件獲取到的還是原來類里面定義的屬性值

類中定義了物件所需要的所有的共有屬性和功能，大家訪問共有屬性和功能的地址都是一樣的，

2.函式屬性

正在呼叫類中的方法是需要按照:類名.函式名(物件)的方法進行呼叫，但是這樣未免太過麻煩，

所以，類提供了一種系結方法：物件在呼叫類中功能（函式）時，會自動把該物件當成引數自動傳入，
物件1.類中函式名（）==類名.函式名(物件) #這里默認函式名傳入了物件1

回顧一下串列、字典，其實也是采用了類的思想！
l=[11,22,33] 等價于 l=list([11,22,33])
其實list就是一個類，l就是一個物件
l.append('dd')等價于list.append(l,'dd') 就是呼叫list類里的append方法

2.5 類中如何隱藏屬性

在屬性名前加__前綴，就會實作一個隱藏的效果，外界就不能呼叫該屬性了，

該方法只是語法形式上的變形，通過__dict__查看其真正的語法名，然后在外部也是可以訪問到的！

隱藏屬性在外部訪問不到，但是在類內部還是可以訪問到的

這樣操作的目的是：不讓外部輕易的訪問到內部的屬性，即使需要訪問，也必須需要一些條件，

2.6 類中的property

property其實就是一種裝飾器，它的功能是把類中的方法偽裝成資料屬性，呼叫的時候就不用呼叫該方法了，直接把方法當成資料呼叫即可（不用加括號了），

class ClassName: 
    def __init__(self):
	self.__name = name
    @property #法一：
    def get(self):
        return __self.name

    def set(self,val):
        self.__name = val
    # 法二：偽裝的更像了 
    name = property（get，set）
    # 改進：直接在函式上加@name.setter（修改值裝飾器）@name.deleter（洗掉值裝飾器）,把函式名都改成name
class_obj = ClassName（）
# 法一呼叫,不用加括號了
class_obj.get
# 法二呼叫
class_obj.name #獲取名字
class_obj.name=123 #修改名字

2.7 類中classmethod方法

在類中，我們定義的方法默認是系結給物件的，即在實體化類的時候，物件會默認當成引數傳入到類中的方法里面，
obj = ClassName（） #這里obj自動傳入了

如何定義一個方法，該方法是默認傳入類的呢？？

只需要在我們需要系結的方法前面加上@classmethod就行，下次我們在呼叫該類的方法時會自動傳入該類名，呼叫者是類，

class B:
    @classmethod
    def fun(cls):
        pass

2.8 staticmethod方法

不需要系結給類或者物件的方法，在對應函式上加上@staticmethod，呼叫者可以是類或者物件，沒有自動傳參的效果，

3. 面向物件的三大特性

3.1 封裝

封裝其實就是整合，對于共有的資料和功能進行整合，

3.2 繼承

3.2.1 什么是繼承

繼承是一種創建新類的方式，新建的類可以稱為子類或者派生類，繼承的類可以稱為父類或者基類

python支持多繼承，就是一個新建的類可以繼承多個父類,python3默認繼承object類,在python2中繼承了object的叫新式類，沒有繼承的叫經典類，python2中需要手動書寫需要繼承的類，不會默認繼承object，

class Student(object): 
    pass

class Student2(object):
    pass
class Sub(Student):# 父類是Student
    pass

class Sub2(Student,Student2): # 父類是Student和Student2
    pass

3.2.2 為什么要用繼承

類是用來物件資料和功能冗余的問題，而類是用來解決類與類的冗余

3.2.3 繼承中的菱形問題的屬性查找（后磚石問題）

菱形問題實際指的是，在python2和python3中菱形模式的繼承會導致，繼承查找順序不一致的問題！！，這個需要注意！

D類繼承了B和C類，B和C類分別繼承了A類，如果A中有一個方法，B和C都重寫了該方法，而D沒有重寫，那么D繼承的是哪個版本的方法呢？

class A:
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B,C): 
    pass
obj = D()
obj.test()
# 查找會從D-->B-->C-->A,如果D的父類順序換了，則查找順序也會變成D-->C-->B-->A，python2中的經典類就不一樣了，查找順序為D-->B-->A-->C

其實，對于你定義的每一個類，python都會計算出一個方法決議順序（MRO）串列，該MRO串列就是一個簡單的所有基類的線性順序串列，

物件.mro（）或者類.mro() #查看MRO線性順序串列

python會在MRO串列中從左到右開始查找基類，知道找到第一個匹配這個屬性的類為止，這個MRO串列的構造是通過一個C3線性化演算法來實作的（了解一下即可），

3.2.4 非菱形問題下的查找順序

python2和3的查找順序為：A-->B--->E--->C--->F--->D---object

3.2.5 多繼承下的mixins機制

mixins機制的核心：就是在多繼承的背景下盡可能的提升多繼承的可讀性

python的多繼承類中，應當只有一個標識其歸屬含義的父類，意思是保證多繼承的類遵循繼承‘is-a’的原則，其余繼承的類都應該是mixin類，該類的命名規范一般是以mixin、able、ible為后綴，

mixin類只是用來表達某一類功能的類，并不決定子類的歸屬，它也不依賴于子類的實作，而且子類也并不是完全依賴mixin類，缺少了該類，子類照常作業，只是缺少了某種功能罷了！！

最后，mixin類盡量少用，當mixin類很多的時候，依然會造成可讀性差的問題！！

3.2.6 子類派生的新方法中如何重用父類功能

法一：指名道姓的呼叫某一個類下面的函式，該方法不依賴類的繼承


class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age

class B:
    def __init__(self,name,age,work):
        A.__init__(self,name,age) # 法一：指名道姓
        self.work = work

obj = B('zhang','18','python')
print(obj.__dict__)

法二：super()方法，該方法嚴格依賴繼承關系

呼叫super（）會得到一個特殊的物件，注意該物件是參照當前發起屬性查找那個類的mro，去當前類的父類中查找屬性！！ 輔助下面的列子進行理解！

class A:
    def test(self):
        print('from A')
        super(A, self).test() # python3中super也可以省略括號里的引數

class B:
    def test(self):
        print('from B')

class C(A,B):
    pass

obj = C()
obj.test()
# 1.首先會到obj物件里面去找test方法
# 2.再去C里面找
# 3.再去A里面找test方法，找到了列印
# 4.然后遇到了super()會得到一個特殊的物件，該物件參照當前發起屬性查找的類的mro就是C這個類，去當前呼叫super()方法的父類中查找test屬性
# 5.C這個類的mro是[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
# 6.當前super()方法的父類是B
print(C.mro())

3.3 多型與鴨子型別

多型性和鴨子型別的本質在于，不同的類中定義了相同的方法名，這樣我們就可以不考慮類而統一用一種方式去使用物件，

比如，所有的類中都定義了read和write方法，那么我們在呼叫的時候就可以不考慮類，直接讓類實體化出來的物件呼叫read和write方法就行，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/502428.html

標籤：Python

上一篇：關于Maven的 install 和打包

下一篇：多道技術、同步異步和阻塞非阻塞

面向物件