Python的類與模塊化怎么理解

這篇文章主要介紹“Python的類與模塊化怎么理解”，在日常操作中，相信很多人在Python的類與模塊化怎么理解問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Python的類與模塊化怎么理解”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

學習目標

Python 是簡潔、易學、面向對象的編程語言。它不僅擁有強大的原生數據類型，也提供了簡單易用的控制語句。本節的主要目標是介紹 Python 中的面向對象編程范式以及模塊化思想，為接下來的學習奠定基礎，本文會完整的介紹學習數據結構和算法所需的 Python 基礎知識及基本思想，并給出相應的實戰示例及解釋。

掌握 Python 面向對象編程的基本概念，并會編寫 Python 自定義類

掌握 Python 模塊化的編程思想

1. 面向對象編程：類

1.1 面向對象編程的基本概念

一個完善的程序是由數據和指令組成的。過程式編程利用“分而治之”的思想，使用函數對數據進行處理，數據與函數之前的關系是松散的，即同樣的數據可以被程序中的所有函數訪問，而一個函數也可以訪問程序中的不同數據。這導致了，如果出現異常，需要在整個系統中查找錯誤代碼。

為了解決這一問題，面向對象編程 (Object Oriented Programming, OOP) 將系統劃分為不同對象，每個對象包含自身的信息數據以及操作這些數據的方法。例如，每個字符串對象具有字符數據，同時還具有改變大小寫、查找等方法。

面向對象編程使用類描述其所包含的所有對象的共同特性(屬性)，即數據屬性(也稱數據成員或成員變量)和功能屬性(也稱成員函數或方法)。

一個類的對象也稱為這個類的一個實例。例如，32 就是一個整數類 int 的對象，可以使用函數 type() 來獲取對象所屬類：

>>> type(32)
<class 'int'>

可以利用內置函數 dir() 查詢類的屬性：

>>> dir(32)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

在繼續講解之前，我們首先來快速介紹下面向對象的三大特性——多態、封裝和繼承。

1.1.1 多態

多態：可對不同類型的對象執行相同的操作。

多態其實很常見，例如列表對象和元組對象都具有 count 方法，使用變量調用 count 方法時，我們無需知道它究竟是列表還是元組，這就是多態的作用。這不僅僅適用于方法，許多內置運算符和函數也使用了多態：

>>> [1,3,3,3].count(3)
3
>>> (1,3,3,3).count(3)
3
>>> [1,3]+[1,3]
[1, 3, 1, 3]
>>> 'hello' + ' world!'
'hello world!'

1.1.2 封裝

封裝：對外部隱藏有關對象具體操作的細節。

封裝與多態類似，都屬于抽象原則，都用于處理程序的組成部分而無需關心不必要的細節，但不同的是，多態使我們無需知道對象所屬的類就能調用其方法，而封裝使我們無需知道對象的內部構造就能使用它。例如我們將虛數的實部和虛部作為對象的數據屬性，就是將對象的屬性“封裝”在對象中。

1.1.3 繼承

繼承：用于建立類的層次結構，基于上層的類創建出新類。

如果我們有了一些類，再創建新的類時發現與已存在的類十分相似，只需要添加一些新方法，那么我們可能不想復制舊類的代碼至新類中，這時我們就要用到繼承了。例如，我們有了一個 Fruit 類，具有描述外觀的方法 show_shape，如果想要新建一個 Apple 類，除了描述外觀外，我們還想知道如何計算總價，那么我們就可以讓 Apple 類繼承 Fruit 的方法，使得對 Apple 對象調用方法 show_shape 時，將自動調用 Fruit 類的這個方法。

1.2 自定義類

我們已經知道抽象數據類型就是一個由對象以及對象上的操作組成的集合，對象和操作被捆綁為一個整體，不但可以使用對象的數據屬性，還可以使用對象上的操作。操作(在類中稱為方法)定義了抽象數據類型和程序其他部分之間的接口。接口定義了操作要做什么，但沒有說明如何做，因此我們可以說抽象的根本目標是隱藏操作的細節。而類就是為了實現數據抽象類型。

Python 用關鍵字 class 定義一個類，格式如下，其中方法定義與函數定義語法類似：

