python類:class創建、數據方法屬性及訪問控制詳解

在Python中，可以通過class關鍵字定義自己的類，然后通過自定義的類對象類創建實例對象。
python中創建類
創建一個Student的類，并且實現了這個類的初始化函數”__init__”:
class Student(object):
    count = 0
    books = []
    def __init__(self, name):
        self.name = name

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

類構造和初始化

”__init__”和”__new__”的聯系和差別

下面先通過一段代碼看看這兩個方法的調用順序：
    
class A(object):
  def __init__(self,*args, **kwargs):
    print "init %s" %self.__class__
  def __new__(cls,*args, **kwargs):
    print "new %s" %cls
    return object.__new__(cls, *args, **kwargs)
 
a = A()

從代碼的輸出可以看到，當通過類實例化一個對象的時候，”__new__”方法首先被調用，然后是”__init__”方法。

一般來說，”__init__”和”__new__”函數都會有下面的形式：
    
def__init__(self,*args,**kwargs):
  # func_suite
 
def__new__(cls,*args,**kwargs):
  # func_suite
returnobj

對于”__new__”和”__init__”可以概括為：

?“__new__”方法在Python中是真正的構造方法（創建并返回實例），通過這個方法可以產生一個”cls”對應的實例對象，所以說”__new__”方法一定要有返回

?對于”__init__”方法，是一個初始化的方法，”self”代表由類產生出來的實例對象，”__init__”將對這個對象進行相應的初始化操作

__new__特性

“__new__”是在新式類中新出現的方法，它有以下行為特性：

?“__new__” 方法是在類實例化對象時第一個調用的方法，將返回實例對象

?“__new__” 方法始終都是類的靜態方法（即第一個參數為cls），即使沒有被加上靜態方法裝飾器

?第一個參數cls是當前正在實例化的類，如果要得到當前類的實例，應當在當前類中的 “__new__” 方法語句中調用當前類的父類的” __new__” 方法

對于上面的第三點，如果當前類是直接繼承自 object，那當前類的 “__new__” 方法返回的對象應該為：
    
def __new__(cls, *args, **kwargs):
  # func_suite
return object.__new__(cls, *args, **kwargs)

重寫__new__

如果（新式）類中沒有重寫”__new__”方法，Python默認是調用該類的直接父類的”__new__”方法來構造該類的實例，如果該類的父類也沒有重寫”__new__”，那么將一直按照同樣的規則追溯至object的”__new__”方法，因為object是所有新式類的基類。

而如果新式類中重寫了”__new__”方法，那么可以選擇任意一個其他的新式類（必須是新式類，只有新式類有”__new__”，因為所有新式類都是從object派生）的”__new__”方法來創建實例，包括這個新式類的所有前代類和后代類，只要它們不會造成遞歸死循環。

看一段例子代碼：    
classFoo(object):
  def__new__(cls,*args,**kwargs):
    obj=object.__new__(cls,*args,**kwargs)
    # 這里的object.__new__(cls, *args, **kwargs)  等價于
    # super(Foo, cls).__new__(cls, *args, **kwargs)
    # object.__new__(Foo, *args, **kwargs)
    # Bar.__new__(cls, *args, **kwargs)
    # Student.__new__(cls, *args, **kwargs)，即使Student跟Foo沒有關系，也是允許的，因為Student是從object派生的新式類
 
    # 在任何新式類，不能調用自身的“__new__”來創建實例，因為這會造成死循環
    # 所以要避免return Foo.__new__(cls, *args, **kwargs)或return cls.__new__(cls, *args, **kwargs)
    print"Call __new__ for %s"%obj.__class__
    returnobj  
 
classBar(Foo):
  def__new__(cls,*args,**kwargs):
    obj=object.__new__(cls,*args,**kwargs)
    print"Call __new__ for %s"%obj.__class__
    returnobj
 
classStudent(object):
  # Student沒有“__new__”方法，那么會自動調用其父類的“__new__”方法來創建實例，即會自動調用 object.__new__(cls)
  pass
 
classCar(object):
  def__new__(cls,*args,**kwargs):
    # 可以選擇用Bar來創建實例
    obj=object.__new__(Bar,*args,**kwargs)
    print"Call __new__ for %s"%obj.__class__
    returnobj
 
