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

emp1 = Employee("yuan", 3000)
emp2 = Employee("qiang",4000)
#添加屬性
emp1.age = 7
emp2.age = 8
#刪除對象emp1的屬性
#del emp1.age
emp2.displayEmployee()
print "Total emploeey %d" % Employee.empCount
print "emp1 is %d years old" %emp1.age

#python內置類屬性
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__

　執行結果：

Name: yuan ,Salary:  3000
Name: qiang ,Salary:  4000
Total emploeey 2
emp1 is 7 years old
Employee.__doc__: None
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x00000000035184A8>, 'empCount': 2, 'displayEmployee': <function displayEmployee at 0x0000000003518518>, '__doc__': None, '__init__': <function __init__ at 0x0000000003518438>}　

• empCount 變量是一個類變量，它的值將在這個類的所有實例之間共享。你可以在內部類或外部類使用 Employee.empCount 訪問。

• 第一種方法__init__()方法是一種特殊的方法，被稱為類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法

• self 代表類的實例，self 在定義類的方法時是必須有的，雖然在調用時不必傳入相應的參數。

• Python內置類屬性

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

析構函數

析構函數 __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 ,"銷毀"

pt1 = Point()
pt2 = pt1   #引用
pt3 = pt1
print id(pt1),id(pt2),id(pt3) #打印出對象的ID
#調用析構函數進行對象的銷毀
del pt1
del pt2
del pt3

　執行結果：

45331272 45331272 45331272
Point 銷毀

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

類的繼承　

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

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

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

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

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

　　下面一個類的繼承實例：

#!/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
    def aa(self):
        print "調用父類aa"

class Child(Parent):
    def __init__(self):
        print "調用子類構造函數"

    def childMethod(self):
        print "調用子類方法"
    def aa(self):
        print "調用子類aa"

c = Child()    #實例化子類
c.childMethod()
c.parentMethod()
c.setAttr(200)
c.getAttr()
c.aa()

執行結果：

調用子類構造函數
調用子類方法
調用父類方法
父類屬性： 200
調用子類aa

　多類繼承　

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()         # 子類調用重寫方法

　　執行結果：

調用子類方法

基礎重載方法

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

運算符重載

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

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  #報錯，私有成員，不能通過對象直接進行訪問
print counter._JustCounter__secretCount  #可以通過object._className__attrName 這樣組合的方式進行訪問私有成員

　執行結果：

1
2
2
2

單下划線、雙下划線、頭尾雙下划線說明：

• __foo__: 定義的是特殊方法，一般是系統定義名字 ，類似 __init__() 之類的。

• _foo: 以單下划線開頭的表示的是 protected 類型的變量，即保護類型只能允許其本身與子類進行訪問，不能用於 from module import *

• __foo: 雙下划線的表示的是私有類型(private)的變量, 只能是允許這個類本身進行訪問了。