class 類名:

方法定義

接下來構建實現抽象數據類型 Imaginary (虛數)的類，用于展示如何實現自定義類。

定義類時首先需要提供構造方法，構造方法定義了數據對象的創建方式。要創建一個 Imaginary 對象，需要提供實部和虛部兩部分數據，Python 中，__init__() 作為構造方法名：

class Imaginary:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

形式參數列表的第一項是一個指向對象本身的特殊參數(習慣上通常使用 self )，在調用時不需要提供相應的實際參數，而構造方法中的剩余參數必須提供相應的實參，使得新創建的對象能夠知道其初始值，與函數定義一樣，可以通過默認值為形參提供默認實參。如在 Imaginary 類中，self.real 定義了 Imaginary 對象有一個名為 real 的內部數據對象作為其實部數據屬性，而self.imag 則定義了虛部。

創建 Imaginary 類的實例時，會調用類中定義的構造方法，使用類名并且傳入數據屬性的實際值完成調用：

>>> imaginary_a = Imaginary(6, 6)
>>> imaginary_a
<__main__.Imaginary object at 0x0000020CF1B80160>

以上代碼創建了一個對象，名為 imaginary_a，值為 6+6i，這就是封裝的示例，將數據屬性和操作數據屬性的方法打包在對象中。

除了實例化外，類還支持另一操作：屬性引用(包括數據屬性和功能屬性)，通過點標記法訪問與類關聯的屬性：

>>> imaginary_a.real
6
>>> imaginary_a.imag
6

除了數據屬性外，還需要實現抽象數據類型所需要的方法(功能屬性)，需要牢記的是，方法的第一個參數 self 是必不可少的，例如要實現打印實例化的虛數對象，編寫類方法 display()：

class Imaginary:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag
    
    def display(self):
        print('{}{:+}i'.format(self.real, self.imag))

調用類方法打印實例化的虛數對象：

>>> imaginary_a = Imaginary(6, 6)
>>> imaginary_a.display()
6+6i
>>> print(imaginary_a)
<__main__.Imaginary object at 0x0000020CF1B72D90>

可以看到，如果使用 print() 函數只能打印存儲在變量中的地址，這是由于將對象轉換成字符串的方法 __str__() 的默認實現是返回實例的地址字符串，如果想要使用 print 函數打印對象，需要重寫默認的 __str__() 方法，或者說重載該方法：

>>> imaginary_a = Imaginary(6, 6)
>>> imaginary_a.display()
6+6i
>>> print(imaginary_a)
<__main__.Imaginary object at 0x0000020CF1B72D90>

此時如果再次使用 print() 函數，就可以直接打印對象了：

>>> imaginary_a = Imaginary(6, 6)
>>> print(imaginary_a)
6+6i

可以重載類中的很多方法，最常見的是重載運算符，這是由于人們習慣使用熟悉的運算符對數據進行運算，這要比使用函數對數據進行運算更加直觀且易于理解，如表達式：8 + 6 / 3，如果用函數則為：add(8, div(6, 3))，顯然前者比后者更加符合習慣。 如果某種類型的對象要使用常見運算符，就必須對這種類型重新定義相應的運算符函數，例如，Python 對于 int 整型、float 浮點型、str 字符串類型等都重新定義了乘法運算符函數，對一個類型重新定義運算符函數的也稱“運算符重載”。我們可以編寫 Imaginary 類的 __mul__() 方法重載乘法運算：

class Imaginary:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    def display(self):
        print('{}{:+}i'.format(self.real, self.imag))
        
    def __str__(self):
        print('{}{:+}i'.format(self.real, self.imag))
    
    def __mul__(self, other):
        new_real = self.real * other.real - self.imag * other.imag
        new_imag = self.real * other.imag + self.imag * other.real
        return Imaginary(new_real, new_imag)

還可以重載其他運算符，如比較運算符 ==，即 __eq__() 方法，重載 Imaginary 類的 __eq__() 方法允許兩個虛數進行比較，查看它們的值是否相等，這也稱為深相等；而根據引用進行判斷的淺相等，只有兩個變量是同一個對象的引用時才相等：

