當前位置：首頁 > 编程语言 > python >内容正文

python

面向对象编程其实很简单——Python 面向对象（初级篇）

發布時間：2025/3/15 python 24 豆豆

生活随笔收集整理的這篇文章主要介紹了面向对象编程其实很简单——Python 面向对象（初级篇）小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

在Python教學中發現，很多同學在走到面向對象編程這塊就開始蒙圈了，為了幫助大家更好的理解面向對象編程并其能將其用到自己的開發過程中，特寫此文。

概述

面向過程：根據業務邏輯從上到下寫壘代碼
函數式：將某功能代碼封裝到函數中，日后便無需重復編寫，僅調用函數即可
面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”

面向過程編程最易被初學者接受，其往往用一長段代碼來實現指定功能，開發過程中最常見的操作就是粘貼復制，即：將之前實現的代碼塊復制到現需功能處。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

while?True： ????if?cpu利用率?>?90%: ????????#發送郵件提醒 ????????連接郵箱服務器 ????????發送郵件 ????????關閉連接 ?? ????if?硬盤使用空間?>?90%: ????????#發送郵件提醒 ????????連接郵箱服務器 ????????發送郵件 ????????關閉連接 ?? ????if?內存占用?>?80%: ????????#發送郵件提醒 ????????連接郵箱服務器 ????????發送郵件 ????????關閉連接

隨著時間的推移，開始使用了函數式編程，增強代碼的重用性和可讀性，就變成了這樣：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

def?發送郵件(內容) ????#發送郵件提醒 ????連接郵箱服務器 ????發送郵件 ????關閉連接 ?? while?True： ?? ????if?cpu利用率?>?90%: ????????發送郵件('CPU報警') ?? ????if?硬盤使用空間?>?90%: ????????發送郵件('硬盤報警') ?? ????if?內存占用?>?80%: ????????發送郵件('內存報警')

今天我們來學習一種新的編程方式：面向對象編程（Object Oriented Programming，OOP，面向對象程序設計）
注：Java和C#來說只支持面向對象編程，而python比較靈活即支持面向對象編程也支持函數式編程

創建類和對象

面向對象編程是一種編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實現，所以，面向對象編程其實就是對 “類” 和 “對象” 的使用。

　　類就是一個模板，模板里可以包含多個函數，函數里實現一些功能

　　對象則是根據模板創建的實例，通過實例對象可以執行類中的函數

class是關鍵字，表示類
創建對象，類名稱后加括號即可

ps：類中的函數第一個參數必須是self（詳細見：類的三大特性之封裝）
　　類中定義的函數叫做 “方法”

1 2 3 4 5 6 7 8 9 10 11 12 13

#?創建類 class?Foo: ?????? ????def?Bar(self): ????????print?'Bar' ?? ????def?Hello(self,?name): ????????print?'i?am?%s'?%name ?? #?根據類Foo創建對象obj obj?=?Foo() obj.Bar()????????????#執行Bar方法 obj.Hello('wupeiqi')?#執行Hello方法

誒，你在這里是不是有疑問了？使用函數式編程和面向對象編程方式來執行一個“方法”時函數要比面向對象簡便

面向對象：【創建對象】【通過對象執行方法】
函數編程：【執行函數】

觀察上述對比答案則是肯定的，然后并非絕對，場景的不同適合其的編程方式也不同。

總結：函數式的應用場景 --> 各個函數之間是獨立且無共用的數據

面向對象三大特性

面向對象的三大特性是指：封裝、繼承和多態。

一、封裝

封裝，顧名思義就是將內容封裝到某個地方，以后再去調用被封裝在某處的內容。

所以，在使用面向對象的封裝特性時，需要：

將內容封裝到某處
從某處調用被封裝的內容

第一步：將內容封裝到某處

?self 是一個形式參數，當執行 obj1 = Foo('wupeiqi', 18 ) 時，self 等于 obj1

? ? ? ? ? ? ? ? ? ? ? ? ? ? ??當執行 obj2 = Foo('alex', 78 ) 時，self 等于 obj2

所以，內容其實被封裝到了對象 obj1 和 obj2 中，每個對象中都封裝了 name 和 age ，之前說的“內容封裝到某處”其在內容里類似于下圖來保存。

