面向對象編程（Object Oriented Programming–OOP）是把對象 作爲程序的基本單元，一個對象包含了數據和操作數據的函數。

面向過程的程序設計把計算機程序視爲一系列的命令集合，即一組函數的順序執行。面向過程把函數繼續切分爲子函數，即把大塊函數通過切割成小塊函數來降低系統的複雜度。(通過定義一組組函數來實現降低複雜度的目的)

面向對象的程序設計把計算機程序視爲一組對象的集合，而每個對象都可以接收其他對象發過來的消息，並處理這些消息，計算機程序的執行就是一系列消息在各個對象之間傳遞。

在Python中，所有數據類型都可以視爲對象，當然也可以自定義對象。自定義的對象數據類型就是面向對象中的類（Class）的概念。

我們以一個例子來說明面向過程和麪向對象在程序流程上的不同之處。

例：假設我們要處理學生的成績表，爲了表示一個學生的成績，面向過程的程序可以用一個dict表示：

std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }

而處理學生成績可以通過函數實現，比如打印學生的成績：

def print_score(std):
    print('%s: %s' % (std['name'], std['score']))

如果採用面向對象的程序設計思想，我們首選思考的不是程序的執行流程，而是Student這種數據類型應該被視爲一個對象，這個對象擁有name和score這兩個屬性（Property）。如果要打印一個學生的成績，首先必須創建出這個學生對應的對象，然後，給對象發一個print_score消息，讓對象自己把自己的數據打印出來。

class Student(object):  #定義一個Student對象

    def __init__(self, name, score):  #擁有name和score兩個屬性
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score)) #打印出數據

給對象發消息實際上就是調用對象對應的關聯函數，我們稱之爲對象的方法（Method）。面向對象的程序寫出來就像這樣：

#調用對象關聯的程序
bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()

面向對象的設計思想是從自然界中來的，因爲在自然界中，類（Class）和實例（Instance）的概念是很自然的。Class是一種抽象概念，比如我們定義的Class——Student，是指學生這個概念，而實例（Instance）則是一個個具體的Student，比如，Bart Simpson和Lisa Simpson是兩個具體的Student。

偶然看到一個關於類與實例的比較，感覺豁然開朗(嘿嘿嘿,猥瑣臉^_^)：
把類想象成爲AV女優，一個抽象的職業，把實例想象成爲蒼老師，一個活生生的人，當你想lu的時候腦海會自動創建一個名字爲‘蒼井空’的AV女優實例，而不可能只想着AV女優這四個字來lu。這就是實例化對象的過程。

所以，面向對象的設計思想是抽象出Class，根據Class創建Instance。

面向對象的抽象程度又比函數要高，因爲一個Class既包含數據，又包含操作數據的方法。

類和實例

面向對象最重要的概念就是類（Class）和實例（Instance），必須牢記類是抽象的模板(女優這個職業)，比如Student類，而實例是根據類創建出來的一個個具體的“對象”（蒼井空這個人），每個對象都擁有相同的方法，但各自的數據可能不同。

仍以Student類爲例，在Python中，定義類是通過class關鍵字：

class Student(object):  #class後面緊接着是類名，即Student，類名通常是大寫開頭的單詞,
#緊接着是(object)，表示該類是從哪個類繼承下來的，
#通常，如果沒有合適的繼承類，就使用object類，這是所有類最終都會繼承的類。
    pass

定義好了Student類，就可以根據Student類創建出Student的實例，創建實例是通過類名+()實現（比如Student()）的：

>>> bart = Student()
>>> bart
<__main__.Student object at 0x10a67a590> #變量bart指向的就是一個Student的實例，
#後面的0x10a67a590是內存地址，每個object的地址都不一樣
>>> Student
<class '__main__.Student'> #Student是一個類

可以自由地給一個實例變量綁定屬性，比如，給實例bart綁定一個name屬性：

>>> bart.name = 'Bart Simpson'
>>> bart.name
'Bart Simpson'

由於類可以起到模板的作用，因此，可以在創建實例的時候，把一些我們認爲必須綁定的屬性強制填寫進去。通過定義一個特殊的__init__方法，在創建實例的時候，就把name，score等屬性綁上去：

class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score

__init__方法的第一個參數永遠是self，表示創建的實例本身，因此，在__init__方法內部，就可以把各種屬性綁定到self，因爲self就指向創建的實例本身。