foo=Foo()
bar=Bar()
car=Car()

代碼的輸出為：

__init__的調用

“__new__”決定是否要使用該類的”__init__”方法，因為”__new__” 可以調用其他類的構造方法或者直接返回別的類創建的對象來作為本類的實例。

通常來說，新式類開始實例化時，”__new__”方法會返回cls（cls指代當前類）的實例，然后調用該類的”__init__”方法作為初始化方法，該方法接收這個實例（即self）作為自己的第一個參數，然后依次傳入”__new__”方法中接收的位置參數和命名參數。

但是，如果”__new__”沒有返回cls（即當前類）的實例，那么當前類的”__init__”方法是不會被調用的。

例子：    
class A(object):
  def __init__(self, *args, **kwargs):
    print "Call __init__ from %s" %self.__class__
 
  def __new__(cls, *args, **kwargs):
    obj = object.__new__(cls, *args, **kwargs)
    print "Call __new__ for %s" %obj.__class__
    return obj  
 
class B(object):
  def __init__(self, *args, **kwargs):
    print "Call __init__ from %s" %self.__class__
 
  def __new__(cls, *args, **kwargs):
    obj = object.__new__(A, *args, **kwargs)
    print "Call __new__ for %s" %obj.__class__
    return obj   
 
b = B()
print type(b)

代碼中，在B的”__new__”方法中，通過”obj = object.__new__(A, *args, **kwargs)”創建了一個A的實例，在這種情況下，B的”__init__”函數就不會被調用到。

派生不可變類型

關于”__new__”方法還有一個重要的用途就是用來派生不可變類型。

例如，Python中float是不可變類型，如果想要從float中派生一個子類，就要實現”__new__”方法：    
classRound2Float(float):
  def__new__(cls,num):
    num=round(num,2)
    #return super(Round2Float, cls).__new__(cls, num)
    returnfloat.__new__(Round2Float,num)
 
f=Round2Float(4.14159)
printf

代碼中從float派生出了一個Round2Float類，該類的實例就是保留小數點后兩位的浮點數。

通過內建函數dir()，或者訪問類的字典屬性__dict__，這兩種方式都可以查看類有哪些屬性。

數據屬性

類數據屬性和實例數據屬性

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

類變量緊接在類名后面定義，相當于java和c++的static變量

實例變量在__init__里定義，相當于java和c++的普通變量

>>> class test:
         count = 0;類變量
        def __init__(self, c):
              self.count = c; 實例變量
             self.__class__.count = self.__class__.count + 1;

>>> a = test(3)
>>> a.count
3
>>> test.count
1

對于類數據屬性和實例數據屬性，可以總結為：

1.類數據屬性屬于類本身，可以通過類名進行訪問/修改

2.類數據屬性也可以被類的所有實例訪問/修改

3.在類定義之后，可以通過類名動態添加類數據屬性，新增的類屬性也被類和所有實例共有

4.實例數據屬性只能通過實例訪問

5.在實例生成后，還可以動態添加實例數據屬性，但是這些實例數據屬性只屬于該實例

特殊的類屬性

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

類屬性     含義
__name__     類的名字（字符串）
__doc__     類的文檔字符串
__bases__     類的所有父類組成的元組
__dict__     類的屬性組成的字典
__module__     類所屬的模塊
__class__     類對象的類型

 Note:文檔字符串對于類，函數/方法，以及模塊來說是唯一的，也就是說__doc__屬性是不能從父類中繼承來的。

屬性隱藏

從上面的介紹了解到，類數據屬性屬于類本身，被所有該類的實例共享；并且，通過實例可以去訪問/修改類屬性。

但是，在通過實例中訪問類屬性的時候一定要謹慎，因為可能出現屬性”隱藏”的情況。

繼續使用上面的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”

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

方法

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

實例方法

實例方法的第一個參數必須是”self”，”self”類似于C++中的”this”。

實例方法只能通過類實例進行調用，這時候”self”就代表這個類實例本身。通過”self”可以直接訪問實例的屬性。

類方法

類方法以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編碼中，有一些約定來進行訪問控制。

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

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

單下劃線”_”

在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()”。

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

A.__private()

B.public()

以上這篇python類:class創建、數據方法屬性及訪問控制詳解就是小編分享給大家的全部內容了