Python面向對象編程之類的概念

Posted on by

1、面向對象基本概念

1.1 萬物皆對象

  • Python語言的中所有數據類型都是對象、函數是對象、模塊是對象
  • Python所有類都是繼承最基礎的類object
  • Python語言中的數據類型的操作功能都是類方法的體現

1.2 面向對象編程

面向對象編程又叫OOP（Object-Oriented-Programming）

OOP：面向對象編程，一種編程思想，重點在於高抽象的復用代碼

  • OOP把對象當做程序的基本單元，對象包含數據和操作數據的函數
  • OOP本質是把問題解決抽象為以對象為中心的計算機程序
  • OOP在較大規模或復雜項目中十分有用，OOP可以提高協作產量
  • OOP最主要的價值在於代碼復用
  • OOP僅僅是一個編程方式，並非解決問題的高級方法

面向過程與面向對象的區別

面向過程以解決問題的過程步驟為核心編寫程序的方式，面向對象以問題對象構建和應用為核心編寫程序的方式，所有能用OOP解決的問題，面向過程都能解決。

1.3 面向對象的特征

封裝（Encapsulation） ：屬性和方法的抽象，用數據和操作數據的方法來形成對象邏輯

方法的抽象：對類的屬性（變量）進行定義、隔離和保護

  • 對象的抽象：對類的方法（函數）進行定義、隔離和保護
  • 目標是形成一個類對外可操作屬性和方法的接口

繼承：代碼復用的高級抽象，用對象之間的繼承關系來形成代碼復用

繼承是面向對象程序設計的精髓之一

  • 實現瞭以類為單位的高抽象級別的代碼復用
  • 繼承是新定義類能夠幾乎完全使用原有類屬性與方法的過程

多態：方法靈活性的抽象，讓對象的操作更加靈活、更多復用代碼

參數類型的多態：一個方法能夠處理多個類型的能力

  • 參數形式的多態：一個方法能夠接受多個參數的能力
  • 多態是OOP的一個傳統概念，Python天然支持多態，不需要特殊語法

2、Python面向對象的術語

類（Class）和對象（Object）

  • 類：邏輯抽象和產生對象的模板，一組變量和函數的特定編排
  • 對象：具體表達數據及操作的實體，相當於程序中的“變量”。包括：類對象、實例對象

類定義完成後，默認生成一個類對象，每個類唯一對應一個類對象，用於存儲這個累的基本信息 類對象是type的實例，表達為type類型；

  • 實例對象（Instance Object）：Python類實例後產生的對象，簡稱：對象
  • 類對象全局隻有一個，實例對象可以生成多個

屬性：存儲數據的“變量”（就是定義在類中的變量），用來描述類的一些特性參數。包括：類屬性、實例屬性

  • 類屬性（Class Attribute）：類對象的屬性，由所有實例對象共享；類內定義，在__init__函數外面。一般是類所共有的屬性定義為類屬性。
  • 實例屬性（Instance Attribute）：實例對象的屬性，一般在類中的函數中定義，實例屬性可能為某個實例獨有。

方法：操作數據的“方法”（就是定義在類中的變量），用來給出類的操作功能。包括：類方法、實例方法、自由方法、靜態方法、保留方法

  • 類方法（Class Method）：類對象的方法，由所有實例對象共享
  • 實例方法（Instance Method）：實例對象的方法，由各實例對象獨享，最常用的形式、
  • 自由方法（Namespace Method）：類中的一個普通函數，由類所在命名空間管理，類對象獨享
  • 靜態方法（Static Method）：類中的一個普通函數，由對象和實例對象共享
  • 保留方法（Reserved Method）：有雙下劃線喀什和結束的方法，保留使用。

實例化：從類到對象的過程，所有“對象”都源於某個“類”

3、Python類的構建

3.1 類的基本構建

在Python中，使用class關鍵字加上類名來定義類，通過縮進我們可以確定類的代碼塊，就如同定義函數那樣。語法結構

class <類名>:
    [類描述“documentation string”]
    <語句塊>

因為Python是腳本語言，定義類不限制位置，可以包含在分支或其他從屬語句塊中，執行是存在即可

  • 類名：可以是任何有效的標識符，一般首字母大寫
  • 類描述：在類定義後首行，以獨立的字符串形式定義；定義後通過<類名>.__doc__來訪問

示例代碼

class TestClass:
    """這是一個測試的類"""
    print("Hello Class Object")


print(TestClass.__doc__)
print(type(TestClass))

'''
----輸出結果----

Hello Class Object
這是一個測試的類
<class 'type'>
'''

類對象直接包含的語句會被執行，所有，定義類盡量不在類中直接包含語句

實例對象：實例對象是Python類最常用的方式

創建實例對象語法結構

<對象名> = <類名>([參數])

實例代碼:

class TestClass:
    print("一碗周")


tt = TestClass()
print(type(tt))
'''
----輸出結果----

一碗周
<class '__main__.TestClass'>
'''

3.2 類的構造函數

概念:

  • 類的構造函數用於從類創建實例對象的過程
  • 類的構造函數為實例對象創建提供瞭參數輸入方式
  • 類的構造函數為實例屬性的定義和賦值提供瞭支持

Python中使用預定義的__init__()作為構造函數

語法結構:

class ClassName:
    def __init__(self,[參數1]， [參數2]， ...[參數n]):
        <語句塊>
    ...

實例代碼:

class TestClass:
    def __init__(self, name):
        print(name)


text1 = TestClass("張三")  # 張三
text2 = TestClass("李四")  # 李四

通過構造函數__init__可以為Python提供參數

**__init__()**的使用說明

