1. 面向物件

python是一門面型物件的的編程語言，所謂面向物件，簡單地來理解就是語言中所有的操作都是通過物件來進行的，
使用面向物件的編程語言，我們關注的是物件，而不注重程序；對于面向物件，一切皆物件，

比如“對于如何把大象放進冰箱這個問題”，在面向物件編程中，我們只需要考慮大象和冰箱兩個物件就足夠了，然后步驟如下：①打開冰箱，②把大象放進去，③關上冰箱門，至于怎么放進去的，這不是我們關注的重點，
因為冰箱和大象兩個物件所持有的屬性和方法，或者說是我們通過呼叫封裝好的函式，足以滿足我們的需求，甚至python也許就已經存在過了形如：

def 把大象放冰箱() :
      bulabulabula...
      return('已經放進去了，') 

的函式，我們只要找到大象和冰箱兩個引數，然后直接呼叫就可以把問題解決了，而我們不用過于關心這個函式是怎么執行的，

與之相對的另一種編程思想，即面向程序，這個問題在面向程序的編程語言中，我們則會將程式分解為一個一個的步驟，通過對每個步驟的抽象來完成程式，面向程序的方式更符合人類的思維，撰寫起來比較容易，

面向物件的編程思想，將所有的功能都保存到對應的變數中，在python中，你想使用一個東西，你必須先創建一個這樣的物件，要使用某個功能，直接找到對應的物件即可，這種編碼方式比較容易閱讀，并且易于維護，容易復用，但是撰寫程序不太符合常規思維，撰寫相對麻煩，
(比如對于一個第三方庫模塊匯入的函式物件，你如果不了解其功能或使用方法，你的編程就很難繼續，同時面向物件編程也是因為這些復雜的函式物件的組合才顯得更方便更強大，)

2. 類

2.1 類的概述

python的內置物件并不都能滿足我們的需求，所以我們在開發中經常要自定義一些物件，類可以簡單理解為是一張圖紙，是物件的圖紙，在程式中我們需要根據類來創建物件，
比如我們用list()函式創建出一個串列，用tuple()函式創建出一個元組，這些都是在python內置庫中已經定義好的內置物件，所以我們才能直接使用，而不能單純的理解為這是平臺的設定，
我們也稱物件為類的實體(instance)，如果多個物件是通過一個類來創建的，我們就成這些物件是一類物件，
此外，類本身也就是一個物件，類是用來創建物件的物件，

2.2 類的定義

# 語法
class MyClass():  # 定義一個類，類名命名為MyClass，也即創建了一個類物件，
	pass

mc = MyClass()  # 創建一個實體物件（類的實體化）
mc1 = MyClass()

類和物件都是對我們生活中現實事物的抽象

• isinstance() 用來檢測實體物件是否是由給定類物件創建出來的

print(isinstance(mc, MyClass))

輸出結果：

2.3 屬性和方法

2.3.1 小引

• 一個物件可以分為兩部分：①屬性②方法
• 在類代碼快中，我們可以定義變數和函式：
  變數會成為該類實體的公共屬性，所有的該類的實體都可以通過 物件.屬性名的形式訪問，
  函式會成為該類實體的公共方法，所有的該類的實體都可以通過 物件.方法名的形式訪問，

2.3.2 屬性

• 類物件是可以添加屬性的，語法為：物件.屬性名 = 屬性值，
• id和type是每個物件自帶的屬性，即存盤，物件一被創建，就有id和type屬性，

print(id(mc), id(mc1))

輸出結果如下：

print(type(mc))

輸出結果如下：

2.3.3 方法

• 呼叫方法語法：物件.方法名()
• 方法呼叫 和 函式呼叫 的區別：
  如果是函式呼叫，呼叫的時候有幾個形參，就會傳入幾個實參，
  如果是方法呼叫，默認傳遞一個引數，所以方法中至少得有一個形參，

2.4 self引數

• self 在定義的時候需要定義，但是在呼叫時會自動傳入，
• self 的名字并不是規定死的，但是是約定俗成的，所以一般最好使用self，而不是別的，
• self總是指呼叫時類的實體，

現舉代碼實體如下：

class Person():
    name = '張三'
    age = 18
    identity = '學生'

    def speak(self):  # self就等于任何呼叫我這個方法的物件本身
        print('你好，我是{},{}歲的{}'.format(self.name, self.age, self.identity))

p1 = Person()

p1.name = "馬保國"
p1.age = 65
p1.identity = '老同志'
p1.speak()

輸出結果：

3. 特殊方法

在類中可以定義一些形如__xxx__的方法，稱為特殊方法，也稱魔術方法，特殊方法不需要我們呼叫，會在特定的時候自動呼叫，

• 掌握下邊這種定義類寫法，方可實作在創建類的實體物件的時候直接傳入屬性，

