在Python中，可以通過class關鍵字定義自己的類，然後通過自定義的類物件類建立例項物件。

例如，下面建立了一個Student的類，並且實現了這個類的初始化函式"__init__":

class Student(object):
    count = 0
    books = []
    def __init__(self, name, age):
        self.name = name
        self.age = age
    pass

接下來就通過上面的Student類來看看Python中類的相關內容。

資料屬性

在上面的Student類中，"count""books""name"和"age"都被稱為類的資料屬性，但是它們又分為類資料屬性和例項資料屬性。

類資料屬性和例項資料屬性

首先看一段程式碼，程式碼中分別展示了對類資料屬性和例項資料屬性的訪問：

Student.books.extend(["python", "javascript"])  
print "Student book list: %s" %Student.books    
# class can add class attribute after class defination
Student.hobbies = ["reading", "jogging", "swimming"]
print "Student hobby list: %s" %Student.hobbies    
 
print dir(Student)

print 

wilber = Student("Wilber", 28) 
print "%s is %d years old" %(wilber.name, wilber.age)   
# class instance can add new attribute 
# "gender" is the instance attribute only belongs to wilber
wilber.gender = "male"
print "%s is %s" %(wilber.name, wilber.gender)   
# class instance can access class attribute
 

print dir(wilber)
wilber.books.append("C#")
print wilber.books

print 

will = Student("Will", 27) 
print "%s is %d years old" %(will.name, will.age)   
# will shares the same class attribute with wilber
# will don't have the "gender" attribute that belongs to wilber
print dir(will)     
print will.books

通過內建函式dir()，或者訪問類的字典屬性__dict__，這兩種方式都可以檢視類有哪些屬性，程式碼的輸出為：

對於類資料屬性和例項資料屬性，可以總結為：

1. 類資料屬性屬於類本身，可以通過類名進行訪問/修改
2. 類資料屬性也可以被類的所有例項訪問/修改
3. 在類定義之後，可以通過類名動態新增類資料屬性，新增的類屬性也被類和所有例項共有
4. 例項資料屬性只能通過例項訪問
5. 在例項生成後，還可以動態新增例項資料屬性，但是這些例項資料屬性只屬於該例項

特殊的類屬性

對於所有的類，都有一組特殊的屬性：

通過這些屬性，可以得到 Student類的一些資訊：

class Student(object):
    '''
    this is a Student class
    '''
    count = 0
    books = []
    def __init__(self, name, age):
        self.name = name
        self.age = age
    pass
    
print Student.__name__
print Student.__doc__
print Student.__bases__
print Student.__dict__
print Student.__module__
print Student.__class

程式碼輸出為：

屬性隱藏

從上面的介紹瞭解到，類資料屬性屬於類本身，被所有該類的例項共享；並且，通過例項可以去訪問/修改類屬性。但是，在通過例項中訪問類屬性的時候一定要謹慎，因為可能出現屬性"隱藏"的情況。

繼續使用上面的Student類，來看看屬性隱藏：

wilber = Student("Wilber", 28)

print "Student.count is wilber.count: ", Student.count is wilber.count
wilber.count = 1    
print "Student.count is wilber.count: ", Student.count is wilber.count
print Student.__dict__
print wilber.__dict__
del wilber.count
print "Student.count is wilber.count: ", Student.count is wilber.count

print 

wilber.count += 3    
print "Student.count is wilber.count: ", Student.count is wilber.count
print Student.__dict__
print wilber.__dict__


del wilber.count
print

print "Student.books is wilber.books: ", Student.books is wilber.books
wilber.books = ["C#", "Python"]
print "Student.books is wilber.books: ", Student.books is wilber.books
print Student.__dict__
print wilber.__dict__
del wilber.books
print "Student.books is wilber.books: ", Student.books is wilber.books

print 

wilber.books.append("CSS")
print "Student.books is wilber.books: ", Student.books is wilber.books
print Student.__dict__
print wilber.__dict__

程式碼的輸出為：

分析一下上面程式碼的輸出：

• 對於不可變型別的類屬性Student.count，可以通過例項wilber進行訪問，並且"Student.count is wilber.count"
• 當通過例項賦值/修改count屬性的時候，都將為例項wilber新建一個count例項屬性，這時，"Student.count is not wilber.count"
• 當通過"del wilber.count"語句刪除例項的count屬性後，再次成為"Student.count is wilber.count"
• 同樣對於可變型別的類屬性Student.books，可以通過例項wilber進行訪問，並且"Student. books is wilber. books"
• 當通過例項賦值books屬性的時候，都將為例項wilber新建一個books例項屬性，這時，"Student. Books is not wilber. books"
• 當通過"del wilber. books"語句刪除例項的books屬性後，再次成為"Student. books is wilber. books"
• 當通過例項修改books屬性的時候，將修改wilber.books指向的記憶體地址（即Student.books），此時，"Student. Books is wilber.books"

注意，雖然通過例項可以訪問類屬性，但是，不建議這麼做，最好還是通過類名來訪問類屬性，從而避免屬性隱藏帶來的不必要麻煩。

方法

在一個類中，可能出現三種方法，例項方法、靜態方法和類方法，下面來看看三種方法的不同。

例項方法

