1. 程式人生 > >Python 從入門到進階之路(五)

Python 從入門到進階之路(五)

之前的文章我們簡單介紹了一下 Python 的函式,本篇文章我們來看一下 Python 中的面向物件。

 Python從設計之初就已經是一門面向物件的語言,正因為如此,在Python中建立一個類和物件是很容易的。

面向物件技術簡介

  • 類(Class): 用來描述具有相同的屬性和方法的物件的集合。它定義了該集合中每個物件所共有的屬性和方法。物件是類的例項。
  • 方法:類中定義的函式。
  • 類變數:類變數在整個例項化的物件中是公用的。類變數定義在類中且在函式體之外。類變數通常不作為例項變數使用。
  • 資料成員:類變數或者例項變數用於處理類及其例項物件的相關的資料。
  • 方法重寫:如果從父類繼承的方法不能滿足子類的需求,可以對其進行改寫,這個過程叫方法的覆蓋(override),也稱為方法的重寫。
  • 區域性變數:定義在方法中的變數,只作用於當前例項的類。
  • 例項變數:在類的宣告中,屬性是用變數來表示的。這種變數就稱為例項變數,是在類宣告的內部但是在類的其他成員方法之外宣告的。
  • 繼承:即一個派生類(derived class)繼承基類(base class)的欄位和方法。繼承也允許把一個派生類的物件作為一個基類物件對待。例如,有這樣一個設計:一個Dog型別的物件派生自Animal類,這是模擬"是一個(is-a)"關係(例圖,Dog是一個Animal)。
  • 例項化:建立一個類的例項,類的具體物件。
  • 物件:通過類定義的資料結構例項。物件包括兩個資料成員(類變數和例項變數)和方法。

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

Python中的類提供了面向物件程式設計的所有基本功能:類的繼承機制允許多個基類,派生類可以覆蓋基類中的任何方法,方法中可以呼叫基類中的同名方法。

物件可以包含任意數量和型別的資料。

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

1 class Cat:
2     def eat(self):
3         print("貓吃魚")
4         
5 cat = Cat()
6 cat.eat()  # 貓吃魚

如上 ,我們定義了一個 Cat 類,裡面定義了一個方法,我們可以通過 變數=類名() 的方式來例項化一個類,這樣我們就可以呼叫類裡面的屬性和方法,所以當我們呼叫 cat.eat() 時輸出列印 Cat 類裡面的 eat() 方法。

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

 1 class Cat:
 2     def eat(self):
 3         print(self.name+"吃魚")
 4 
 5 
 6 tom = Cat()
 7 tom.name = "Tom"
 8 tom.eat()  # Tom吃魚
 9 
10 jerry = Cat()
11 jerry.name = "Jerry"
12 jerry.eat()  # Jerry吃魚

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

上面的程式碼中我們可以實現輸出不同的 name 值,但是需要我們在例項化後自己定義 name,我們也可以在定義類的時候就將 name 值傳入來做:

 1 class Cat:
 2     def __init__(self,name):
 3         self.name = name
 4     def eat(self):
 5         print(self.name+"吃魚")
 6 
 7 tom = Cat("Tom")
 8 tom.eat()  # Tom吃魚
 9 
10 jerry = Cat("Jerry")
11 jerry.eat()  # Jerry吃魚

上面的程式碼中,我們在 Cat 類中定義了一個 __init__() 的方法,該方法是類自帶的方法,第一個引數必須為 self,我們可以在裡面定義自己所需的變數。如上,我們在例項化 Cat 類的時候就將 Tom ,Jeery 傳入,然後在 self 形參後面新增形參,該形參與傳入引數的順序意義對應,這樣我們就可以使用傳入的引數了,定義和使用時需要在前面加 self. 

在上面的程式碼演示中,我們可以看出當我們例項化一個類之後,就能呼叫該類的方法,這種方法叫公有方法,還有一種方法叫私有方法,就是例項化後不能被呼叫,只有自己內部可以呼叫,如下:

 1 class Cat:
 2     def __init__(self,name):
 3         self.name= name
 4     def eat(self):
 5         print(self.name+"吃魚")
 6         self.__run()
 7     def __run(self):
 8         print("私有方法")
 9 
