一、 面向過程編程語言

“面向過程”(Procedure Oriented)是一種以過程為中心的編程思想。分析出解決問題所需要的步
驟，然后用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就可以了。

面向對象的方法也是含有面向過程的思想。面向過程最重要的是模塊化的思想方
法。比如拿學生早上起來這件事說明面向過程，粗略的可以將過程擬為：
(1)起床
(2)穿衣
(3)洗臉刷牙
(4)去學校
而這4步就是一步一步地完成，它的順序很重要，你只需要一個一個地實現就行了。
而如果是用面向對象的方法的話，可能就只抽象出一個學生的類，它包括這四個
方法，但是具體的順序就不一定按照原來的順序。

• 特性：
  模塊化 流程化
• 優點：
  性能比面向對象高, 因為類調用時需要實例化，開銷比較大，比較消耗資源;
  單片機、嵌入式開發、Linux/Unix等一般采用面向過程開發，性能是最重要的因素。
• 缺點：
  沒有面向對象易維護、易復用、易擴展

二、 函數式編程語言

函數式編程是種編程方式，它將電腦運算視為函數的計算。函數編程語言最重要的基礎是λ
演算（lambda calculus），而且λ演算的函數可以接受函數當作輸入（參數）和輸出（返回值）。
主要思想: 把運算過程盡量寫成一系列嵌套的函數調用。

三、面向對象編程語言

面向對象是按人們認識客觀世界的系統思維方式，把構成問題事務分解成各個對象，建立對
象的目的不是為了完成一個步驟，而是為了描敘某個事物在整個解決問題的步驟中的行為。

• 特性： 抽象 封裝 繼承 多態
• 優點： 易維護、易復用、易擴展，由于面向對象有封裝、繼承、多態性的特性，
  可以設計出低耦合 的系統，使系統更加靈活、更加易于維護
• 缺點： 性能比面向過程低

1 . 類和對象

• 類（Class）是現實或思維世界中的實體在計算機中的反映，它將數據以及這些數
  據上的操作封裝在一起。
• 對象(Object)是具有類類型的變量。類和對象是面向對象編程技術中的最基本的概
  念

如何定義類? class 類(): pass

如何將類轉換成對象?
實例化是指在面向對象的編程中，把用類創建對象的過程稱為實例化。是將一個抽象的概
念類，具體到該類實物的過程。實例化過程中一般由類名 對象名 = 類名（參數1，參數2…參數n）
構成。

# 類（Class） class Cat:# 屬性:一般是名詞，eg：name,age,gender....name = 'name'kind = 'kind'# 方法：一般情況是動詞，eg:create,delete,eating,run...def eat(self):print('cat like eating fish...') #對象（Object）:對類得實例化（具體化） jiongjiong = Cat()print(Cat) #<class '__main__.Cat'> print(jiongjiong) #<__main__.Cat object at 0x000001E5D1684B50>

類（Class）是是創建實例的模板
對象(Object)是一個一個具體的實例

2 . 封裝特性

面向對象的三大特性是指：封裝、繼承和多態

(1)封裝，顧名思義就是將內容封裝到某個地方，以后再去調用被封裝在某處的內容。
所以，在使用面向對象的封裝特性時，需要：
1). 將內容封裝到某處
2). 從某處調用被封裝的內容
1). 通過對象直接調用被封裝的內容： 對象.屬性名
2). 通過self間接調用被封裝的內容： self.屬性名
3). 通過self間接調用被封裝的內容: self.方法名()

構造方法__init__與其他普通方法不同的地方在于，當一個對象被創建后，會立即調
用構造方法。自動執行構造方法里面的內容。
對于面向對象的封裝來說，其實就是使用構造方法將內容封裝到 對象 中，然后通過
對象直接或者self間接獲取被封裝的內容。

# 類(Class) class Cat:def __init__(self, name, kind): # 形參"""1. 構造方法，實例化對象時自動執行的方法2. self是什么? self實質上是實例化的對象3. 類方法中, python解釋器會自動把對象作為參數傳給self"""print('正在執行__init__構造方法')print('self:', self)# 屬性：一般是名詞，eg: name, age, gender.....# 封裝: self.name將對象和name屬性封裝/綁定self.name = nameself.kind = kind# 方法: 一般情況是動詞, eg: create, delete, eating, run......def eat(self):print('cat %s like eating fish.....' %(self.name))# 對象(Object):對類的實例化(具體化) jiongjiong = Cat("囧囧", "美短虎斑") print(jiongjiong.name) print(jiongjiong.kind) jiongjiong.eat()

代碼運行結果：