參數：第一個參數約定是self,表示類實例自身，其他參數是實例參數（self是內部使用的，默認保留，其他用戶輸入的參數放到self後面）

函數名：Python解釋器內部定義，由雙下劃線 (__) 開始和結束

返回值：構造函數沒有返回值，或返回為None，否則產生TypeError異常

**self**在類定義內部代表類的實例

  • slef是Python面向對象中約定的一個類參數
  • self代表類的實例，在類內部，self用於組合訪問實例相關的屬性和方法
  • 相比，類名代表類對象本身

3.3 類的屬性

屬性是類內部定義的變量，語法結構如下：

class ClassName:
    <類屬性名> = <類屬性初值>
    def __init__(self,[參數1]， [參數2]， ...[參數n]):
        self.<實例屬性名> = <實例屬性初值>
    ...
  • 訪問類屬性：<類名>.<類屬性>或者<對象名>.<類屬性>
  • 訪問實例屬性：<對象名>.<實例屬性>

實例代碼

class TestClass:
    count = 0  # 類屬性

    def __init__(self, name, age):
        self.name = name  # 實例屬性
        self.age = name
        TestClass.count += 1  # 實例化一次 count+1


students1 = TestClass("張三", "18")
students2 = TestClass("李四", "19")
print("總數：", TestClass.count)  # 總數： 2
print(students1.name, students2.name)  # 張三 李四

3.4 類的方法

（1）實例方法：實例方法是類內部定義的函數，與實例對象無關，語法結構

class ClassName:
    def <方法名>(self, <參數列表>):
        ...

 <方法名>(<參數列表>)的方式使用實例方法的定義第一個參數是self

實例代碼

class TestClass:
    def __init__(self, number):
        self.number = number

    def sum_number(self):  # 實例方法
        sum_num = 0
        for i in range(self.number + 1):  # 因為循環不會到最後一個數字
            sum_num += i
        return sum_num


number1 = TestClass(100)
number2 = TestClass(10)
print(number1.sum_number())  # 5050
print(number2.sum_number())  # 55

（2）類方法：類方法是與類對象相關的函數，有所有實例對象共享，語法結構↓

class ClassName:
    @classmethod
    def <方法名>(cls, <參數列表>):
        ...

<方法名>(<參數列表>)或者<類名>.<方法名>(<參數列表>)的方式使用，類方法至少包含一個參數，表示類對象，建議用@classmethod是裝飾器，類方法定義所必須

類方法隻能操作類屬性和其他類方法，不能操作實例屬性和實例方法。

實例代碼

class TestClass:
    sum_num = 0

    def __init__(self, number):
        self.number = number

    def sum_number(self):
        for i in range(self.number + 1):  # 因為循環不會到最後一個數字
            TestClass.sum_num += i
        return TestClass.sum_num

    @classmethod
    def test(cls):  # 類方法
        test_value = TestClass.sum_num * 2
        return test_value


value1 = TestClass(100)
print(value1.sum_number())  # 5050
print(value1.test())  # 10100

（3）自有方法：自有方法是定義在類名空間中的普通函數，語法格式如下：

class ClassName:
    def <方法名>(<參數列表>):
        ...

.<方法名>(<參數列表>)的方式使用，<類名>表示命名空間。自有方法不需要self或cls這類參數，可以沒有參數。自有方法隻能操作類屬性和類方法，不能操作實例屬性和實例方法。自由方法的使用隻能使用<類名>

嚴格的說自由方法不是一個方法，隻是一個定義在類中的函數

實例代碼

class TestClass:
    sum_num = 0

    def __init__(self, number):
        self.number = number

    def sum_number(self):
        for i in range(self.number + 1):  # 因為循環不會到最後一個數字
            TestClass.sum_num += i
        return TestClass.sum_num

    def test():  # 自由方法
        test_value = TestClass.sum_num * 2
        return test_value


def test_out():  # 等於上面的那個自由方法
    test_out_value = TestClass.sum_num * 2
    return test_out_value


value = TestClass(100)
print(value.sum_number())  # 5050
print(TestClass.test())  # 10100
print(test_out())  # 10100

定義來類中的自由方法也可以定義到外面

（4）靜態方法：定義在類中的普通函數，能夠被所有實例對象共享

class ClassName:
    @staticmethod
    def <方法名>(<參數列表>):
        ...

.<方法名>(<參數列表>)或者<類名>.<方法名>(<參數列表>)的方式使用靜態方法也可以沒有參數，可以理解為可以使用對象名調用的自有方法。 @staticmethod是裝飾器，靜態方法定義所必需的，靜態方法同自由方法一樣，隻能操作類屬性和類方法，不能操作實例屬性和實例方法，不同的是可以通過<類名>或<對象名>。

示例代碼

class TestClass:
    sum_num = 0

    def __init__(self, number):
        self.number = number

    def sum_number(self):
        for i in range(self.number + 1):  # 因為循環不會到最後一個數字
            TestClass.sum_num += i
        return TestClass.sum_num

    @staticmethod  # 靜態方法裝飾器
    def test():
        test_value = TestClass.sum_num * 2
        return test_value


value = TestClass(100)
print(value.sum_number())  # 5050
print(TestClass.test())  # 10100
print(value.test())  # 10100

（5）保留方法：有雙下劃線喀什和結束的方法，保留使用。語法結構↓

class ClassName:
    def <保留方法名>(<參數列表>):
        ...

保留方法一般都對應類的某種操作，在使用操作符的時候調用是Python解釋器中保留的方法

到此這篇關於Python面向對象編程之類的概念的文章就介紹到這瞭,更多相關Python面向對象編程之類的概念內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：