1.常用術語

2.創建類

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

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

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

 1 # -*- coding: UTF-8 -*-
 2 class Employee:
 3     ‘所有員工的基類‘
 4     empCount = 0
 5 
 6     def
 
 __init__(self, name, salary):
 7         self.name = name
 8         self.salary = salary
 9         Employee.empCount += 1
10 
11     def displayCount(self):
12         print "Total Employee %d" % Employee.empCount
13 
14     def displayEmployee(self):
15         print "Name : ", self.name, ", Salary: 
 
", self.salary

3.self

　　代表實例，而不是類。

　　類的方法與普通的函數只有一個特別的區別——它們必須有一個額外的第一個參數名稱, 按照慣例它的名稱是 self。

1 # -*- coding: utf-8 -*-
2 class Test:
3     def prt(self):
4         print(self)
5         print(self.__class__)
6 
7 t = Test()
8 t.prt()

4.創建實例對象

 1 # -*- coding: UTF-8 -*-
 2 class Employee:
 3     ‘
 
所有員工的基類‘
 4     empCount = 0
 5 
 6     def __init__(self, name, salary):
 7         self.name = name
 8         self.salary = salary
 9         Employee.empCount += 1
10 
11     def displayCount(self):
12         print "Total Employee %d" % Employee.empCount
13 
14     def displayEmployee(self):
15         print "Name : ", self.name, ", Salary: ", self.salary
16 
17 "創建 Employee 類的第一個對象"
18 emp1 = Employee("Zara", 2000)
19 "創建 Employee 類的第二個對象"
20 emp2 = Employee("Manni", 5000)
21 emp1.displayEmployee()
22 emp2.displayEmployee()
23 print "Total Employee %d" % Employee.empCount

5.訪問屬性

　　可以添加，刪除，修改類的屬性。

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

 1 # -*- coding: UTF-8 -*-
 2 class Employee:
 3     ‘所有員工的基類‘
 4     empCount = 0
 5 
 6     def __init__(self, name, salary):
 7         self.name = name
 8         self.salary = salary
 9         Employee.empCount += 1
10 
11     def displayCount(self):
12         print "Total Employee %d" % Employee.empCount
13 
14     def displayEmployee(self):
15         print "Name : ", self.name, ", Salary: ", self.salary
16 
17 "創建 Employee 類的第一個對象"
18 emp1 = Employee("Zara", 2000)
19 
20 "添加一個 ‘age‘ 屬性"
21 emp1.age222 = 7
22 
23 "修改 ‘age‘ 屬性"
24 emp1.age222 = 8
25 
26 print emp1.age222

6.效果

7.訪問屬性的函數

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

 1 # -*- coding: UTF-8 -*-
 2 class Employee:
 3     ‘所有員工的基類‘
 4     empCount = 0
 5 
 6     def __init__(self, name, salary):
 7         self.name = name
 8         self.salary = salary
 9         Employee.empCount += 1
10 
11     def displayCount(self):
12         print "Total Employee %d" % Employee.empCount
13 
14     def displayEmployee(self):
15         print "Name : ", self.name, ", Salary: ", self.salary
16 
17 "創建 Employee 類的第一個對象"
18 emp1 = Employee("Zara", 2000)
19 
20 "添加一個 ‘age‘ 屬性"
21 emp1.age = 7
22 
23 print hasattr(emp1, ‘age‘)    # 如果存在 ‘age‘ 屬性返回 True。
24 print getattr(emp1, ‘age‘)    # 返回 ‘age‘ 屬性的值
25 setattr(emp1, ‘age‘, 9) # 添加屬性 ‘age‘ 值為 8
26 print emp1.age
27 delattr(emp1, ‘age‘)    # 刪除屬性 ‘age‘

8.效果

9.內置屬性

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

 1 # -*- coding: UTF-8 -*-
 2 class Employee:
 3     ‘所有員工的基類‘
 4     empCount = 0
 5 
 6     def __init__(self, name, salary):
 7         self.name = name
 8         self.salary = salary
 9         Employee.empCount += 1