有了__init__方法，在創建實例的時候，就不能傳入空的參數了，必須傳入與__init__方法匹配的參數，但self不需要傳，Python解釋器自己會把實例變量傳進去：

>>> bart = Student('Bart Simpson', 59) #'Bart Simpson'對應name參數，59對應score參數
>>> bart.name
'Bart Simpson'
>>> bart.score
59

Note：
和普通的函數相比，在類中定義的函數只有一點不同，就是第一個參數永遠是實例變量self，並且，調用時，不用傳遞該參數。除此之外，類的方法和普通函數沒有什麼區別，所以，你仍然可以用默認參數、可變參數、關鍵字參數和命名關鍵字參數。

數據封裝

面向對象編程的一個重要特點就是數據封裝。在上面的Student類中，每個實例就擁有各自的name和score這些數據。我們可以通過函數來訪問這些數據，比如打印一個學生的成績：

>>> def print_score(std): #定義一個打印學生成績的函數
...     print('%s: %s' % (std.name, std.score))
...
>>> print_score(bart) #通過函數訪問這些數據
Bart Simpson: 59 #打印結果%s：%s

但是，既然Student實例本身就擁有這些數據，要訪問這些數據，就沒有必要從外面的函數去訪問，可以直接在Student類的內部定義訪問數據的函數，這樣，就把“數據”給封裝起來了。這些封裝數據的函數是和Student類本身是關聯起來的，我們稱之爲類的方法：數據封裝就是在類的內部完成對訪問數據函數的定義，下面例子中的def print_score(self):就不需要從外面的函數去訪問了，可以看做把函數封裝在類裏面，如同一個黑盒，不用知道里面具體的內容，只需要知道索要實現的功能即可

class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

要定義一個方法，除了第一個參數是self外，其他和普通函數一樣。要調用一個方法，只需要在實例變量上直接調用，除了self不用傳遞，其他參數正常傳入：

>>> bart.print_score()
Bart Simpson: 59

這樣一來，我們從外部看Student類，就只需要知道，創建實例需要給出name和score，而如何打印，都是在Student類的內部定義的，這些數據和邏輯被“封裝”起來了，調用很容易，但卻不用知道內部實現的細節。

封裝的另一個好處是可以給Student類增加新的方法，比如get_grade：

class Student(object):
    ...

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

同樣的，get_grade方法可以直接在實例變量上調用，不需要知道內部實現細節：

>>> bart.get_grade()
'C'

小結

類是創建實例的模板（職業），而實例則是一個一個具體的對象（蒼老師），各個實例擁有的數據都互相獨立（蒼老師與波多老師是相互獨立的），互不影響；

方法就是與實例綁定的函數，和普通函數不同，方法可以直接訪問實例的數據；（調用對象關聯的函數）

通過在實例上調用方法，我們就直接操作了對象內部的數據，但無需知道方法內部的實現細節。

和靜態語言不同，Python允許對實例變量綁定任何數據，也就是說，對於兩個實例變量，雖然它們都是同一個類的不同實例，但擁有的變量名稱都可能不同：

>>> bart = Student('Bart Simpson', 59)
>>> lisa = Student('Lisa Simpson', 87)
>>> bart.age = 8
>>> bart.age
8
>>> lisa.age
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

類和實例示例

代碼:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)

print('bart.name =', bart.name)
print('bart.score =', bart.score)
bart.print_score()

print('grade of Bart:', bart.get_grade())
print('grade of Lisa:', lisa.get_grade())

運行結果:

bart.name = Bart Simpson
bart.score = 59
Bart Simpson: 59
grade of Bart: C
grade of Lisa: B

訪問限制

在Class內部，可以有屬性和方法，而外部代碼可以通過直接調用實例變量的方法來操作數據，這樣，就隱藏了內部的複雜邏輯。

但是，從前面Student類的定義來看，外部代碼還是可以自由地修改一個實例的name、score屬性：

>>> bart = Student('Bart Simpson', 98)
>>> bart.score
98
>>> bart.score = 59
>>> bart.score
59

如果要讓內部屬性不被外部訪問，可以把屬性的名稱前加上兩個下劃線__，在Python中，實例的變量名如果以__開頭，就變成了一個私有變量（private），只有內部可以訪問，外部不能訪問，所以，我們把Student類改一改：

