Python 面向對象（初級篇）

51CTO同步釋出位址：http://3060674.blog.51cto.com/3050674/1689163

概述

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

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

while True：
	if cpu使用率 > 90%:
		#發送郵件提醒
		連接配接郵箱伺服器
		發送郵件
		關閉連接配接

	if 硬碟使用空間 > 90%:
		#發送郵件提醒
		連接配接郵箱伺服器
		發送郵件
		關閉連接配接

	if 記憶體占用 > 80%:
		#發送郵件提醒
		連接配接郵箱伺服器
		發送郵件
		關閉連接配接

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

def 發送郵件(内容)
	#發送郵件提醒
	連接配接郵箱伺服器
	發送郵件
	關閉連接配接

while True：

	if cpu使用率 > 90%:
		發送郵件('CPU報警')

	if 硬碟使用空間 > 90%:
		發送郵件('硬碟報警')

	if 記憶體占用 > 80%:
		發送郵件('記憶體報警')

今天我們來學習一種新的程式設計方式：面向對象程式設計（Object Oriented Programming，OOP，面向對象程式設計）

注：Java和C#來說隻支援面向對象程式設計，而python比較靈活即支援面向對象程式設計也支援函數式程式設計

建立類和對象

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

　　類就是一個模闆，模闆裡可以包含多個函數，函數裡實作一些功能

　　對象則是根據模闆建立的執行個體，通過執行個體對象可以執行類中的函數

class是關鍵字，表示類
建立對象，類名稱後加括号即可

ps：類中的函數第一個參數必須是self（詳細見：類的三大特性之封裝）

　　類中定義的函數叫做 “方法”

# 建立類
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 在記憶體中儲存的方式，根據儲存格式可以如此調用被封裝的内容：對象.屬性名

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間接調用被封裝的内容

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歲，男，最愛大保健

老張...

Python 面向對象（初級篇）

Python 面向對象（初級篇）
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, '男')      
函數式程式設計

Python 面向對象（初級篇）

Python 面向對象（初級篇）
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('老李', 90, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()      
面向對象

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

練習二：遊戲人生程式

1、建立三個遊戲人物，分别是：

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

2、遊戲場景，分别：

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

Python 面向對象（初級篇）

# -*- 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()

遊戲人生

二、繼承

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

例如：

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

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

如果我們要分别為貓和狗建立一個類，那麼就需要為貓和狗實作他們所有的功能，如下所示：

Python 面向對象（初級篇）

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

僞代碼

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

　　動物：吃、喝、拉、撒

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

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

Python 面向對象（初級篇）

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 '喵喵叫'

僞代碼

Python 面向對象（初級篇）

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()

代碼執行個體

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

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

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

Python 面向對象（初級篇）

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、Python的類可以繼承多個類，Java和C#中則隻能繼承一個類

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

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

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

Python 面向對象（初級篇）

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()

經典類多繼承

Python 面向對象（初級篇）

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崇尚“鴨子類型”。

Python 面向對象（初級篇）

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

Python僞代碼實作Java或C#的多态

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)

Python “鴨子類型”

總結

以上就是本節對于面向對象初級知識的介紹，總結如下：

面向對象是一種程式設計方式，此程式設計方式的實作是基于對類和對象的使用
類是一個模闆，模闆中包裝了多個“函數”供使用
對象，根據模闆建立的執行個體（即：對象），執行個體用于調用被包裝在類中的函數
面向對象三大特性：封裝、繼承和多态

問答專區

問題一：什麼樣的代碼才是面向對象？

答：從簡單來說，如果程式中的所有功能都是用類和對象來實作，那麼就是面向對象程式設計了。

問題二：函數式程式設計和面向對象如何選擇？分别在什麼情況下使用？

答：須知：對于 C# 和 Java 程式員來說不存在這個問題，因為該兩門語言隻支援面向對象程式設計（不支援函數式程式設計）。而對于 Python 和 PHP 等語言卻同時支援兩種程式設計方式，且函數式程式設計能完成的操作，面向對象都可以實作；而面向對象的能完成的操作，函數式程式設計不行（函數式程式設計無法實作面向對象的封裝功能）。

是以，一般在Python開發中，全部使用面向對象或面向對象和函數式混合使用

面向對象的應用場景:

多函數需使用共同的值，如：資料庫的增、删、改、查操作都需要連接配接資料庫字元串、主機名、使用者名和密碼

Python 面向對象（初級篇）

class SqlHelper:

    def __init__(self, host, user, pwd):

        self.host = host
        self.user = user
        self.pwd = pwd

    def 增(self):
        # 使用主機名、使用者名、密碼（self.host 、self.user 、self.pwd）打開資料庫連接配接
        # do something
        # 關閉資料庫連接配接

    def 删(self):
        # 使用主機名、使用者名、密碼（self.host 、self.user 、self.pwd）打開資料庫連接配接
        # do something
        # 關閉資料庫連接配接

    def 改(self):
        # 使用主機名、使用者名、密碼（self.host 、self.user 、self.pwd）打開資料庫連接配接
        # do something
        # 關閉資料庫連接配接

    def 查(self):
    # 使用主機名、使用者名、密碼（self.host 、self.user 、self.pwd）打開資料庫連接配接
        # do something
        # 關閉資料庫連接配接# do something

Demo

需要建立多個事物，每個事物屬性個數相同，但是值的需求

如：張三、李四、楊五，他們都有姓名、年齡、血型，但其都是不相同。即：屬性個數相同，但值不相同

Python 面向對象（初級篇）

class Person:

    def __init__(self, name ,age ,blood_type):

        self.name = name
        self.age = age
        self.blood_type = blood_type


    def detail(self):
        temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
        print temp

zhangsan = Person('張三', 18, 'A')
lisi = Person('李四', 73, 'AB')
yangwu = Person('楊五', 84, 'A')

問題三：類和對象在記憶體中是如何儲存？

答：類以及類中的方法在記憶體中隻有一份，而根據類建立的每一個對象都在記憶體中需要存一份，大緻如下圖：

如上圖所示，根據類建立對象時，對象中除了封裝 name 和 age 的值之外，還會儲存一個類對象指針，該值指向目前對象的類。

當通過 obj1 執行【方法一】時，過程如下：

根據目前對象中的類對象指針找到類中的方法
将對象 obj1 當作參數傳給方法的第一個參數 self

以上是本篇文章的全部内容，如果覺得有點點意思，右邊的推薦再等你喲 ! 下一篇《面向對象進階篇》

作者：武沛齊

出處：http://www.cnblogs.com/wupeiqi/

本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段聲明，且在文章頁面明顯位置給出原文連接配接。

Python 面向對象（初級篇）

概述

建立類和對象

面向對象三大特性

總結

繼續閱讀

來自python的【條件控制/語句循環/break/continue/else/pass】一、條件控制二、語句循環

無法解析的外部符号 wmain，該符号在函數 "void cdecl mainCRTStartupHelper(struct HINSTANCE *,unsigned short con......

TestLink導出用例轉換工具(XML2Excel)

YAML簡介和PyYAML安全操作YAML支援的類型YAML的優點：yaml的基本文法python操作

Small tricks

libsvm for python 安裝

學習軟體測試基礎測試第七天

Zeppelin 配置通路 REST APIApache Zeppelin Configuration REST API

【Torch】最簡潔logging使用指南

27. Remove Element(清單)題目代碼

Cloud Studio初體驗

使用 ctypes 進行 Python 和 C 的混合程式設計

【python】【資料處理】畫多元資料分布圖

【python】netconf協定對接管理裝置

「Python 網絡自動化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 網絡裝置

在python中建立excel并寫入