Python之面向對象是什么

Python之面向對象是什么？相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。

面向對象技術簡介

類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

方法：類中定義的函數。

類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為實例變量使用。

數據成員：類變量或者實例變量用于處理類及其實例對象的相關的數據。

方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。

局部變量：定義在方法中的變量，只作用于當前實例的類。

實例變量：在類的聲明中，屬性是用變量來表示的。這種變量就稱為實例變量，是在類聲明的內部但是在類的其他成員方法之外聲明的。

繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。

實例化：創建一個類的實例，類的具體對象。

對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

和其它編程語言相比，Python 在盡可能不增加新的語法和語義的情況下加入了類機制。

Python中的類提供了面向對象編程的所有基本功能：類的繼承機制允許多個基類，派生類可以覆蓋基類中的任何方法，方法中可以調用基類中的同名方法。

對象可以包含任意數量和類型的數據。

Python 中定義類的方法是以 class k開頭，我們先定義一個類：

class Cat:
    def eat(self):
        print("貓吃魚")
        
cat = Cat()
cat.eat()  # 貓吃魚

如上 ，我們定義了一個 Cat 類，里面定義了一個方法，我們可以通過 變量=類名() 的方式來實例化一個類，這樣我們就可以調用類里面的屬性和方法，所以當我們調用 cat.eat() 時輸出打印 Cat 類里面的 eat() 方法。

在上面的 eat() 方法中，我們默認穿了一個 self 的參數，它代表該類的實例，不一定非叫 self ，可以叫 xxx，只是我們約定俗成叫 self，跟 *args 和 **kwargs 一個道理，那該如何理解這個 self 呢，如下：

class Cat:
    def eat(self):
        print(self.name+"吃魚")


tom = Cat()
tom.name = "Tom"
tom.eat()  # Tom吃魚

jerry = Cat()
jerry.name = "Jerry"
jerry.eat()  # Jerry吃魚

在上面的代碼中，我們定義了兩個 Cat 的實例，并且在每個實例中都添加了一個 name 屬性，如果我們想要在 eat() 方法中輸出各自定義的 name 值，我們可以通過 self 屬性來定義，因為 self 就表示該類的實例，所以就會去拿各自實例里面的 name 值。

上面的代碼中我們可以實現輸出不同的 name 值，但是需要我們在實例化后自己定義 name，我們也可以在定義類的時候就將 name 值傳入來做：

class Cat:
    def __init__(self,name):
        self.name = name
    def eat(self):
        print(self.name+"吃魚")

tom = Cat("Tom")
tom.eat()  # Tom吃魚

jerry = Cat("Jerry")
jerry.eat()  # Jerry吃魚

上面的代碼中，我們在 Cat 類中定義了一個 __init__() 的方法，該方法是類自帶的方法，第一個參數必須為 self，我們可以在里面定義自己所需的變量。如上，我們在實例化 Cat 類的時候就將 Tom ，Jeery 傳入，然后在 self 形參后面添加形參，該形參與傳入參數的順序意義對應，這樣我們就可以使用傳入的參數了，定義和使用時需要在前面加 self。

在上面的代碼演示中，我們可以看出當我們實例化一個類之后，就能調用該類的方法，這種方法叫公有方法，還有一種方法叫私有方法，就是實例化后不能被調用，只有自己內部可以調用，如下：

class Cat:
    def __init__(self,name):
        self.name= name
    def eat(self):
        print(self.name+"吃魚")
        self.__run()
    def __run(self):
        print("私有方法")
 
tom = Cat("Tom")
tom.eat()  # Tom吃魚  私有方法
tom.__run()  # AttributeError: 'Cat' object has no attribute '__run'

上面的代碼中當我們實例化 tom 后，可以通過 eat() 方法調用到 __run() 方法，但是直接調用 __run() 會報錯。

不僅私有方法不能被調用，私有屬性也不能，如下：

class Cat:
    age = 11
    __height = 120
    def add(self):
        self.age += 1
        self.__height += 1

tom = Cat()
tom.add()
print(tom.age)  # 12
print(tom.__height)  # AttributeError: 'Cat' object has no attribute '__height'

接下來我們看一下類中的繼承，在上面的代碼中我們定義了一個 Cat 的類，里面有一個 eat() 方法，當我們定義一個 Dog 類時，它也有一個 eat() 方法，而且 eat() 方法是一樣的，現在 Cat 類有一個 bark() 方法，Dog 類里也有一個 bark() 方法，但是這兩個方法執行的結果不一樣，而且 Dog 類里有一個 swim() 方法，而 Cat 里沒有，如果我們都分別定義這兩個類的話，代碼會很長，而且如果兩個相同的 eat() 方法需要修改時需要修改兩個地方，這時我們可以用繼承的方式解決，如下：