創建一個類People,擁有的屬性為姓名， 性別和年齡， 擁有的方法為購物,玩游戲,學習;實例化
對象,執行相應的方法。 顯示如下:
小明,18歲,男,去西安賽格購物廣場購物
小王,20歲,男,去西安賽格購物廣場購物
小紅,22歲,女,在西部開源學習
提示:
屬性:name,age,gender
方法:shopping(), playGame(), learning()

""" 創建一個類People,擁有的屬性為姓名， 性別和年齡， 擁有的方法為購物,玩游戲,學習;實例化 對象,執行相應的方法。 顯示如下: 小明,18歲,男,去西安賽格購物廣場購物 小王,20歲,男,去西安賽格購物廣場購物 小紅,22歲,女,在西部開源學習 提示: 屬性:name,age,gender 方法:shopping(), playGame(), learning() """ class People:def __init__(self,name,age,gender):self.name = nameself.age = ageself.gender = genderdef shopping(self):print(f'{self.name},{self.age}歲，{self.gender}，去西安賽格購物廣場購物')def learning(self):print(f'{self.name},{self.age}歲,{self.gender},在西部開源學習') p1 = People('小明','18','男') p2 = People('小王','20','男') p3 = People('小紅','22','女')p1.shopping() p2.shopping() p3.learning()

代碼運行結果：

3 . 繼承特性

面向對象的三大特性是指：封裝、繼承和多態

繼承

多繼承

私有屬性與私有方法

繼承描述的是事物之間的所屬關系,當我們定義一個class的時候,可以從某個現有的class繼承,新的class稱為子類、擴展類(Subclass),而被繼承的class稱為基類、父類或超類(Baseclass、
Superclass)。

• 問題一: 如何讓實現繼承?
  子類在繼承的時候,在定義類時,小括號()中為父類的名字
• 問題二: 繼承的工作機制是什么?
  父類的屬性、方法,會被繼承給子類。 舉例如下: 如果子類沒有定義__init__方法,父類有,那么在子類繼承父類的時候這個方法就被繼承了,所以只要創建對象,就默認執行了那個繼承過來的__init__方法

class Student:def __init__(self,name,age):self.name = nameself.age = agedef learning(self):print(f'{self.name}正在學習') class MathStudent(Student):"""MathStudent的父類是student"""pass#實例化 m1 = MathStudent('華羅庚',88) print(m1.name) print(m1.age) m1.learning() #子類沒有就會去父類找 # m1.choice_course() #子類和父類都沒有就會報錯

代碼運行結果：

4 . 重寫父類方法

就是子類中,有一個和父類相同名字的方法,在子類中的方法會覆蓋掉父類中同名的方法。

class Student:def __init__(self,name,age):self.name = nameself.age = agedef learning(self):print(f'{self.name}正在學習')def choice_course(self):print('正在選課中'.center(50,'*'))class MathStudent(Student):"""MathStudent的父類是student"""def choice_course(self):# 需求：先執行父類的方法choice_course，再個性化執行自己的方法#Student.choice_course(self) #方法1：直接執行父類的方法，但不建議#方法2：通過super找到父類的方法，再執行（）中的。super(MathStudent,self).choice_course()info = """課程表1. 高數2. 線性代數3. 概率論"""print(info)#實例化 m1 = MathStudent('華羅庚',88) m1.choice_course()

代碼運行結果：

5 . 練習

兩數相加力扣網址

直接在力扣上做,代碼如下：

#Definition for singly-linked list. # class ListNode: # def __init__(self, val=0, next=None): # self.val = val # self.next = next class Solution:def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:res = 0l3 = ListNode()cur = l3while(l1 or l2):if(l1):res += l1.val # res=2l1 = l1.nextif(l2):res += l2.val # res=2+5=7l2 = l2.next# res=10, val=0, res=>val val=res%10# res=14, val=4, 14%10=4l3.next = ListNode(res%10)l3 = l3.next# res=10, 進位為1， 10//10=1# res=14, 進位為1， 14//10=1res //= 10if res == 1:l3.next = ListNode(1)return cur.next

6 . 鏈表的封裝

