在Python中，可以通過class關(guān)鍵字定義自己的類，然后通過自定義的類對象類創(chuàng)建實例對象。

python中創(chuàng)建類

創(chuàng)建一個Student的類，并且實現(xiàn)了這個類的初始化函數(shù)”__init__”:

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

接下來就通過上面的Student類來看看Python中類的相關(guān)內(nèi)容。

類構(gòu)造和初始化

”__init__”和”__new__”的聯(lián)系和差別

下面先通過一段代碼看看這兩個方法的調(diào)用順序：

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() 

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

一般來說，”__init__”和”__new__”函數(shù)都會有下面的形式：

def__init__(self,*args,**kwargs):
  # func_suite
 
def__new__(cls,*args,**kwargs):
  # func_suite
returnobj

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

•“__new__”方法在Python中是真正的構(gòu)造方法（創(chuàng)建并返回實例），通過這個方法可以產(chǎn)生一個”cls”對應(yīng)的實例對象，所以說”__new__”方法一定要有返回

•對于”__init__”方法，是一個初始化的方法，”self”代表由類產(chǎn)生出來的實例對象，”__init__”將對這個對象進(jìn)行相應(yīng)的初始化操作

__new__特性

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

•“__new__” 方法是在類實例化對象時第一個調(diào)用的方法，將返回實例對象

•“__new__” 方法始終都是類的靜態(tài)方法（即第一個參數(shù)為cls），即使沒有被加上靜態(tài)方法裝飾器

•第一個參數(shù)cls是當(dāng)前正在實例化的類，如果要得到當(dāng)前類的實例，應(yīng)當(dāng)在當(dāng)前類中的 “__new__” 方法語句中調(diào)用當(dāng)前類的父類的” __new__” 方法

對于上面的第三點，如果當(dāng)前類是直接繼承自 object，那當(dāng)前類的 “__new__” 方法返回的對象應(yīng)該為：

def __new__(cls, *args, **kwargs):
  # func_suite
return object.__new__(cls, *args, **kwargs) 

重寫__new__

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

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

看一段例子代碼：

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沒有關(guān)系，也是允許的，因為Student是從object派生的新式類
 
    # 在任何新式類，不能調(diào)用自身的“__new__”來創(chuàng)建實例，因為這會造成死循環(huán)
    # 所以要避免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__”方法，那么會自動調(diào)用其父類的“__new__”方法來創(chuàng)建實例，即會自動調(diào)用 object.__new__(cls)
  pass
 
classCar(object):
  def__new__(cls,*args,**kwargs):
    # 可以選擇用Bar來創(chuàng)建實例
    obj=object.__new__(Bar,*args,**kwargs) 
    print"Call __new__ for %s"%obj.__class__
    returnobj
 
foo=Foo()
bar=Bar()
car=Car()

代碼的輸出為：

__init__的調(diào)用

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

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

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

例子：

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)”創(chuàng)建了一個A的實例，在這種情況下，B的”__init__”函數(shù)就不會被調(diào)用到。

派生不可變類型

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

例如，Python中float是不可變類型，如果想要從float中派生一個子類，就要實現(xiàn)”__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類，該類的實例就是保留小數(shù)點后兩位的浮點數(shù)。

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

數(shù)據(jù)屬性

類數(shù)據(jù)屬性和實例數(shù)據(jù)屬性

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

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

實例變量在__init__里定義，相當(dāng)于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

對于類數(shù)據(jù)屬性和實例數(shù)據(jù)屬性，可以總結(jié)為：

1.類數(shù)據(jù)屬性屬于類本身，可以通過類名進(jìn)行訪問/修改

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

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

4.實例數(shù)據(jù)屬性只能通過實例訪問

5.在實例生成后，還可以動態(tài)添加實例數(shù)據(jù)屬性，但是這些實例數(shù)據(jù)屬性只屬于該實例

特殊的類屬性

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

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

屬性隱藏

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

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

繼續(xù)使用上面的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進(jìn)行訪問，并且”Student.count is wilber.count”

•當(dāng)通過實例賦值/修改count屬性的時候，都將為實例wilber新建一個count實例屬性，這時，”Student.count is not wilber.count”

•當(dāng)通過”del wilber.count”語句刪除實例的count屬性后，再次成為”Student.count is wilber.count”

•同樣對于可變類型的類屬性Student.books，可以通過實例wilber進(jìn)行訪問，并且”Student. books is wilber. books”

•當(dāng)通過實例賦值books屬性的時候，都將為實例wilber新建一個books實例屬性，這時，”Student. Books is not wilber. books”

•當(dāng)通過”del wilber. books”語句刪除實例的books屬性后，再次成為”Student. books is wilber. books”

•當(dāng)通過實例修改books屬性的時候，將修改wilber.books指向的內(nèi)存地址（即Student.books），此時，”Student. Books is wilber. books”

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

方法

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

實例方法

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

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

類方法

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

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()

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

靜態(tài)方法

與實例方法和類方法不同，靜態(tài)方法沒有參數(shù)限制，既不需要實例參數(shù)，也不需要類參數(shù)，定義的時候使用@staticmethod裝飾器。

同類方法一樣，靜態(tài)法可以通過類名訪問，也可以通過實例訪問。

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()

這三種方法的主要區(qū)別在于參數(shù)，實例方法被綁定到一個實例，只能通過實例進(jìn)行調(diào)用；但是對于靜態(tài)方法和類方法，可以通過類名和實例兩種方式進(jìn)行調(diào)用。

訪問控制

Python中沒有訪問控制的關(guān)鍵字，例如private、protected等等。

但是，在Python編碼中，有一些約定來進(jìn)行訪問控制。

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

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

單下劃線”_”

在Python中，通過單下劃線”_”來實現(xiàn)模塊級別的私有化，一般約定以單下劃線”_”開頭的變量、函數(shù)為模塊私有的，也就是說”from moduleName import *”將不會引入以單下劃線”_”開頭的變量、函數(shù)。

現(xiàn)在有一個模塊lib.py，內(nèi)容用如下，模塊中一個變量名和一個函數(shù)名分別以”_”開頭：

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

當(dāng)通過下面代碼引入lib.py這個模塊后，所有的以”_”開頭的變量和函數(shù)都沒有被引入，如果訪問將會拋出異常：

from lib import *
print numA
printNum()
 
print _numA
#print _printNum() 

雙下劃線”__”

對于Python中的類屬性，可以通過雙下劃線”__”來實現(xiàn)一定程度的私有化，因為雙下劃線開頭的屬性在運行時會被”混淆”（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 

 當(dāng)通過實例wilber訪問這個屬性的時候，就會得到一個異常，提示屬性”__address”不存在。

其實，通過內(nèi)建函數(shù)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']
>>> 

以說，即使是雙下劃線，也沒有實現(xiàn)屬性的私有化，因為通過下面的方式還是可以直接訪問”__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()

當(dāng)實例化B的時候，由于沒有定義__init__函數(shù)，將調(diào)用父類的__init__，但是由于雙下劃線的”混淆”效果，”self.__private()”將變成 “self._A__private()”。

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

A.__private()

B.public()

以上這篇python類:class創(chuàng)建、數(shù)據(jù)方法屬性及訪問控制詳解就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論