您现在的位置： Linux教程網 >> UnixLinux > >> Linux編程 >> Linux編程

Python 面向對象編程

　　Python從設計之初就已經是一門面向對象的語言，正因為如此，在Python中創建一個類和對象是很容易的。本章節我們將詳細介紹Python的面向對象編程。

　　如果你以前沒有接觸過面向對象的編程語言，那你可能需要先了解一些面向對象語言的一些基本特征，在頭腦裡頭形成一個基本的面向對象的概念，這樣有助於你更容易的學習Python的面向對象編程。

面向對象技術簡介

類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為實例變量使用。
數據成員：類變量或者實例變量用於處理類及其實例對象的相關的數據。
方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
實例變量：定義在方法中的變量，只作用於當前實例的類。
繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。
實例化：創建一個類的實例，類的具體對象。
方法：類中定義的函數。
對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

創建類

使用class語句來創建一個新類，class之後為類的名稱並以冒號結尾，如下實例:

class ClassName:
   '類的幫助信息'   #類文檔字符串
   class_suite  #類體

　　類的幫助信息可以通過ClassName.__doc__查看。

　　class_suite 由類成員，方法，數據屬性組成。

實例

以下是一個簡單的Python類實例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有員工的基類'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

empCount變量是一個類變量，它的值將在這個類的所有實例之間共享。你可以在內部類或外部類使用Employee.empCount訪問。
第一種方法__init__()方法是一種特殊的方法，被稱為類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法

創建實例對象

　　要創建一個類的實例，你可以使用類的名稱，並通過__init__方法接受參數。

"創建 Employee 類的第一個對象"
emp1 = Employee("Zara", 2000)
"創建 Employee 類的第二個對象"
emp2 = Employee("Manni", 5000)

訪問屬性

　　您可以使用點(.)來訪問對象的屬性。使用如下類的名稱訪問類變量:

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

　　完整實例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有員工的基類'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"創建 Employee 類的第一個對象"
emp1 = Employee("Zara", 2000)
"創建 Employee 類的第二個對象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

　　執行以上代碼輸出結果如下：

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

　　你可以添加，刪除，修改類的屬性，如下所示：

emp1.age = 7  # 添加一個 'age' 屬性
emp1.age = 8  # 修改 'age' 屬性
del emp1.age  # 刪除 'age' 屬性

　　你也可以使用以下函數的方式來訪問屬性：

getattr(obj, name[, default]) : 訪問對象的屬性。
hasattr(obj,name) : 檢查是否存在一個屬性。
setattr(obj,name,value) : 設置一個屬性。如果屬性不存在，會創建一個新屬性。
delattr(obj, name) : 刪除屬性。

hasattr(emp1, 'age')    # 如果存在 'age' 屬性返回 True。
getattr(emp1, 'age')    # 返回 'age' 屬性的值
setattr(emp1, 'age', 8) # 添加屬性 'age' 值為 8
delattr(empl, 'age')    # 刪除屬性 'age'

Python內置類屬性

__dict__ : 類的屬性（包含一個字典，由類的數據屬性組成）
__doc__ :類的文檔字符串
__name__: 類名
__module__: 類定義所在的模塊（類的全名是'__main__.className'，如果類位於一個導入模塊mymod中，那麼className.__module__ 等於 mymod）
__bases__ : 類的所有父類構成元素（包含了以個由所有父類組成的元組）

　　Python內置類屬性調用實例如下：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有員工的基類'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

　　執行以上代碼輸出結果如下：

Employee.__doc__: 所有員工的基類
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x10a939578>}

python對象銷毀(垃圾回收)

　　同Java語言一樣，Python使用了引用計數這一簡單技術來追蹤內存中的對象。

　　在Python內部記錄著所有使用中的對象各有多少引用。

　　一個內部跟蹤變量，稱為一個引用計數器。

