python類:class建立、資料方法屬性及訪問控制詳解

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

您可能感興趣的文章:

Python實現動態新增類的屬性或成員函式的解決方法Python中如何獲取類屬性的列表全面瞭解python中的類,物件,方法,屬性Python類屬性與例項屬性用法分析python中類和例項如何繫結屬性與方法示例詳解