例項方法的第一個引數必須是"self"，"self"類似於C++中的"this"。

例項方法只能通過類例項進行呼叫，這時候"self"就代表這個類例項本身。通過"self"可以直接訪問例項的屬性。

class Student(object):
    '''
    this is a Student class
    '''
    count = 0
    books = []
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def printInstanceInfo(self):
        print "%s is %d years old" %(self.name, self.age)
    pass
    
wilber = Student("Wilber", 28)
wilber.printInstanceInfo()

類方法

類方法以cls作為第一個引數，cls表示類本身，定義時使用@classmethod裝飾器。通過cls可以訪問類的相關屬性。

class Student(object):
    '''
    this is a Student class
    '''
    count = 0
    books = []
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    @classmethod
    def printClassInfo(cls):
        print cls.__name__
        print dir(cls)
    pass
    
Student.printClassInfo()    
wilber = Student("Wilber", 28)
wilber.printClassInfo()

程式碼的輸出為，從這段程式碼可以看到，類方法可以通過類名訪問，也可以通過例項訪問。

靜態方法

與例項方法和類方法不同，靜態方法沒有引數限制，既不需要例項引數，也不需要類引數，定義的時候使用@staticmethod裝飾器。

同類方法一樣，靜態法可以通過類名訪問，也可以通過例項訪問。

class Student(object):
    '''
    this is a Student class
    '''
    count = 0
    books = []
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    @staticmethod
    def printClassAttr():
        print Student.count
        print Student.books
    pass
    
Student.printClassAttr()    
wilber = Student("Wilber", 28)
wilber.printClassAttr()

這三種方法的主要區別在於引數，例項方法被繫結到一個例項，只能通過例項進行呼叫；但是對於靜態方法和類方法，可以通過類名和例項兩種方式進行呼叫。

訪問控制

Python中沒有訪問控制的關鍵字，例如private、protected等等。但是，在Python編碼中，有一些約定來進行訪問控制。

單下劃線"_"

在Python中，通過單下劃線"_"來實現模組級別的私有化，一般約定以單下劃線"_"開頭的變數、函式為模組私有的，也就是說"from moduleName import *"將不會引入以單下劃線"_"開頭的變數、函式。

現在有一個模組lib.py，內容用如下，模組中一個變數名和一個函式名分別以"_"開頭：

numA = 10
_numA = 100

def printNum():
    print "numA is:", numA
    print "_numA is:", _numA
    
def _printNum():
    print "numA is:", numA
print "_numA is:", _numA

當通過下面程式碼引入lib.py這個模組後，所有的以"_"開頭的變數和函式都沒有被引入，如果訪問將會丟擲異常：

from lib import *
print numA
printNum()

print _numA
#print _printNum()

雙下劃線"__"

對於Python中的類屬性，可以通過雙下劃線"__"來實現一定程度的私有化，因為雙下劃線開頭的屬性在執行時會被"混淆"（mangling）。

在Student類中，加入了一個"__address"屬性：

class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__address = "Shanghai"

    pass

wilber = Student("Wilber", 28)
print wilber.__address    

當通過例項wilber訪問這個屬性的時候，就會得到一個異常，提示屬性"__address"不存在。

其實，通過內建函式dir()就可以看到其中的一些原由，"__address"屬性在執行時，屬性名被改為了"_Student__address"（屬性名前增加了單下劃線和類名）

>>> wilber = Student("Wilber", 28)
>>> dir(wilber)
['_Student__address', '__class__', '__delattr__', '__dict__', '__doc__', '__form
at__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__r
educe__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '
__subclasshook__', '__weakref__', 'age', 'name']
>>>

所以說，即使是雙下劃線，也沒有實現屬性的私有化，因為通過下面的方式還是可以直接訪問"__address"屬性：

>>> wilber = Student("Wilber", 28)
>>> print wilber._Student__address
Shanghai
>>>

雙下劃線的另一個重要的目地是，避免子類對父類同名屬性的衝突。

看下面一個例子：

class A(object):
    def __init__(self):
        self.__private()
        self.public()
    
    def __private(self):
        print 'A.__private()'
    
    def public(self):
        print 'A.public()'

class B(A):
    def __private(self):
        print 'B.__private()'
    
    def public(self):
        print 'B.public()'
    
b = B()  

當例項化B的時候，由於沒有定義__init__函式，將呼叫父類的__init__，但是由於雙下劃線的"混淆"效果，"self.__private()"將變成 "self._A__private()"。

看到這裡，就清楚為什麼會有如下輸出了：

"_"和" __"的使用 更多的是一種規範/約定，不沒有真正達到限制的目的：

• "_"：以單下劃線開頭的表示的是protected型別的變數，即只能允許其本身與子類進行訪問；同時表示弱內部變數標示，如，當使用"from moduleNmae import *"時，不會將以一個下劃線開頭的物件引入。
• "__"：雙下劃線的表示的是私有型別的變數。只能是允許這個類本身進行訪問了，連子類也不可以，這類屬性在執行時屬性名會加上單下劃線和類名。

總結

本文介紹了Python中class的一些基本點：

• 例項資料屬性和類資料屬性的區別，以及屬性隱藏
• 例項方法，類方法和靜態方法直接的區別
• Python中通過"_"和"__"實現的訪問控制