# shallow_and_deep_equal.py
class ImaginaryFirst:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    def display(self):
        print('{}{:+}i'.format(self.real, self.imag))

    def __str__(self):
        print('{}{:+}i'.format(self.real, self.imag))
        
class Imaginary:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    def display(self):
        print('{}{:+}i'.format(self.real, self.imag))

    def __str__(self):
        print('{}{:+}i'.format(self.real, self.imag))
    
    def __eq__(self, other):
        return self.real == other.real and self.imag == self.imag

print('淺相等：只有兩個變量是同一個對象的引用時才相等。')
imag_1 = imag_2 = ImaginaryFirst(6, 6)
print('imag_1 == imag_2  ', imag_1 == imag_2)
imag_1 = ImaginaryFirst(6, 6)
imag_2 = ImaginaryFirst(6, 6)
print('imag_1 == imag_2  ', imag_1 == imag_2)

print('深相等：兩個變量的值相等即表示對象相等。')
imag_1 = imag_2 = Imaginary(6, 6)
print('imag_1 == imag_2  ', imag_1 == imag_2)
imag_1 = Imaginary(6, 6)
imag_2 = Imaginary(6, 6)
print('imag_1 == imag_2  ', imag_1 == imag_2)

程序運行結果如下所示：

淺相等：只有兩個變量是同一個對象的引用時才相等。

imag_1 == imag_2   True

imag_1 == imag_2   False

深相等：兩個變量的值相等即表示對象相等。

imag_1 == imag_2   True

imag_1 == imag_2   True

1.3 再談繼承

1.3.1 繼承實例

繼承可以建立一組彼此相關的抽象，能夠建立一個類的層次結構，這樣的關系結構也稱為繼承層次結構，每個類都可以從上層的類繼承屬性。在 Python 中，object 類位于最頂層。

下層的新類會繼承已有類的屬性，同時添加自己特有的一些屬性，這個新的類就稱為“派生類”或“子類”，而原有的類稱為“基類”、“父類”或“超類”。利用父類定義子類，需要在定義的類名后添加圓括號，圓括號內寫入父類名。如果沒有顯式地說明一個類的父類，則默認其父類為 object。

例如三角形，包括銳角三角形、直角三角形和鈍角三角形，因此定義類時，除了定義一般三角形的類 Triangle 外，還可以定義銳角三角形的類 AcuteTriangle 等，這時我們就可以令 AcuteTriangle 類繼承 Triangle 類：

class Triangle:
    def __init__(self, edge_1, edge_2, edge_3):
        self.edge_1 = edge_1
        self.edge_2 = edge_2
        self.edge_3 = edge_3
    
    def __str__(self):
        return str((self.edge_1, self.edge_2, self.edge_3))
    
    def print_info(self):
        print('The three sides of a triangle are {}, {} and {}'.format(self.edge_1, self.edge_2, self.edge_3))
    
    def perimeter(self):
        return self.edge_1 + self.edge_2 + self.edge_3
        
class AcuteTriangle(Triangle):
    def __init__(self, edge_1, edge_2, edge_3, max_angle):
        # 使用父類構造函數進行初始化
        Triangle.__init__(self, edge_1, edge_2, edge_3)
        self.max_angle = max_angle
    
    def print_info(self):
        Triangle.print_info(self)
        print('The max angle is {}'.format(self.max_angle))
    
    def get_max_angle(self):
        return self.max_angle

可以看到子類除了繼承外，還可以：

• 添加新屬性，例如子類 AcuteTriangle 中新增了數據屬性 max_angle 以及方法屬性 get_max_angle；

• 替換(覆蓋)父類中的屬性，例如AcuteTriangle覆蓋了父類的__init__()和 print_info() 方法。以 AcuteTriangle.__init__() 方法為例，首先調用 Triangle.__init__() 初始化被繼承的實例變量 self.edge_1，self.edge_2，self.edge_3， 然后初始化 self.max_angle，這個實例變量只在 AcuteTriangle 實例中才有，而Triangle 實例中沒有。