10 tom = Cat("Tom")
11 tom.eat()  # Tom吃魚  私有方法
12 tom.__run()  # AttributeError: 'Cat' object has no attribute '__run'

上面的程式碼中當我們例項化 tom 後,可以通過 eat() 方法呼叫到 __run() 方法,但是直接呼叫 __run() 會報錯。

不僅私有方法不能被呼叫,私有屬性也不能,如下:

 1 class Cat:
 2     age = 11
 3     __height = 120
 4     def add(self):
 5         self.age += 1
 6         self.__height += 1
 7 
 8 tom = Cat()
 9 tom.add()
10 print(tom.age)  # 12
11 print(tom.__height)  # AttributeError: 'Cat' object has no attribute '__height'

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

 1 class Animal:
 2     def eat(self):
 3         print("吃吃吃")
 4 
 5 class Cat(Animal):
 6     def bark(self):
 7         print("喵喵喵")
 8 
 9 class Dog(Animal):
10     def bark(self):
11         print("汪汪汪")
12 
13     def swim(self):
14         print("狗刨式")
15 
16 cat = Cat()
17 cat.eat()  # 吃吃吃
18 cat.bark()  # 喵喵喵
19 cat.swim()  # AttributeError: 'Cat' object has no attribute 'swim'
20 
21 dog = Dog()
22 dog.eat()  # 吃吃吃
23 dog.bark()  # 汪汪汪
24 dog.swim()  # 狗刨式

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

當然我們可以讓 Cat 類也繼承 Dog 類,如下:

 1 class Animal:
 2     def eat(self):
 3         print("吃吃吃")
 4 # Cat 類要想繼承 Dog 類必須寫在 Dog 類後面
 5 # class Cat(Dog,Animal):
 6 #     def bark(self):
 7 #         print("喵喵喵")
 8 
 9 class Dog(Animal):
10     def bark(self):
11         print("汪汪汪")
12     def swim(self):
13         print("狗刨式")
14 
15 class Cat(Dog,Animal):
16     def bark(self):
17         print("喵喵喵")
18 
19 cat = Cat()
20 cat.eat()  # 吃吃吃
21 cat.bark()  # 喵喵喵
22 cat.swim()  # 狗刨式
23 
24 dog = Dog()
25 dog.eat()  # 吃吃吃
26 dog.bark()  # 汪汪汪
27 dog.swim()  # 狗刨式

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

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

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

 

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

 1 class Animal:
 2     def eat(self):
 3         print("吃吃吃")
 4 
 5 class Cat(Animal):
 6     pass
 7 
 8 class Dog(Animal):
 9     def eat(self):
10         print("大口大口吃")
11 
12 cat = Cat()
13 cat.eat()  # 吃吃吃
14 
15 dog = Dog()
16 dog.eat()  # 大口大口吃

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

 

在上面我們說過了類屬性和例項方法,接下來我們來看一下類方法:

 1 class Cat:
 2     # 類屬性
 3     age = 10
 4 
 5     # 例項方法
 6     def __init__(self):
 7         self.name = "Tom"
 8 
 9     def info(self):
10         print(self.name, self.age)
11 
12     # 類方法
13     @classmethod
14     def addAge(cls):
15         cls.age = 22
16 
17 tom = Cat()
18 tom.info()  # Tom 10
19 Cat.info()  # TypeError: info() missing 1 required positional argument: 'self'
20 
21 tom.addAge()
22 print(tom.age)  # 22
23 print(Cat.age)  # 22
24 
25 Cat.addAge()
26 print(tom.age)  # 22
27 print(Cat.age)  # 22

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

當我們例項化一個 tom 後,我們就可以呼叫 tom 裡面的例項方法,我們之前說過 self 指的是該類的例項化,所以當我們呼叫 tom.info() 時能正常呼叫,但是 Cat.info() 時則會報錯,因為裡面的 self 指向的是例項化的 tom,而不是 Cat 類,所以會報錯。

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

&n