""" 參考鏈接 https://www.cnblogs.com/klyjb/p/11237361.html 數組: 需要連續的內存空間 鏈表: 不需要連續的內存空間數組 鏈表 增加元素 O(n) O(1) 刪除元素 O(n) O(1) 修改元素 O(1) O(n) 查看元素 O(1) O(n) """# 封裝節點類 class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef travel(self, head):"""遍歷鏈表里面的每一個元素"""while head:print(head.val, end=',')head = head.nextdef create_l1():# l1 = 2,4,3# l2 = 5, 6, 4l1 = ListNode()node1 = ListNode(val=2)node2 = ListNode(val=4)node3 = ListNode(val=3)l1.next = node1node1.next = node2node2.next = node3return l1.nextdef create_l2():# l1 = 2,4,3# l2 = 5, 6, 4l2 = ListNode()node1 = ListNode(val=5)node2 = ListNode(val=6)node3 = ListNode(val=4)l2.next = node1node1.next = node2node2.next = node3return l2.nextdef addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode:res = 0l3 = ListNode()cur = l3while(l1 or l2):if(l1):res += l1.val # res=2l1 = l1.nextif(l2):res += l2.val # res=2+5=7l2 = l2.next# res=10, val=0, res=>val val=res%10# res=14, val=4, 14%10=4l3.next = ListNode(res%10)l3 = l3.next# res=10, 進位為1， 10//10=1# res=14, 進位為1， 14//10=1res //= 10if res == 1:l3.next = ListNode(1)return cur.nextif __name__ == '__main__':l1 = create_l1()l2 = create_l2()l3 = addTwoNumbers(l1, l2)l3.travel(l3)

7. 多繼承

多繼承,即子類有多個父類,并且具有它們的特征

在Python 2及以前的版本中，由任意內置類型派生出的類，都屬于“新式
類”
，都會獲得所有“新式類”的特性；反之，即不由任意內置類型派生出的類，
則稱之為“經典類”。

“新式類”和“經典類”的區分在Python 3之后就已經不存在，在Python 3.x之后的版本，因為所有的類都派生自內置類型object(即使沒有顯示的繼承object類型)，即所有的類都是“新式類”。
最明顯的區別在于繼承搜索的順序不同，即：
經典類多繼承搜索順序(深度優先算法):先深入繼承樹左側查找，然后再返回，開始查找右側。
新式類多繼承搜索順序(廣度優先算法):先在水平方向查找，然后再向上查找，

""" 新式類: 廣度優先算法 經典類： 深度優先算法(py2中的部分類屬于經典類)python3所有的類都屬于新式類。新式類的繼承算法是廣度優先。# 分析多繼承的相關代碼 >pip install djangorestframework from rest_framework import viewsets viewsets.ModelViewSet """class D(object):def hello(self):print('D') class C(D):# def hello(self):# print('C')pass class B(D):pass# def hello(self):# print('B') class A(B, C):pass# def hello(self):# print('A') a = A() a.hello()

四、私有屬性和私有方法

默認情況下,屬性在 Python 中都是“public”， 大多數 OO 語言提供“訪問控制符”來限定成員函數的訪問。
在 Python 中,實例的變量名如果以 __ 開頭,就變成了一個私有變量/屬性
(private),實例的函數名如果以 __ 開頭,就變成了一個私有函數/方法(private)只
有內部可以訪問,外部不能訪問。

class Student:"""父類Student"""def __init__(self, name, age, score):self.name = nameself.age = age# 私有屬性，以雙下劃線開頭。# 工作機制: 類的外部(包括子類)不能訪問和操作，類的內部可以訪問和操作。self.__score = scoredef learning(self):print(f'{self.name}正在學習')def get_score(self):self.__modify_score()return self.__score# 私有方法是以雙下劃線開頭的方法,#工作機制: 類的外部(包括子類)不能訪問和操作，類的內部可以訪問和操作。def __modify_score(self):self.__score += 20class MathStudent(Student):"""MathStudent的父類是Student"""def get_score(self):self.__modify_score()return self.__score# 報錯原因: 子類無法繼承父類的私有屬性和私有方法。 s1 = MathStudent('張三', 18, 100) score = s1.get_score() print(score)

優勢

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

如果又要允許外部代碼修改屬性怎么辦?可以給類增加專門設置屬性方
法。 為什么大費周折?因為在方法中,可以對參數做檢查,避免傳入無效的參數。

五、多態特性

多態（Polymorphism）按字面的意思就是“多種狀態”。在面向對象語言中，接口的多種不同的實現方式即為多態。通俗來說： 同一操作作用于不同的對象，可以有不同的解釋，產生不同的執行結果。

多態的好處就是，當我們需要傳入更多的子類，只需要繼承父類就可以了，而方法既可以直接不重寫（即使用父類的），也可以重寫一個特有的。這就是多態的意思。調用方只管調用，不管細節，而當我們新增一種的子類時，只要確保新方法編寫正確，而不用管原來的代碼。這就是著名的“開閉”原則：
對擴展開放（Open for extension）：允許子類重寫方法函數
對修改封閉（Closed for modification）：不重寫，直接繼承父類方法函數

總結

以上是生活随笔為你收集整理的python面向对象编程(封装与继承)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。