第二步：從某處調用被封裝的內容

調用被封裝的內容時，有兩種情況：

通過對象直接調用
通過self間接調用

1、通過對象直接調用被封裝的內容

上圖展示了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式可以如此調用被封裝的內容：對象.屬性名

1 2 3 4 5 6 7 8 9 10 11 12 13

class?Foo: ?? ????def?__init__(self,?name,?age): ????????self.name?=?name ????????self.age?=?age ?? obj1?=?Foo('wupeiqi',?18) print?obj1.name????#?直接調用obj1對象的name屬性 print?obj1.age?????#?直接調用obj1對象的age屬性 ?? obj2?=?Foo('alex',?73) print?obj2.name????#?直接調用obj2對象的name屬性 print?obj2.age?????#?直接調用obj2對象的age屬性

2、通過self間接調用被封裝的內容

執行類中的方法時，需要通過self間接調用被封裝的內容

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

class?Foo: ??? ????def?__init__(self,?name,?age): ????????self.name?=?name ????????self.age?=?age ??? ????def?detail(self): ????????print?self.name ????????print?self.age ??? obj1?=?Foo('wupeiqi',?18) obj1.detail()??#?Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，所以，此時方法內部的?self?＝?obj1，即：self.name?是?wupeiqi?；self.age?是?18 ??? obj2?=?Foo('alex',?73) obj2.detail()??#?Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，所以，此時方法內部的?self?＝?obj2，即：self.name?是?alex?；?self.age?是?78

綜上所述，對于面向對象的封裝來說，其實就是使用構造方法將內容封裝到對象中，然后通過對象直接或者self間接獲取被封裝的內容。

練習一：在終端輸出如下信息

小明，10歲，男，上山去砍柴
小明，10歲，男，開車去東北
小明，10歲，男，最愛大保健
?
老李，90歲，男，上山去砍柴
老李，90歲，男，開車去東北
老李，90歲，男，最愛大保健
?
老張...

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

函數式編程 def?kanchai(name,?age,?gender): ????print?"%s,%s歲,%s,上山去砍柴"?%(name,?age,?gender) def?qudongbei(name,?age,?gender): ????print?"%s,%s歲,%s,開車去東北"?%(name,?age,?gender) def?dabaojian(name,?age,?gender): ????print?"%s,%s歲,%s,最愛大保健"?%(name,?age,?gender) kanchai('小明',?10,?'男') qudongbei('小明',?10,?'男') dabaojian('小明',?10,?'男') kanchai('老李',?90,?'男') qudongbei('老李',?90,?'男') dabaojian('老李',?90,?'男')

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class?Foo: ????? ????def?__init__(self,?name,?age?,gender): ????????self.name?=?name ????????self.age?=?age ????????self.gender?=?gender ????def?kanchai(self): ????????print?"%s,%s歲,%s,上山去砍柴"?%(self.name,?self.age,?self.gender) ????def?qudongbei(self): ????????print?"%s,%s歲,%s,開車去東北"?%(self.name,?self.age,?self.gender) ????def?dabaojian(self): ????????print?"%s,%s歲,%s,最愛大保健"?%(self.name,?self.age,?self.gender) xiaoming?=?Foo('小明',?10,?'男') xiaoming.kanchai() xiaoming.qudongbei() xiaoming.dabaojian() laoli?=?Foo('小明',?10,?'男') laoli.kanchai() laoli.qudongbei() laoli.dabaojian()

上述對比可以看出，如果使用函數式編程，需要在每次執行函數時傳入相同的參數，如果參數多的話，又需要粘貼復制了... ?；而對于面向對象只需要在創建對象時，將所有需要的參數封裝到當前對象中，之后再次使用時，通過self間接去當前對象中取值即可。

練習二：游戲人生程序

1、創建三個游戲人物，分別是：

蒼井井，女，18，初始戰斗力1000
東尼木木，男，20，初始戰斗力1800
波多多，女，19，初始戰斗力2500

2、游戲場景，分別：

草叢戰斗，消耗200戰斗力
自我修煉，增長100戰斗力
多人游戲，消耗500戰斗力

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