class Person():
    name = '張三'
    age = 18
    identity = '學生'
    
	# 特殊方法 __init__，類的物件被創建時， __init__就會被呼叫
    def __init__(self, name, age, identity):  
        self.name = name
        self.age = age
        self.identity = identity
        print('hello')    # 實體物件一被創建，"hello"就被輸出，
    # 這樣寫，再創建類的物件的時候，name和age都將成為必傳引數，缺少則 __init__會無法運行，導致報錯，
    # 這里不能用不定長引數，那樣沒有任何意義，
    
    def speak(self):  # self就等于任何呼叫我這個方法的物件本身
        print('你好，我是{},{}歲的{}'.format(self.name, self.age, self.identity))

p1 = Person("馬保國", 65,"老同志")
p1.speak()

4.封裝

4.1封裝，私有屬性，隱藏屬性

封裝是面向物件三大特征之一，我們需要一種方式來增強資料的安全性，這種方式就是封裝，
封裝是指隱藏物件中一些不希望被外部訪問到的屬性或方法，具體方式為，在屬性名前加入一個下劃線，表示不可直接訪問，但仍可手動訪問，只是提醒不可修改；在屬性名前加兩個下劃線表示隱藏屬性，

示例：

class Person():
    
    def __init__(self, name, age, identity):  
        self.name = name
        self._age = age
        self.__identity = identity
# 這樣寫，再創建類的物件的時候，name和age都將成為必傳引數，缺少則 __init__會無法運行，導致報錯，      # 這里不能用不定長引數，那樣沒有任何意義，
    
    def speak(self):  # self就等于任何呼叫我這個方法的物件本身
        print('你好，我是{},{}歲的{}'.format(self.name, self._age, self.__identity))
p1 = Person("馬保國", 65,"老同志")
print(p1.name)
print(p1.age)
print(p1.identity)

運行結果如下：

我們可以看到，name依然可以直接訪問，但是前邊加了一個下劃線的age和加了兩個下劃線的identity屬性已經不能直接訪問了，

• 對于前邊加了一個下劃線的屬性age，我們使用p1._age的方式依然可以訪問age屬性的，
  
  但是對于前邊加了兩個下劃線的屬性identity，我們卻不能再使用p1.__identity來訪問了，否則會有如下報錯，
  
• 但是對于這樣的屬性，并不是沒有辦法訪問，
  我們可以使用固定語法：_類名__屬性名 的形式進行訪問，
  如 p1._Person__identity
  （類名前加一個下劃線，類名與屬性名之間加了兩個下劃線）
  即:
  
  這樣就訪問成功了，
• 該如何解釋這一系列情況呢？
  可以這樣來理解，
• 一般情況下，加_的都是私有屬性，沒有特殊情況下不要修改私有屬性，封裝就是這樣保障資料安全的，這種”不要修改“是一種約定俗成，不意味著不能修改，只是對編程者的一種提醒，畢竟所有的屬性，只要你想修改，都還是受人為控制的，
• 加一個_后，只是相當于傳入屬性值后，把原先的屬性名前加了一個下劃線，故可以通過“_屬性名”的形式訪問，
• 而對于加了__(兩個下劃線)的隱藏屬性，本質上只不過是Python自動為屬性改了一個名字，即 _類名__屬性名 ，這樣我們就常常把它描述為“私有屬性不能通過物件來獲取，只能在類的內部訪問，” （一句常見的概述）但是，上邊的例子我們也看到了，使用p1._Person_identity的方式確實可以說是通過物件訪問到了屬性值，但是這句話本身是沒有問題的，之所以這么說，就是我們對于封裝這一概念的一種認同與使用，我們約定俗成不亂操作封裝過的屬性值，以保障資料安全，我們只是不再可以通過原來的物件名字來獲取該物件了，
• 協定開發我們一般使用私有屬性(一個下劃線)，而一般不用隱藏屬性，

4.2 getter()與setter()

我們也可以給類提供上getter()和setter()方法
getter() 用于獲取物件中指定的屬性
setter() 用于設定物件中的屬性
示例如下：

class Person():
    
    def __init__(self, name, age, identity):  
        self.name = name
        self.__age = age
        self._identity = identity
    
    # getter方法  提供給你訪問這個屬性的方法  # 協定開發一般用 私有屬性
    def get_identity(self):
        return self._identity
    
    # setter方法  提供給你修改這個屬性的方法
    def set_identity(self, identity):
        self._identity = identity
    
    def speak(self):  
        print('你好，我是{},{}歲的{}'.format(self.name, self.__age, self._identity))

# 逐句輸入下邊代碼，觀察結果，以感受其用法邏輯，
p1 = Person("馬保國", 65,"老同志")
p1.get_identity()
p1.speak()
p1.set_identity('武林高手')
p1.get_identity()
p1.speak()