class Animal:
    def eat(self):
        print("吃吃吃")

class Cat(Animal):
    def bark(self):
        print("喵喵喵")

class Dog(Animal):
    def bark(self):
        print("汪汪汪")

    def swim(self):
        print("狗刨式")

cat = Cat()
cat.eat()  # 吃吃吃
cat.bark()  # 喵喵喵
cat.swim()  # AttributeError: 'Cat' object has no attribute 'swim'

dog = Dog()
dog.eat()  # 吃吃吃
dog.bark()  # 汪汪汪
dog.swim()  # 狗刨式

我們將 Cat 類和 Dog 類相同的 eat() 方法定義在了 Animal 類里，然后在創建 Cat 和 Dog 類時添加了 (Animal)，意思是繼承 Animal 類，這樣我們在實例化 Cat 和 Dog 類后就能調用 Animal 類里的方法 eat()，而且還能調用各自實例里的 bark() 方法，但是如果沒有另一個類，則不能使用該類的方法，如 cat 調用 dog 的 swim() 方法就會報錯。

當然我們可以讓 Cat 類也繼承 Dog 類，如下：

class Animal:
    def eat(self):
        print("吃吃吃")
# Cat 類要想繼承 Dog 類必須寫在 Dog 類后面
# class Cat(Dog,Animal):
#     def bark(self):
#         print("喵喵喵")

class Dog(Animal):
    def bark(self):
        print("汪汪汪")
    def swim(self):
        print("狗刨式")

class Cat(Dog,Animal):
    def bark(self):
        print("喵喵喵")

cat = Cat()
cat.eat()  # 吃吃吃
cat.bark()  # 喵喵喵
cat.swim()  # 狗刨式

dog = Dog()
dog.eat()  # 吃吃吃
dog.bark()  # 汪汪汪
dog.swim()  # 狗刨式

如上，我們可以讓 Cat 同時繼承 Dog 和 Animal 兩個類，但是如若想要繼承某類，必須先創建該類。

我們也可以多重繼承，即讓 Animal 類也繼承某類，這樣 Cat 和 Dog 如果繼承了 Animal 類，那么也可以使用 Animal 類繼承的父類的屬性和方法。

只得注意的是私有屬性和方法不能被繼承，因為私有屬性和方法只能在自己的類中使用。

接下來我們看一下類中方法的重寫：

class Animal:
    def eat(self):
        print("吃吃吃")

class Cat(Animal):
    pass

class Dog(Animal):
    def eat(self):
        print("大口大口吃")

cat = Cat()
cat.eat()  # 吃吃吃
 
dog = Dog()
dog.eat()  # 大口大口吃

在上面的代碼中，我們讓 Cat 和 Dog 類都繼承了 Animal 類，但是在 Dog 類中，我們定義了一個和 Animal 類中一樣的方法名，但是執行的結果不一樣，當我們分別調用實例化的 cat 和 dog 的 eat() 方法時，Cat 類由于沒有自己的 eat() 方法，所以向上尋找，發現繼承的 Animal 類中有 eat() 方法，所以就調用了 Animal 類中的 eat() 方法，但是 Dog 類中有 eat() 方法，所以就調用自己的 eat() 方法，不在向上尋找，這就是類中方法的重寫。

在上面我們說過了類屬性和實例方法，接下來我們來看一下類方法：

class Cat:
    # 類屬性
    age = 10

    # 實例方法
    def __init__(self):
        self.name = "Tom"

    def info(self):
         print(self.name, self.age)

    # 類方法
    @classmethod
    def addAge(cls):
        cls.age = 22
 
tom = Cat()
tom.info()  # Tom 10
Cat.info()  # TypeError: info() missing 1 required positional argument: 'self'

tom.addAge()
print(tom.age)  # 22
print(Cat.age)  # 22

Cat.addAge()
print(tom.age)  # 22
print(Cat.age)  # 22

如果我們在類里面的方法前面加 @classmethod，就表明該方法為類方法，在說類方法前我們再來看一下實例方法。

當我們實例化一個 tom 后，我們就可以調用 tom 里面的實例方法，我們之前說過 self 指的是該類的實例化，所以當我們調用 tom.info() 時能正常調用，但是 Cat.info() 時則會報錯，因為里面的 self 指向的是實例化的 tom，而不是 Cat 類，所以會報錯。

在類方法中，我們同樣謠傳一個默認的形參，默認叫 cls，它指向的是類本身，而不是該類的實例化，所以我們可以通過 cls.age=22 來更改類里面的類屬性，而且類方法 addAge() 可以使用實例化的 tom 來調用，也可以使用 Cat 類本身來調用。

看完上述內容，你們掌握Python之面向對象是什么的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！