python類:class建立、資料方法屬性及存取控制詳解，python存取控制

python類:class建立、資料方法屬性及存取控制詳解，python存取控制

在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_suitereturnobj

對於”__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_suitereturn 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:", numAprint "_numA is:", _numA

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

from lib import *print numAprintNum() 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__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']>>> 

以說，即使是雙底線，也沒有實現屬性的私人化，因為通過下面的方式還是可以直接存取”__address”屬性：

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

雙底線的另一個重要的目地

避免子類對父類同名屬性的衝突。

看下面一個例子：

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建立、資料方法屬性及存取控制詳解就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支援幫客之家。