結果展示如下：

• 增加getter()和setter()方法，可以很好地控制屬性是否是只讀的，

5. property裝飾器

我們可以用@property裝飾器來創建只讀屬性，@property裝飾器會將方法轉換為相同名稱的只讀屬性，可以與所定義的屬性配合使用，這樣可以防止屬性被修改，
具體示例如下：

class Person():
    
    # 這里，name屬性是私有屬性，不可讀也不可改
    def __init__(self, name):  
        self._name = name 
    
    # getter方法  提供給你訪問這個屬性的方法
    @property
    def name(self):
        return self._name
    # 這樣，name屬性就轉為了只讀，不可改，可以通過相同名稱的方法：name來查看name屬性，
	
	# 如果想再把不可改的屬性改為可改屬性，則：
    # setter方法  提供給你修改這個屬性的方法
    @name.setter
    def name(self, name):
        self._name = name

# 下邊 逐句進行測驗
p1 = Person('馬保國')
print(p1.name)    # 可以通過p1.name 讀取name屬性了，
p1.name = '蔡徐坤'  # 可以這樣修改p1的name屬性了， 
print(p1.name) # name屬性已被更改

6. 繼承

6.1 繼承概述 與 object類

繼承也是面向物件的三大特征之一，通過繼承我們可以使一個類獲取到其他類中的屬性和方法，
在定義類的時候，可以在類名后邊的括號中指定當前類的父類，
繼承提高了類的復用性，讓類與類之間有了關系，有了這個關系，才有了多型的特性，

# 定義一個父類
class Person(object):  
    def __init__(self, name):  
        self.name = name
# 定義一個子類
class boy(Person):
	def speak(self):
		print('He has a dream.')
# 這就實作了一個簡單的類的繼承，

# issubclass()方法 用于檢測一個類是否是一個類的父類
print(issubclass(boy, Person))    # True
print(issubclass(Person, object))   # True

對于父類，或者說是不繼承其他類的獨立的類，定義的時候我們約定俗成繼承object這個類，object類中有很多高級特性可以使用，不過即使不傳入object也沒有關系，我們創建類的時候python3已經默認幫我們傳入了object，object類是所有類中最大的父類，
對于子類，則必須要在其括號中填入要繼承的父類，

6.2 方法重寫

• 方法重寫要建立在繼承的基礎之上，

• 如果在子類中有和父類同名的方法，則通過子類實體物件區呼叫方法時，會呼叫的是子類的方法，而不是父類的方法，這個特點我們稱之為方法的重寫（覆寫），

• 當我們呼叫一個物件的方法時，會優先在當前物件的類中尋找，有則直接呼叫，沒有則去當前物件的類的父類中尋找，有則呼叫，沒有則繼續往上邊的父類中尋找，以此類推，直到找到object類，如果還沒有就報錯了，

可以通過這段示例代碼來體會其邏輯：

class A(object):
    name = 'A'

    def test(self):
        print('A.....')

class B(A):
    def test(self):
        print('B,...')

class C(B):
    pass

c = C()
# 逐句測驗
c.test()
print(c.name)

6.3 super()方法

• super這個方法的使用時建立在兩個基礎之上的

1. 必須要有父類的繼承
2. 必須要有方法的重寫

super()方法可以獲取到當前類的父類的方法，且通過super()方法回傳物件呼叫父類方法時，不需要呼叫self，

class A():    # 默認繼承object
    def test(self):
        print('A.....')
class B(A):
    def test(self):
        print('B,...')
    # super的作用： 將被覆寫了的父類方法，重新呼叫
    def test2(self):
        super().test()

# 進行逐行測驗
b = B()
b.test()
b.test2()

結果如下：

這樣，就既能使用子類中的test方法，也能呼叫父類中的test方法了，

6.4 多重繼承

• python是支持多重繼承的，也就是說我們可以為一個類同時指定多個父類，只要在子類后邊的括號里添加多個類即可實作多重繼承，
• 多重繼承可以使子類同時擁有多個父類，并且會獲取到所有父類中的方法，如果遇到呼叫父類中的同名方法，則按照括號內傳入的順序，會先在第一個父類中尋找，然后是第二個，第三個…以此類推，前邊的會覆寫后便的，
• 在開發者如果沒有特殊要求，應盡量避免使用多重繼承，多重繼承會使得我們的代碼更加復雜，

簡要寫法示例：

class A():    
    def test(self):
        print('A.....')
class B():
    def test(self):
        print('B.....')
class C(A, B):    # 這樣就實作了C類對A類和B類的多重繼承，
	def speak(self):
		print('A和B都是我爹，')

# 呼叫test方法的話,按先后順序會呼叫A中的，B中的test()方法會被覆寫，
c = C()
c.test()

輸出結果：

7. 多型

