Python3.5中面向對象編程的示例分析

這篇文章給大家分享的是有關Python3.5中面向對象編程的示例分析的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

具體如下：

1、面向過程與面向對象的比較

（1）面向過程編程（procedural programming）

面向過程編程又被稱為：top-down languages，程序從上到下 一步步執行，從頭到尾的解決問題。

基本設計思路為：程序一開始是解決一個大問題，然后把大問題分解成多個小問題或子過程，這些小問題執行的時候再繼續分解，

直到小問題足夠簡單到可以在一個小范圍內解決。

缺點：若程序要進行修改，則修改的部分依賴的各個部分也要修改，這樣會發生一連串的影響，隨著程序越來越大，編程方式的維護難度也會越來越高。

所以，如果寫一下簡單的腳本，去做一些一次性的任務，用面向過程的方式是極好的，如果要處理的任務是復雜的，且需要不斷迭代和維護的，還是用面向對象是最方便的。

（2）面向對象編程（oop）

面向對象編程是利用“類”和“對象”來創建各種模型來實現對真實世界的描述。

優點：可以使程序的維護和擴展變得簡單，并且可以大大提高程序的開發效率；另外，基于對象的程序編程，可以讓別人更加理解你的代碼邏輯，是團隊開發變得更加從容。

核心的特征：世界萬物皆對象，世界萬物皆可分類。

a、類（class）

類：是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象都具備的屬性、共同的方法。

b、對象（object）

對象：類實例化后的實例，一個類必須經過實例化方能在程序中調用。

一個類可以實例化多個對象，每個對象可以有不同的屬性。人類是指使用的人，每個人是指具體的對象。

c、封裝（encapsulation）

在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，里面包含著類的數據和方法。

d、繼承（Inheritance）

一個類可以派生出子類，在這個父類里定義的屬性、方法自動被子類繼承。

e、多態（Polymorphism）

多態：是面向對象的重要特性,簡單點說：“一個接口，多種實現”，指一個基類中派生出了不同的子類，

且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。

編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現。

把一系列具體事物的共同點抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。

多態允許將子類的對象當作父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。

這里引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象可以在運行期間動態綁定。

2、面向對象編程

（1）無論什么形式的編程，都要明確一下原則：寫重復的代碼是非常不好的地級行為；之前寫的代碼需要不斷的更新。

所以，開發的程序要遵循易讀、易改的原則，即：可讀性好、易擴展。

（2）示例代碼：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu

#面向對象--CS游戲模擬

class Role(object):
  def __init__(self,name,role,weapon,life_value=100,money=15000):
    self.name = name
    self.role = role
    self.weapon = weapon
    self.life_value = life_value
    self.money = money

  def shot(self):
    print("shotting...")

  def got_shot(self):
    print("ah...%s got shot..." %self.name)

  def buy_gun(self,gun_name):
    print("%s just bought %s" %(self.name,gun_name))

r1 = Role("Jack","police","AK-47")  #實例化（初始化一個類，創建了一個對象）
r1.buy_gun("B51")

r2 = Role("Amy","terrorist","B22") 
r2.got_shot()

運行結果：

Jack just bought B51
ah...Amy got shot...

注：

a、類的基本定義

第一句：定義一個類，class是定義類的語法，Role是類名，（object）是新式類的寫法，必須這樣寫；

第二句：__init__()叫做初始化方法，也叫構造方法（雖然它是函數的形式，但在類中就不叫函數了，叫做方法），在類被調用時這個方法會自動執行，進行一些初始化動作，

所以__init__(self,name,role,weapon,life_value=100,money=15000)就是要在創建一個角色時給它設置這些屬性。

b、實例化：把一個類變成一個具體的對象的過程叫實例化。

在這里，實例化生成一個角色，會自動把參數傳給類Role下面的__init__(...)方法。

初始化一個角色，就需要調用這個類一次；上面的創建角色時，并沒有給__init__(...)傳值，是因為類在調用它自己的__init__(...)是自己幫你給self參數賦值了。

執行r1 = Role('liu','police','AK47')時，python的解釋器其實干了兩件事：
1、  在內存中開辟一塊空間指向r1這個變量名。
2、  調用Role這個類并執行其中的__init__(…)方法，相當于Role.__init__(r1,'Jack','police','AK47'),這么做是為什么呢？ 

是為了把'Jack','police','AK47'這3個值跟剛開辟的r1關聯起來，因為關聯起來后，你就可以直接r1.name, r1.weapon 這樣來調用。

所以，為實現這種關聯，在調用__init__方法時，就必須把r1這個變量也傳進去，否則__init__不知道要把那3個參數跟誰關聯。

所以這個__init__(…)方法里的，self.name = name , self.role = role 等等的意思就是要把這幾個值 存到r1的內存空間里。

結：self就是示例本身，實例化時Python會自動把這個示例本身通過self參數傳遞進去。