>>> triangle_a = Triangle(3, 4, 6)
>>> triangle_a.print_info()
The three sides of a triangle are 3, 4 and 6
>>> triangle_b = AcuteTriangle(3, 3, 3, 60)
>>> triangle_b.print_info()
The three sides of a triangle are 3, 3 and 3
The max angle is 60

在子類中可以通過 super() 方法來調用父類的方法，這種方法可以省略父類名：

class AcuteTriangle(Triangle):
    def __init__(self, edge_1, edge_2, edge_3, max_angle):
        # 使用父類構造函數進行初始化
        super().__init__(self, edge_1, edge_2, edge_3)
        self.max_angle = max_angle
    
    def print_info(self):
        super().print_info(self)
        print('The max angle is {}'.format(self.max_angle))
    
    def get_max_angle(self):
        return self.max_angle

使用內置函數 isinstance() 可以檢查一個對象是否是某個類的實例(對象)，而要確定一個類是否是另一個類的子類，則可以使用內置方法 issubclass()：

>>> triangle_a = Triangle(3, 4, 6)
>>> triangle_b = AcuteTriangle(3, 3, 3, 60)
>>> print(isinstance(triangle_a, Triangle))
True
>>> print(isinstance(triangle_a, AcuteTriangle))
False
>>> print(isinstance(triangle_b, AcuteTriangle))
True
>>> print(isinstance(triangle_b, Triangle))
True
>>> print(issubclass(AcuteTriangle, Triangle))
True
>>> print(issubclass(Triangle, AcuteTriangle))
False

因為類 AcuteTriangle 是從類 Triangle 派生出來的，所以一個類 AcuteTriangle 對象當然也是一個類 Triangle 對象，正如“一個銳角三角形也是一個三角形”。

1.3.2 多繼承

一個類可以繼承多個類的特性，這也稱為多繼承，例如：

class RightTriangle(Triangle):
    def area(self):
        return self.edge_1 * self.edge_2 * 0.5

    def print_name(self):
        print('This is a right triangle!')

class IsoscelesTriangle(Triangle):
    def print_name(self):
        print('This is an isosceles triangle!')

class IsoscelesRightTriangle(RightTriangle, IsoscelesTriangle):
    pass

以上示例中，pass 語句不做任何事，其作用相當于占位符，以等待后續補充代碼；也可以用于語法上需要語句而實際不需要做任何工作的地方。

2. 模塊

我們已經知道，函數和類都是可以重復調用的代碼塊。在程序中使用位于不同文件的代碼塊的方法是：導入 (import) 該對象所在的模塊 (mudule)。

在之前的示例中，我們總是使用 shell，或假設整個程序保存在一個文件中，這在程序比較小時可能沒有什么問題。但程序變得越來越大時，將程序的不同部分根據不同分類方法保存在不同文件中通常會更加方便。

2.1 導入模塊

Python 模塊允許我們方便地使用多個文件中的代碼來構建程序。模塊就是一個包含 Python 定義和語句的 .py 文件。

例如我們創建一個 hello_world.py 文件，就可以理解為創建了一個名為 hello_world 的模塊：

# hello_world.py
def print_hello():
    print('Hello World!')

class Triangle:
    def __init__(self, edge_1, edge_2, edge_3):
        self.edge_1 = edge_1
        self.edge_2 = edge_2
        self.edge_3 = edge_3
    
    def __str__(self):
        return str((self.edge_1, self.edge_2, self.edge_3))
    
    def print_info(self):
        print('The three sides of a triangle are {}, {} and {}'.format(self.edge_1, self.edge_2, self.edge_3))
    
    def perimeter(self):
        return self.edge_1 + self.edge_2 + self.edge_3

可將模塊視為擴展，要導入模塊，需要使用關鍵字 import，導入模塊的一般格式如下：

import module_1[, module_2....]  # 可以同時導入多個模塊

例如在 test.py 文件要導入 hello_world 模塊：

import hello_world

導入的模塊只要說明模塊名即可，不需要也不能帶有文件擴展名 .py。如果要使用模塊中的對象，如函數、類等，需要用使用句點運算符 (.)，即使用“模塊名.對象”進行訪問。例如，使用 hello_worl.Triangle 訪問模塊 hello_world 中的類 Triangle：

