Python如何面向對象

這期內容當中小編將會給大家帶來有關Python如何面向對象，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

Python 是一門完全面向對象的語言。在 Python 中，一切都是對象。從我們開始使用 Python 時，我們就已經使用了 Python 中的對象和類。

Python 程序中的每一個元素都是類的一個實例，如數字、字符串、列表、字典這些元素，都是 Python 內置類對應的一個對象，甚至于使用 def 關鍵字定義的一個函數都對應一個 function類。

面向對象基礎

Python 使用 class 關鍵字聲明一個類。

一個典型的 Python 類主要包含以下成員:

構造函數 (constructor)

實例屬性 (Instance Attributes)

類屬性 (Class Attributes)

方法 (Class Attributes)

一個類也可以沒有任何成員，如下面的 Car 類就沒有任何成員:

class Car:
    '''This is an empty Car Class'''
    pass

下面的類則包含了實例屬性、類屬性、構造函數、方法等成員:

class Car:
    brand = 'BenChi'

    def __init__(self):
        self.price = 10000
        self.chair = 7

    def run(self):
        print('Run 100km Per Hour....')

構造函數

在 Python 中，構造函數是實例化一個類對象的時自動被調用的函數，類似于 Java 或 C# 中的構造函數。構造函數必須使用一個特定的名稱 __init__ ，并且必須有一個固定的參數 self 。

Python 類中 幾乎 每一個方法都要將 self 作為第一個參數，self 是調用該方法的對象的引用。其實，第一個參數的名字是任意的，并不一定要叫 self, self 只是一種約定。

注意，注意，注意: __init__ 方法并不是 Python 類構造函數，關于 Python 類的構造函數其實有很大爭議，這里主要是為了介紹面向對象的概念。

下面的例子定義了一個構造函數:

class Car:
    def __init__(self):
        print('Call Constructor......')

car1 = Car()
car2 = Car()

Python 中構造函數( init )的作用定義了類實例的屬性，并對實例屬性進行復制。

實例屬性

實例屬性是與類實例綁定的屬性，其定義在構造函數( init )中。

下面的例子定義了兩個實例屬性:

class Car:
    def __init__(self):
        self.price = 100
        self.chair = 7

類屬性

類屬性不同于實例屬性，類屬性的值被所有實例對象共享。類屬性在類級別定義而不是定義在__init__ 方法中。類屬性的訪問也不同于實例屬性，類屬性的訪問是通過類名, 也可以通過實例訪問。

下面例子定義了一個類屬性

class Car:
    brand = "benchi"

print(Car.brand)

通過類名修改類屬性

通過類名修改類屬性，那么該類所有的實例對象對應的類屬性都會被修改, 如下:

class Car:
    brand = "benchi"


car1 = Car()
car2 = Car()

print('Before Change.............')
print(f'car1 brand is: {car1.brand}')
print(f'car2 brand is: {car2.brand}')

print('Change Class Attribute By [Class Name]')
Car.brand = 'Audi'

print('After Change.............')
print(f'car1 brand is: {car1.brand}')
print(f'car2 brand is: {car2.brand}')

輸出:
Before Change.............
car1 brand is: benchi
car2 brand is: benchi
Change Class Attribute By [Class Name]
After Change.............
car1 brand is: Audi
car2 brand is: Audi

類方法

在一個類中，可以定義盡可能多的類方法，一般情況下，類方法的第一個參數都是 self 。

下面的類就定義了一個類方法:

class Car:
    brand = "benchi"

    def run(self):
        print('Run......')

面向對象之封裝

面向對象語言，如Java、C++等，使用 public 、 protected 、 private 等關鍵字來控制對類資源的訪問。

類的 private 成員僅能在類內部進行訪問，其他任何地方都不能訪問，包括其子類。

類的 protected 成員可以在類內部和其子類中訪問。

類的 public 成員可以在任何地方進行訪問。

Python沒有使用關鍵字機制來限制對類成員方法和類成員屬性的訪問，Python規定了一種約定，在類方法或者類成員前加 _ (下劃線)或者 __ (雙下劃線)來模擬 private 或者 public 訪問修飾其的功能。

面向對象之繼承

在面向對象編程中，繼承是達到代碼重用目的的一種方式。在繼承中，子類可以使用其父類的一部分代碼。

繼承的基本使用

下面先創建一個父類, 代碼如下:

class Fish:
    def __init__(self, first_name, last_name="Fish",
                 skeleton="bone", eyelids=False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids

    def swim(self):
        print("The fish is swimming.")

    def swim_backwards(self):
        print("The fish can swim backwards.")

接下來，創建一個沒有任何方法和屬性的子類，代碼如下:

class Trout(Fish):
    pass

Python類繼承的語法是在定義類的時候，傳入父類的名字作為參數

由于 Trout 類繼承了 Fish 類， Trout 類就是 Fish 類的子類， Trout 類的對象就可以調用其父類的所有方法，代碼如下:

terry = Trout("Terry")
print(terry.first_name + " " + terry.last_name)
print(terry.skeleton)
print(terry.eyelids)
terry.swim()
terry.swim_backwards()

輸出:

Terry Fish
boneFalseThe fish is swimming.
The fish can swim backwards.

接下來，再創建另一個子類，該子類有自己的方法:

class Clownfish(Fish):

    def live_with_anemone(self):
        print("The clownfish is coexisting with sea anemone.")

創建 Clownfish 的一個對象，并調用其方法:

class Clownfish(Fish):

    def live_with_anemone(self):
        print("The clownfish is coexisting with sea anemone.")

casey = Clownfish("Casey")
print(casey.first_name + " " + casey.last_name)
casey.swim()
casey.live_with_anemone()

輸出:
Casey Fish
The fish is swimming.
The clownfish is coexisting with sea anemone.

從輸出結果可以看出， Clownfish 的對象 casey 可以調用其父類的 swim() 方法和 __init__() 方法，同時可以調用它自身的 live_with_anemone() 方法。

上述就是小編為大家分享的Python如何面向對象了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。