#?-*-?coding:utf-8?-*- #?#####################??定義實現功能的類??##################### class?Person: ????def?__init__(self,?na,?gen,?age,?fig): ????????self.name?=?na ????????self.gender?=?gen ????????self.age?=?age ????????self.fight?=fig ????def?grassland(self): ????????"""注釋：草叢戰斗，消耗200戰斗力""" ????????self.fight?=?self.fight?-?200 ????def?practice(self): ????????"""注釋：自我修煉，增長100戰斗力""" ????????? ????????self.fight?=?self.fight?+?200 ????def?incest(self): ????????"""注釋：多人游戲，消耗500戰斗力""" ????????? ????????self.fight?=?self.fight?-?500 ????def?detail(self): ????????"""注釋：當前對象的詳細情況""" ????????temp?=?"姓名:%s?;?性別:%s?;?年齡:%s?;?戰斗力:%s"??%?(self.name,?self.gender,?self.age,?self.fight) ????????print?temp ????????? #?#####################??開始游戲??##################### cang?=?Person('蒼井井',?'女',?18,?1000)????#?創建蒼井井角色 dong?=?Person('東尼木木',?'男',?20,?1800)??#?創建東尼木木角色 bo?=?Person('波多多',?'女',?19,?2500)??????#?創建波多多角色 cang.incest()?#蒼井空參加一次多人游戲 dong.practice()#東尼木木自我修煉了一次 bo.grassland()?#波多多參加一次草叢戰斗 #輸出當前所有人的詳細情況 cang.detail() dong.detail() bo.detail() cang.incest()?#蒼井空又參加一次多人游戲 dong.incest()?#東尼木木也參加了一個多人游戲 bo.practice()?#波多多自我修煉了一次 #輸出當前所有人的詳細情況 cang.detail() dong.detail() bo.detail() 游戲人生

二、繼承

繼承，面向對象中的繼承和現實生活中的繼承相同，即：子可以繼承父的內容。

例如：

　　貓可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我們要分別為貓和狗創建一個類，那么就需要為貓和狗實現他們所有的功能，如下所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

偽代碼 class?貓： ????def?喵喵叫(self): ????????print?'喵喵叫' ????def?吃(self): ????????#?do?something ????def?喝(self): ????????#?do?something ????def?拉(self): ????????#?do?something ????def?撒(self): ????????#?do?something class?狗： ????def?汪汪叫(self): ????????print?'喵喵叫' ????def?吃(self): ????????#?do?something ????def?喝(self): ????????#?do?something ????def?拉(self): ????????#?do?something ????def?撒(self): ????????#?do?something

上述代碼不難看出，吃、喝、拉、撒是貓和狗都具有的功能，而我們卻分別的貓和狗的類中編寫了兩次。如果使用繼承的思想，如下實現：

　　動物：吃、喝、拉、撒

　　 ? 貓：喵喵叫（貓繼承動物的功能）

　　 ? 狗：汪汪叫（狗繼承動物的功能）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

偽代碼 class?動物: ????def?吃(self): ????????#?do?something ????def?喝(self): ????????#?do?something ????def?拉(self): ????????#?do?something ????def?撒(self): ????????#?do?something #?在類后面括號中寫入另外一個類名，表示當前類繼承另外一個類 class?貓(動物)： ????def?喵喵叫(self): ????????print?'喵喵叫' ????????? #?在類后面括號中寫入另外一個類名，表示當前類繼承另外一個類 class?狗(動物)： ????def?汪汪叫(self): ????????print?'喵喵叫'

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

代碼實例 class?Animal: ????def?eat(self): ????????print?"%s?吃?"?%self.name ????def?drink(self): ????????print?"%s?喝?"?%self.name ????def?shit(self): ????????print?"%s?拉?"?%self.name ????def?pee(self): ????????print?"%s?撒?"?%self.name class?Cat(Animal): ????def?__init__(self,?name): ????????self.name?=?name ????????self.breed?＝?'貓' ????def?cry(self): ????????print?'喵喵叫' class?Dog(Animal): ????? ????def?__init__(self,?name): ????????self.name?=?name ????????self.breed?＝?'狗' ????????? ????def?cry(self): ????????print?'汪汪叫' ????????? #?#########?執行?######### c1?=?Cat('小白家的小黑貓') c1.eat() c2?=?Cat('小黑的小白貓') c2.drink() d1?=?Dog('胖子家的小瘦狗') d1.eat()