# test_1.py
import hello_world
hello_world.print_hello()
tri_a = hello_world.Triangle(3, 4, 5)
print(tri_a)

程序輸出如下所示：

Hello World!

(3, 4, 5)

需要注意的是，導入的模塊要位于相同的目錄層次下，否則需要添加目錄結構，例如，如果 hello_world 位于子目錄 module 下，則需要使用如下方式：

# test_2.py
import module.hello_world
module.test.print_hello()

程序輸出如下所示：

Hello World!

2.2 導入Python標準模塊

Python 提供了許多標準模塊，這些模塊文件位于 Python 安裝目錄的 lib 文件夾中。可以像導入自己編寫的模塊一樣導入標準模塊，例如導入 math 模塊，使用其中的對象：

# test_3.py
import math
print('sqrt(4) = ', math.sqrt(4))
print('sin(π/6) = ', math.sin(math.pi /6))

程序輸出如下所示：

sqrt(4) = 2.0

sin(π/6) = 0.49999999999999994

這里可能大家會有一個疑問，這里導入的模塊和當前文件并不在同一目錄下，為什么不需要使用模塊路徑？這個問題也可以轉換為——當我們使用 import 語句的時候，Python 解釋器是怎樣找到對應的文件的呢？

這就涉及到 Python 的搜索路徑，搜索路徑是由一系列目錄名組成的，Python 解釋器就依次從這些目錄中去尋找所引入的模塊。搜索路徑被存儲在 sys 模塊中的 path 變量中：

>>> import sys
>>> sys.path
['', 'D:\\Program Files\\Python39\\python39.zip', 'D:\\Program Files\\Python39\\DLLs', 'D:\\Program Files\\Python39\\lib', 'D:\\Program Files\\Python39', 'D:\\Program Files\\Python39\\lib\\site-packages'

2.3 單獨導入模塊中所需對象

我們可能不想每次調用模塊中的對象時都指定模塊名，這時，我們可以使用 from module import object，從模塊中單獨導入所需對象，同時使用這個單獨導入的對象時就不需要在前面添加“模塊名.”前綴了：

# test_4.py
from math import pi, sin
print('sqrt(4) = ', sqrt(4))
print('sin(π/6) = ', sin(math.pi /6))

2.4 導入模塊中的所有對象

可以通過 from module import *導入模塊中的所有對象，同樣不再需要模塊名前綴：

# test_5.py
from math import *
print('sqrt(4) = ', sqrt(4))
print('sin(π/6) = ', sin(math.pi /6))

不同程序代碼中不可避免地可能會使用了同一個名字來命名不同對象，這時就會引起沖突，但如果這些名字屬于不同的模塊，就可以通過模塊名來區分它們，因此為了避免名字沖突，應盡量避免使用 from module import object 或 from module import * 導入對象。

2.5 重命名導入模塊或對象

另一種避免名字沖突的方法是重命名導入模塊或對象：

# test_6.py
import math as m
from datetime import date as d
print(d.today())
print('sqrt(4) = ', m.sqrt(4))
print('sin(π/6) = ', m.sin(math.pi /6))

程序輸出如下所示：

datetime.date(2021, 12, 3)

sqrt(4) = 2.0

sin(π/6) = 0.49999999999999994

可以看到附加的好處是可以使用簡寫，減少編碼工作量。

2.6 導入第三方模塊

除了標準庫外，Python 也具有規模龐大的第三方庫，覆蓋了信息技術幾乎所有領域，這也是 Python 的其中一個巨大優勢。下面以常用可視化庫 matplotlib 為例介紹第三方庫的使用。和標準庫不同，使用第三方庫首先要進行安裝，在 shell 命令中使用 pip 命令可以快速安裝所需庫：

pip install matplotlib

安裝完成后，使用第三方庫就和標準庫沒有任何差別了：

# cos_1.py
import math
from matplotlib import pyplot as plt
scale = range(100)
x = [(2 * math.pi * i) / len(scale) for i in scale]
y = [math.cos(i) for i in x]
plt.plot(x, y)
plt.show()

到此，關于“Python的類與模塊化怎么理解”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！