class Student(object):

    def __init__(self, name, score):
        self.__name = name   ##__開頭變量表示私有變量
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

改完後，對於外部代碼來說，沒什麼變動，但是已經無法從外部訪問實例變量.__name和實例變量__score了：

>>> bart = Student('Bart Simpson', 98)
>>> bart.__name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'

這樣就確保了外部代碼不能隨意修改對象內部的狀態，這樣通過訪問限制的保護，代碼更加健壯。

但是如果外部代碼要獲取name和score怎麼辦？可以給Student類增加get_name和get_score這樣的方法：

class Student(object):
    ...

    def get_name(self):  
        return self.__name  ##外部代碼想要獲取類內部的數據方法

    def get_score(self):
        return self.__score

如果又要允許外部代碼修改score怎麼辦？可以再給Student類增加set_score方法：

class Student(object):
    ...

    def set_score(self, score):
        self.__score = score  #外部代碼想要修改類內部變量的方法

你也許會問，原先那種直接通過bart.score = 59也可以修改啊，爲什麼要定義一個方法大費周折？因爲在方法中，可以對參數做檢查，避免傳入無效的參數：

class Student(object):
    ...

    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')

NOTE:
需要注意的是，在Python中，變量名類似__xxx__的，也就是以雙下劃線開頭，並且以雙下劃線結尾的，是特殊變量，特殊變量是可以直接訪問的，不是private變量，所以，不能用__name__、__score__這樣的變量名。

一個下劃線開頭的實例變量名，比如_name，表示這樣的實例變量外部是可以訪問的，但是，按照約定俗成的規定，當你看到這樣的變量時，意思就是，“雖然我可以被訪問，但是，請把我視爲私有變量，不要隨意訪問”。

雙下劃線開頭的實例變量是不是一定不能從外部訪問呢？其實也不是。不能直接訪問__name是因爲Python解釋器對外把__name變量改成了_Student__name，所以，仍然可以通過_Student__name來訪問__name變量：

>>> bart._Student__name
'Bart Simpson'

但是強烈建議你不要這麼幹，因爲不同版本的Python解釋器可能會把__name改成不同的變量名。

總的來說就是，Python本身沒有任何機制阻止你幹壞事，一切全靠自覺。

最後注意下面的這種錯誤寫法：

>>> bart = Student('Bart Simpson', 98)
>>> bart.get_name()
'Bart Simpson'
>>> bart.__name = 'New Name' # 設置__name變量！
>>> bart.__name
'New Name'

表面上看，外部代碼“成功”地設置了__name變量，但實際上這個__name變量和class內部的__name變量不是一個變量! 內部的__name變量已經被Python解釋器自動改成了_Student__name，而外部代碼給bart新增了一個__name變量。不信試試：

>>> bart.get_name() # get_name()內部返回self.__name
'Bart Simpson'

訪問限制示例

代碼:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')

    def get_grade(self):
        if self.__score >= 90:
            return 'A'
        elif self.__score >= 60:
            return 'B'
        else:
            return 'C'

bart = Student('Bart Simpson', 59)
print('bart.get_name() =', bart.get_name())
bart.set_score(60)
print('bart.get_score() =', bart.get_score())

print('DO NOT use bart._Student__name:', bart._Student__name)

運行結果:

bart.get_name() = Bart Simpson
bart.get_score() = 60
DO NOT use bart._Student__name: Bart Simpson

參考1
參考2

Python面向對象的編程筆記

類和實例

數據封裝

小結

類和實例示例

訪問限制

訪問限制示例

Nginx R31 doc 官方文檔-01-nginx 如何安裝

Qt/C++音視頻開發74-合併標籤圖形/生成yolo運算結果圖形/文字和圖形合併成一個/水印濾鏡

挑戰程序設計競賽 2.2章習題 POJ - 3617 Best Cow Line 貪心

字節面試：MySQL什麼時候鎖表？如何防止鎖表？

.NET8連接SQL SERVER 2008 R2 報：證書鏈是由不受信任的頒發機構頒發的

golang開發環境搭建(win10)

python計算機視覺學習筆記——PIL庫的用法

Golang初學：獲取程序內存使用情況，std runtime

排序和查找算法--C

Apache Hadoop2.8.0僞分佈式環境搭建

函數和多維數組--c/c++

Ubuntu搭建FTP文件服務

大數據時代下的隱私保護

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結