10 
11     def displayCount(self):
12         print "Total Employee %d" % Employee.empCount
13 
14     def displayEmployee(self):
15         print "Name : ", self.name, ", Salary: ", self.salary
16 
17 print "Employee.__doc__:", Employee.__doc__
18 print "Employee.__name__:", Employee.__name__
19 print "Employee.__module__:", Employee.__module__
20 print "Employee.__bases__:", Employee.__bases__
21 print "Employee.__dict__:", Employee.__dict__

10.效果

11.垃圾回收

　　Python 使用了引用計數這一簡單技術來跟蹤和回收垃圾。

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

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

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

　　垃圾回收機制不僅針對引用計數為0的對象，同樣也可以處理循環引用的情況。

　　循環引用指的是，兩個對象相互引用，但是沒有其他變量引用他們。這種情況下，僅使用引用計數是不夠的。

　　Python 的垃圾收集器實際上是一個引用計數器和一個循環垃圾收集器。

　　作為引用計數的補充， 垃圾收集器也會留心被分配的總量很大（及未通過引用計數銷毀的那些）的對象。 在這種情況下， 解釋器會暫停下來， 試圖清理所有未引用的循環。

12.程序

 1 # -*- coding: UTF-8 -*-
 2 class Point:
 3     def __init__(self, x=0, y=0):
 4         self.x = x
 5         self.y = y
 6 
 7     def __del__(self):
 8         class_name = self.__class__.__name__
 9         print class_name, "銷毀"
10 
11 pt1 = Point()
12 pt2 = pt1
13 pt3 = pt1
14 print id(pt1), id(pt2), id(pt3)  # 打印對象的id
15 del pt1
16 del pt2
17 del pt3

13.效果

14.類的繼承

　　 class 派生類名（基類名）：//... 基類名寫在括號裏，基本類是在類定義的時候，在元組之中指明的。

　　一些特點：

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

　　支持：

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

　　語法：

15.程序

 1 # -*- coding: UTF-8 -*-
 2 class Parent:  # 定義父類
 3     parentAttr = 100
 4 
 5     def __init__(self):
 6         print "調用父類構造函數"
 7 
 8     def parentMethod(self):
 9         print ‘調用父類方法‘
10 
11     def setAttr(self, attr):
12         Parent.parentAttr = attr
13 
14     def getAttr(self):
15         print "父類屬性 :", Parent.parentAttr
16 
17 
18 class Child(Parent):  # 定義子類
19     def __init__(self):
20         print "調用子類構造方法"
21 
22     def childMethod(self):
23         print ‘調用子類方法‘
24 
25 c = Child()  # 實例化子類
26 c.childMethod()  # 調用子類的方法
27 c.parentMethod()  # 調用父類方法
28 c.setAttr(200)  # 再次調用父類的方法 - 設置屬性值
29 c.getAttr()  # 再次調用父類的方法 - 獲取屬性值

16.效果

17.方法重寫

　　這個和Java一樣

18.基礎重載方法

19.運算符的重載

 1 # -*- coding: UTF-8 -*-
 2 class Vector:
 3     def __init__(self, a, b):
 4         self.a = a
 5         self.b = b
 6 
 7     def __str__(self):
 8         return ‘Vector (%d, %d)‘ % (self.a, self.b)
 9 
10     def __add__(self, other):
11         return Vector(self.a + other.a, self.b + other.b)
12 
13 v1 = Vector(2, 10)
14 v2 = Vector(5, -2)
15 print v1 + v2

20.效果

21.類屬性與方法　　

類的私有屬性

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

類的方法

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

類的私有方法

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

22.程序

　　Python不允許實例化的類訪問私有數據，但你可以使用 object._className__attrName 訪問屬性

 1 # -*- coding: UTF-8 -*-
 2 class JustCounter:
 3     __secretCount = 0  # 私有變量
 4     publicCount = 0  # 公開變量
 5 
 6     def count(self):
 7         self.__secretCount += 1
 8         self.publicCount += 1
 9         print self.__secretCount
10 
11 
12 counter = JustCounter()
13 counter.count()
14 counter.count()
15 print counter.publicCount
16 print counter._JustCounter__secretCount  #Python不允許實例化的類訪問私有數據，但你可以使用 object._className__attrName 訪問屬性
17 # print counter.__secretCount  # 報錯，實例不能訪問私有變量

23.效果

24.單下劃線、雙下劃線、頭尾雙下劃線說明

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

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

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

python中的面相對象