所以，對于面向對象的繼承來說，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而不必一一實現每個方法。

注：除了子類和父類的稱謂，你可能看到過派生類和基類，他們與子類和父類只是叫法不同而已。

學習了繼承的寫法之后，我們用代碼來是上述阿貓阿狗的功能：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

那么問題又來了，多繼承呢？

是否可以繼承多個類
如果繼承的多個類每個類中都定了相同的函數，那么那一個會被使用呢？

1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類

2、Python的類如果繼承了多個類，那么其尋找方法的方式有兩種，分別是：深度優先和廣度優先

當類是經典類時，多繼承情況下，會按照深度優先方式查找
當類是新式類時，多繼承情況下，會按照廣度優先方式查找

經典類和新式類，從字面上可以看出一個老一個新，新的必然包含了跟多的功能，也是之后推薦的寫法，從寫法上區分的話，如果?當前類或者父類繼承了object類，那么該類便是新式類，否則便是經典類。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

經典類多繼承 class?D: ????def?bar(self): ????????print?'D.bar' class?C(D): ????def?bar(self): ????????print?'C.bar' class?B(D): ????def?bar(self): ????????print?'B.bar' class?A(B,?C): ????def?bar(self): ????????print?'A.bar' a?=?A() #?執行bar方法時 #?首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中么有，則繼續去D類中找，如果D類中么有，則繼續去C類中找，如果還是未找到，則報錯 #?所以，查找順序：A?-->?B?-->?D?-->?C #?在上述查找bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了 a.bar()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

新式類多繼承 class?D(object): ????def?bar(self): ????????print?'D.bar' class?C(D): ????def?bar(self): ????????print?'C.bar' class?B(D): ????def?bar(self): ????????print?'B.bar' class?A(B,?C): ????def?bar(self): ????????print?'A.bar' a?=?A() #?執行bar方法時 #?首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中么有，則繼續去C類中找，如果C類中么有，則繼續去D類中找，如果還是未找到，則報錯 #?所以，查找順序：A?-->?B?-->?C?-->?D #?在上述查找bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了 a.bar()

經典類：首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中么有，則繼續去D類中找，如果D類中么有，則繼續去C類中找，如果還是未找到，則報錯

新式類：首先去A類中查找，如果A類中沒有，則繼續去B類中找，如果B類中么有，則繼續去C類中找，如果C類中么有，則繼續去D類中找，如果還是未找到，則報錯

注意：在上述查找過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了

三、多態?

?Pyhon不支持多態并且也用不到多態，多態的概念是應用于Java和C#這一類強類型語言中，而Python崇尚“鴨子類型”。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

Python偽代碼實現Java或C#的多態 class?F1: ????pass class?S1(F1): ????def?show(self): ????????print?'S1.show' class?S2(F1): ????def?show(self): ????????print?'S2.show' #?由于在Java或C#中定義函數參數時，必須指定參數的類型 #?為了讓Func函數既可以執行S1對象的show方法，又可以執行S2對象的show方法，所以，定義了一個S1和S2類的父類 #?而實際傳入的參數是：S1對象和S2對象 def?Func(F1?obj): ????"""Func函數需要接收一個F1類型或者F1子類的類型""" ????? ????print?obj.show() ????? s1_obj?=?S1() Func(s1_obj)?#?在Func函數中傳入S1類的對象?s1_obj，執行?S1?的show方法，結果：S1.show s2_obj?=?S2() Func(s2_obj)?#?在Func函數中傳入Ss類的對象?ss_obj，執行?Ss?的show方法，結果：S2.show

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Python?“鴨子類型” class?F1: ????pass class?S1(F1): ????def?show(self): ????????print?'S1.show' class?S2(F1): ????def?show(self): ????????print?'S2.show' def?Func(obj): ????print?obj.show() s1_obj?=?S1() Func(s1_obj)? s2_obj?=?S2() Func(s2_obj)

轉載于:https://www.cnblogs.com/wanghuaijun/p/5951864.html

總結

以上是生活随笔為你收集整理的面向对象编程其实很简单——Python 面向对象（初级篇）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。