　　當對象被創建時，就創建了一個引用計數，當這個對象不再需要時，也就是說，這個對象的引用計數變為0 時，它被垃圾回收。但是回收不是"立即"的，由解釋器在適當的時機，將垃圾對象占用的內存空間回收。

a = 40      # 創建對象  <40>
b = a       # 增加引用， <40> 的計數
c = [b]     # 增加引用.  <40> 的計數

del a       # 減少引用 <40> 的計數
b = 100     # 減少引用 <40> 的計數
c[0] = -1   # 減少引用 <40> 的計數

　　垃圾回收機制不僅針對引用計數為0的對象，同樣也可以處理循環引用的情況。循環引用指的是，兩個對象相互引用，但是沒有其他變量引用他們。這種情況下，僅使用引用計數是不夠的。Python 的垃圾收集器實際上是一個引用計數器和一個循環垃圾收集器。作為引用計數的補充，垃圾收集器也會留心被分配的總量很大（及未通過引用計數銷毀的那些）的對象。在這種情況下，解釋器會暫停下來，試圖清理所有未引用的循環。

實例

　　析構函數 __del__ ，__del__在對象消逝的時候被調用，當對象不再被使用時，__del__方法運行：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Point:
   def __init( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "destroyed"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印對象的id
del pt1
del pt2
del pt3

　　以上實例運行結果如下：

3083401324 3083401324 3083401324
Point destroyed

　　注意：通常你需要在單獨的文件中定義一個類，

類的繼承

　　面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是通過繼承機制。繼承完全可以理解成類之間的類型和子類型關系。

　　需要注意的地方：繼承語法 class 派生類名（基類名）：//... 基類名寫作括號裡，基本類是在類定義的時候，在元組之中指明的。

　　在python中繼承中的一些特點：

1：在繼承中基類的構造（__init__()方法）不會被自動調用，它需要在其派生類的構造中親自專門調用。
2：在調用基類的方法時，需要加上基類的類名前綴，且需要帶上self參數變量。區別於在類中調用普通函數時並不需要帶上self參數
3：Python總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）。

　　如果在繼承元組中列了一個以上的類，那麼它就被稱作"多重繼承" 。

語法：

　　派生類的聲明，與他們的父類類似，繼承的基類列表跟在類名之後，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

實例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent:        # 定義父類
   parentAttr = 100
   def __init__(self):
      print "調用父類構造函數"

   def parentMethod(self):
      print '調用父類方法'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "父類屬性 :", Parent.parentAttr

class Child(Parent): # 定義子類
   def __init__(self):
      print "調用子類構造方法"

   def childMethod(self):
      print '調用子類方法 child method'

c = Child()          # 實例化子類
c.childMethod()      # 調用子類的方法
c.parentMethod()     # 調用父類方法
c.setAttr(200)       # 再次調用父類的方法
c.getAttr()          # 再次調用父類的方法

　　以上代碼執行結果如下：

調用子類構造方法
調用子類方法 child method
調用父類方法
父類屬性 : 200

　　你可以繼承多個類

class A:        # 定義類 A
.....

class B:         # 定義類 B
.....

class C(A, B):   # 繼承類 A 和 B
.....

　　你可以使用issubclass()或者isinstance()方法來檢測。

issubclass() - 布爾函數判斷一個類是另一個類的子類或者子孫類，語法：issubclass(sub,sup)
isinstance(obj, Class) 布爾函數如果obj是Class類的實例對象或者是一個Class子類的實例對象則返回true。

方法重寫

如果你的父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法：

實例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent:        # 定義父類
   def myMethod(self):
      print '調用父類��法'

class Child(Parent): # 定義子類
   def myMethod(self):
      print '調用子類方法'

c = Child()          # 子類實例
c.myMethod()         # 子類調用重寫方法

　　執行以上代碼輸出結果如下：

調用子類方法

基礎重載方法

　　下表列出了一些通用的功能，你可以在自己的類重寫：

序號方法, 描述 & 簡單的調用 1 __init__ ( self [,args...] )
構造函數
簡單的調用方法: obj = className(args) 2 __del__( self )
析構方法, 刪除一個對象
簡單的調用方法 : dell obj 3 __repr__( self )
轉化為供解釋器讀取的形式
簡單的調用方法 : repr(obj) 4 __str__( self )
用於將值轉化為適於人閱讀的形式
簡單的調用方法 : str(obj) 5 __cmp__ ( self, x )
對象比較
簡單的調用方法 : cmp(obj, x)

運算符重載

　　Python同樣支持運算符重載，實例如下：

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

　　以上代碼執行結果如下所示:

Vector(7,8)

類屬性與方法

類的私有屬性

　　__private_attrs：兩個下劃線開頭，聲明該屬性為私有，不能在類地外部被使用或直接訪問。在類內部的方法中使用時self.__private_attrs。

類的方法

　　在類地內部，使用def關鍵字可以為類定義一個方法，與一般函數定義不同，類方法必須包含參數self,且為第一個參數

類的私有方法

　　__private_method：兩個下劃線開頭，聲明該方法為私有方法，不能在類地外部調用。在類的內部調用 self.__private_methods

實例

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class JustCounter:
    __secretCount = 0  # 私有變量
    publicCount = 0    # 公開變量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount  # 報錯，實例不能訪問私有變量

　　Python 通過改變名稱來包含類名:

1
2
2
Traceback (most recent call last):
  File "test.py", line 17, in <module>
    print counter.__secretCount  # 報錯，實例不能訪問私有變量
AttributeError: JustCounter instance has no attribute '__secretCount'

　　Python不允許實例化的類訪問私有數據，但你可以使用 object._className__attrName 訪問屬性，將如下代碼替換以上代碼的最後一行代碼：

.........................
print counter._JustCounter__secretCount

　　執行以上代碼，執行結果如下：


　致謝，感謝您的閱讀！

下面關於Python的文章您也可能喜歡，不妨看看：

Python：在指定目錄下查找滿足條件的文件 http://www.linuxidc.com/Linux/2015-08/121283.htm

Python2.7.7源碼分析 http://www.linuxidc.com/Linux/2015-08/121168.htm

無需操作系統直接運行 Python 代碼 http://www.linuxidc.com/Linux/2015-05/117357.htm

CentOS上源碼安裝Python3.4 http://www.linuxidc.com/Linux/2015-01/111870.htm

《Python核心編程第二版》.(Wesley J. Chun ).[高清PDF中文版] http://www.linuxidc.com/Linux/2013-06/85425.htm

《Python開發技術詳解》.( 周偉,宗傑).[高清PDF掃描版+隨書視頻+代碼] http://www.linuxidc.com/Linux/2013-11/92693.htm

Python腳本獲取Linux系統信息 http://www.linuxidc.com/Linux/2013-08/88531.htm

在Ubuntu下用Python搭建桌面算法交易研究環境 http://www.linuxidc.com/Linux/2013-11/92534.htm

Python 語言的發展簡史 http://www.linuxidc.com/Linux/2014-09/107206.htm

Python 的詳細介紹：請點這裡
Python 的下載地址：請點這裡

上一篇文章： Facebook 是如何構建首個跨平台 React Native 應用的？
下一篇文章： Scala的REPL Shell的調用

Linux編程

Python基礎教程：面向對象編程

Python多線程編程

Python對象

Python面向對象編程

Python面向對象的繼承

Python 編程風格

Python面向對象編程學習筆記

Python基礎：Python的變量和對象

相關文章

Python Socket 編程(1)

概說Python編程

Python socket 編程初探

Python——面向對象篇之異常和反射

幫你提升 Python 的 27 種編程語言

Java面向對象編程之反射

Python 的 WebSocket 編程

Python中list對象

Python面向對象之類和對象

Python對象的拷貝

Python對象簡析

Python基礎：Python可變對象和不可變對象

Linux編程

SHELL編程

PERL編程