多型是面向物件三大特性之一，從字面來理解，就是指多種形態，
python中多型的特點：

1. python中的多型只關心物件的實體方法是否同名，不關心物件所屬的型別，
2. 物件所屬的類之間，繼承關系也是可有可無的，
3. 多型可以增加代碼外部呼叫的靈活度，讓代碼更通用，兼容性比較強，
4. 多型是呼叫方法的技巧，不會影響到類的內部設計，

代碼示例如下：

class A():    
    def test(self):
        print('A.....')
class B():
    def test(self):
        print('B.....')
class C():
	def test(self):
		print('C.....')

def test(obj):
    obj.test()

a = A()
b = B()
c = C()

a.test()
b.test()
c.test()

8. 屬性和方法

8.1 屬性

• 類屬性: 直接在類中定義的屬性是類屬性，
  類屬性可以通過類或類的示例訪問到，但是類屬性只能通過類物件來修改，無法通過實體物件修改，
• 實體屬性: 通過示例物件添加的屬性屬于實體屬性，
  實體屬性只能通過實體物件來訪問和修改，類物件無法訪問修改，

示例：

class A():
	num = 0    # 這個屬性就是類屬性，無法通過實體物件更改    
    def __init__(self, name):
        self.name = name   # 這個屬性即是實體屬性
        print(self)

8.2 方法:

8.2.1 實體方法

• 在類的定義中，以self為第一個引數的方法都是實體方法，實體方法呼叫的時候，python會將呼叫物件以self傳入，
• 實體方法可以通過實體和類去呼叫，
  當通過實體呼叫時，會自動將當前呼叫物件以self傳入，
  當通過類呼叫時，不會自動傳遞self，我們必須手動傳遞self，

8.2.2 類方法

• 類方法 在類的內容中，以 @classmethod 來修飾的方法就是類方法，類方法的第一個引數是cls，即當前類物件，會被自動傳遞(這一點類似self)，即可以說：第一個引數是cls的方法是類方法，這也是類方法與實體方法的不同之處，
• 類方法可以通過類去呼叫，也可以通過實體呼叫，

示例：

class A():
    
    def __init__(self, name):
        self.name = name  
        print(self)
    
    def speak(self):  # 實體方法
        print('大家好，我是%s' % self.name)

    @classmethod     # 類方法
    def run(cls):
        print('我會唱、跳、rap、籃球，')
 

a = A('張三') # 創建實體物件
a.speak()  # 實體呼叫實體方法
A.speak(a)  # 類呼叫實體方法，需要傳入手動傳入實體物件
a.run()      # 實體呼叫類方法
A.run()      # 類呼叫類方法

8.2.3 靜態方法

• 在類中用**@staticmethod**來修飾的方法屬于靜態方法，
• 靜態方法不需要指定任何默認引數，靜態方法可以通過類和實體呼叫，
• 靜態方法基本上是一個與當前類無關的方法，只是一個保存在當前類中的函式，是工具方法，

示例如下：

class A():
    @staticmethod
    def static():     # 功能方法，工具方法
        print('我是靜態方法')

9.單例模式

9.1 __new()__方法

__new__方法用于創建和回傳一個物件，在類準備將自身實體化是呼叫，

class A():
	def __new__(self):
		print('實體物件創建好了，')
a = A()

9.2 單例模式的實作

• 單例模式是一種常用的軟體設計模式，也就是說該類只包含一個實體，通過通過單例模式可以保證系統中一個類只有一個實體而且該實體易于外界訪問，從而方便對實體個數的控制并節約系統資源，
  通常在一些資源管理器中，比如日志記錄等，

• 實作思路：
  當物件不存在時，創建物件；
  當物件存在時，永久回傳當前已創建的物件，

代碼示例：

class Single(object):
    obj = None

    def __new__(cls, *args, **kwargs):
        if cls.obj is None:
            cls.obj = super().__new__(cls)
            return cls.obj
        else:
            return cls.obj
# 這里也用到了，通過類物件的內部方法來修改類屬性obj的思想，

s = Single()
s1 = Single()
print(id(s))
print(id(s1))

從結果我們可以看出，s和s1的id相同，即s和s1是同一個物件，
其內在邏輯是這樣的：
我們創建s物件的時候，類屬性obj默認為None, if條件成立，所以通過父類中的__new__方法，以cls(Single類)為實體物件名，創建了一個父類object的實體物件，然后把這個實體物件賦值給Single類的obj屬性，第二次再創建s1實體物件的時候，Single的obj屬性就不再是None了，即i條件f不再成立，所以就直接回傳非None的cls.obj，

感謝大家的訪問與支持，您的支持將是博主堅持更新的最大動力！如果博主的文章對您的學習能夠有所幫助，別忘了小手指點一下界面的 收藏+關注，更多精彩內容敬請關注！