r1.buy_gun("B51")===》Python會自動轉換成：Role.buy_gun(r1,"B51”)

依然沒給self傳值 ，但Python還是會自動的幫你把r1 賦值給self這個參數， 為什么呢？ 因為，你在buy_gun(..)方法中可能要訪問r1的一些其它屬性， 

比如這里就訪問 了r1的名字，怎么訪問呢？你得告訴這個方法，于是就把r1傳給了這個self參數，然后在buy_gun里調用 self.name 就相當于調用r1.name ，

如果還想知道r1的生命值 有多少，直接寫成self.life_value就可以了。

總結：

a、上面的這個r1 = Role('Alex','police','AK47')動作，叫做類的“實例化”， 就是把一個虛擬的抽象的類，通過這個動作，變成了一個具體的對象了， 這個對象就叫做實例。
b、剛才定義的這個類體現了面向對象的第一個基本特性，封裝，其實就是使用構造方法將內容封裝到某個具體對象中，然后通過對象直接或者self間接獲取被封裝的內容。

3、實例變量與類變量

（1）類變量：存在類的內存中，沒有實例化即可使用；實例化后，通過實例也可調用類變量。作用：共用的屬性，節省開銷。

（2）實例變量：描述某個具體對象一些特定的屬性，只能在實例本身中使用。

（3）區別：若一個類中，既有類變量name，又有實例變量name，則先找實例變量，實例變量沒有的情況下，再找類變量。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu

#面向對象--CS游戲模擬

class Role(object):
  n = 123   #類變量
  def __init__(self,name,role,weapon,life_value=100,money=15000):
    #構造函數
    #作用：在實例化時做一些類的初始化工作
    self.name = name    #實例變量（靜態屬性），作用域就是實例本身
    self.role = role
    self.weapon = weapon
    self.life_value = life_value
    self.money = money

  def shot(self):   #類的方法（功能）--動態屬性
    print("shotting...")

  def got_shot(self):
    print("ah...%s got shot..." %self.name)

  def buy_gun(self,gun_name):
    print("%s just bought %s" %(self.name,gun_name))

#r1是類Role的一個實例化對象
# 實例化就是以類Role為模板，在內存開辟一塊空間，存上數據，賦值成一個變量名
#實例化（初始化一個類，創建了一個對象）
r1 = Role("Jack","police","AK-47")  #此時self相當于r1,Role(r1,"Jack","police","AK-47")
r1.buy_gun("B51")    #r1也被稱作Role的一個實例

r1.name = "liu"   #修改r1的實例變量
r1.n = "改變類變量"  #在r1中修改類變量n的值，相當于創建一個n，不會影響r2
r1.bullet_prove = True   #添加新的屬性，只能在r1中使用
print(r1.n)

r2 = Role("Amy","terrorist","B22") #此時self相當于r2,Role(r2,"Amy","terrorist","B22")
r2.got_shot()
print(r2.n)

Role.n = "abc"   #通過類名修改類變量的值
print("r1:",r1.n)
print("r2:",r2.n)

運行結果：

liu just bought B51
改變類變量
ah...Amy got shot...
123
r1: 改變類變量
r2: abc

4、析構函數        def __del__(self):

作用：在實例銷毀/釋放時自動執行，通常用于做一些收尾工作，如：關閉一些數據庫鏈接，關閉打開臨時的文件。

析構函數的調用順序與構造方法的調用順序相反。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu

#面向對象--CS游戲模擬

class Role(object):
  n = 123   #類變量
  def __init__(self,name,role,weapon,life_value=100,money=15000):
    #構造函數
    #作用：在實例化時做一些類的初始化工作
    self.name = name    #實例變量（靜態屬性），作用域就是實例本身
    self.role = role
    self.weapon = weapon
    self.life_value = life_value
    self.money = money

  def __del__(self):   #析構函數
    print("%s game over..." %self.name)

  def shot(self):   #類的方法（功能）--動態屬性
    print("shotting...")

  def got_shot(self):
    print("ah...%s got shot..." %self.name)

  def buy_gun(self,gun_name):
    print("%s just bought %s" %(self.name,gun_name))

r1 = Role("Jack","police","AK-47")
r1.buy_gun("AK47")
r1.got_shot()

r2 = Role("Amy","terrorist","B22")
r2.got_shot()

運行結果：

Jack just bought AK47
ah...Jack got shot...
ah...Amy got shot...
Amy game over...
Jack game over...

5、私有方法、私有屬性（變量）    在變量或者方法前面添加兩個下劃線 "__"，即可變成私有方法、私有屬性

私有屬性只能在類的內部，通過self使用，在類的外部無法直接訪問和修改其內容。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu

#面向對象--CS游戲模擬

class Role(object):
  n = 123   #類變量
  def __init__(self,name,role,weapon,life_value=100,money=15000):
    #構造函數
    #作用：在實例化時做一些類的初始化工作
    self.name = name    #實例變量（靜態屬性），作用域就是實例本身
    self.role = role
    self.weapon = weapon
    self.__life_value = life_value   #私有屬性/私有變量
    self.money = money

  def __del__(self):   #析構函數
    print("%s game over..." %self.name)

  def show_status(self):    #私有屬性只能在類的內部使用
    print("name:%s weapon:%s life_val:%s" %(self.name,self.weapon,self.__life_value))

  def shot(self):   #類的方法（功能）--動態屬性
    print("shotting...")

  def got_shot(self):
    self.__life_value -= 50
    print("ah...%s got shot..." %self.name)

  def buy_gun(self,gun_name):
    print("%s just bought %s" %(self.name,gun_name))

r1 = Role("Jack","police","AK-47")
r1.buy_gun("AK47")
r1.got_shot()
r1.show_status()

運行結果：

Jack just bought AK47
ah...Jack got shot...
name:Jack weapon:AK-47 life_val:50
Jack game over...

感謝各位的閱讀！關于“Python3.5中面向對象編程的示例分析”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！