python類及其方法

 

1、介紹

在 Python 中，面向對象編程主要有兩個主題，就是類和類實例
類與實例：
類與實例相互關聯着：類是對象的定義，而實例是"真正的實物"，它存放了類中所定義的對象
的具體信息。

類有這樣一些的優勢：

一、類對象是多態的：也就是多種形態，這意味着咱們能夠對不一樣的類對象使用一樣的操做方法，而不須要額外寫代碼。
二、類的封裝：封裝以後，能夠直接調用類的對象，來操做內部的一些類方法，不須要讓使用者看到代碼工做的細節。
三、類的繼承：類能夠從其它類或者元類中繼承它們的方法，直接使用。

2、類的定義

1.定義類（class）的語法

1 >>> class Iplaypython:
2 >>>     def fname(self, name):
3 >>>           self.name = name

一第行，語法是class 後面緊接着，類的名字，最後別忘記「冒號」，這樣來定義一個類。
類的名字，首字母，有一個不可文的規定，最好是大寫，這樣須要在代碼中識別區分每一個類。
第二行開始是類的方法，你們看到了，和函數很是類似，可是與普通函數不一樣的是，它的內部有一個「self」，參數，它的做用是對於對象自身的引用。

2.初始化對象

建立類時，能夠定義一個特定的方法，名爲__init__(),只要建立這個類的一個實例就會運行這個方法。能夠向__init__()方法傳遞參數，這樣建立對象時就能夠把屬性設置爲你但願的值__init__()這個方法會在建立對象時完成初始化

1 >>> class peo:
2 ...     def __init__(self,name,age,sex):
3 ...             self.Name = name
4 ...             self.Age = age
5 ...             self.Sex = sex
6 ...     def speak(self):
7 ...             print "my name" + self.Name
8 ... 

實例化這個類的對象時：

1 >>> zhangsan=peo("zhangsan",24,'man')
2 >>> print zhangsan.Age
3 24
4 >>> print zhangsan.Name
5 zhangsan
6 >>> print zhangsan.Sex
7 man

以前屢次用到self這個形參類就比如是一張藍圖，使用一個類能夠建立多個對象實例，speak()方法在被調用時，必須知道是哪一個對象調用了它.

這裏self參數就會告訴方法是哪一個對象來調用的.這稱爲實例引用。

 

3.類的私有屬性：

　　__private_attrs 兩個下劃線開頭，聲明該屬性爲私有，不能在類地外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs
類的方法
　　在類地內部，使用def關鍵字能夠爲類定義一個方法，與通常函數定義不一樣，類方法必須包含參數self,且爲第一個參數
私有的類方法
　　__private_method 兩個下劃線開頭，聲明該方法爲私有方法，不能在類地外部調用。在類的內部調用slef.__private_methods

 

4. classmethod類方法

1) 在python中.類方法 @classmethod 是一個函數修飾符，它表示接下來的是一個類方法，而對於日常咱們見到的則叫作實例方法。 類方法的第一個參數cls，而實例方法的第一個參數是self，表示該類的一個實例。
2) 普通對象方法至少須要一個self參數，表明類對象實例
3)類方法有類變量cls傳入，從而能夠用cls作一些相關的處理。而且有子類繼承時，調用該類方法時，傳入的類變量cls是子類，而非父類。 對於類方法，能夠經過類來調用，就像C.f()，有點相似C＋＋中的靜態方法, 也能夠經過類的一個實例來調用，就像C().f()，這裏C()，寫成這樣以後它就是類的一個實例了。

 1 class info(object):
 2 
 3 　　@classmethod
 4 　　def sayclassmethod(cls):
 5 
 6 　　　　print 'say %s' % cls
 7 
 8 　　def saymethod(self):
 9 
10 　　　　print 'say %s' % self
11 
12 
13 test = info()
14 test.saymethod()##實例調用方法
15 test.sayclassmethod()##實例調用類方法
16 info.saymethod(test)##類調用實例方法
17 info.sayclassmethod()##類調用類方法

你們對比運行下。

 

5.類的裝飾器@property

 1 class Pager:
 2     def __init__(self,all_count):
 3         self.all_count=all_count
 4     @property
 5     def all_pager(self):
 6         a,b=divmod(self.all_count,10)
 7         if a==0:
 8             return a
 9         else:
10             return  a+1
11 
12     @all_pager.setter
13     def all_pager(self,value):
14         print(value)
15 
16     @all_pager.deleter
17     def all_pager(self):
18         print('hehe')
19 p=Pager(101)
20 ret=p.all_count#以訪問類屬性的方法訪問對象的方法
21 print(ret)

下面看第二種方法

 1 class Pager:
 2     def __init__(self,all_count):
 3         self.all_count=all_count
 4     def f1(self):
 5         return 123
 6     def f2(self,value):
 7         print('======')
 8     def f3(self):
 9         print('+++++++')
10 
11     foo=property(fget=f1,fset=f2,fdel=f3)
12 p=Pager(101)
13 ret=p.foo
14 p.foo='alex'
15 print(p.foo)
16 del p.foo

在該類中定義三個函數，分別用做賦值、取值、刪除變量

property函數原型爲property(fget=None,fset=None,fdel=None,doc=None)，上例根據本身定義相應的函數賦值便可。

 

 

3、繼承類定義：
1.單繼承

class <類名>(父類名)
<語句>

1 class childbook(book)
2     age = 10

#單繼承示例

 1  class student(people):  
 2         grade = ''  
 3         def __init__(self,n,a,w,g):  
 4             #調用父類的構函  
 5             people.__init__(self,n,a,w)  
 6             self.grade = g  
 7         #覆寫父類的方法  
 8         def speak(self):  
 9             print("%s is speaking: I am %d years old,and I am in grade %d"%(self.name,self.age,self.grade))       
10 
11     s = student('ken',20,60,3)  
12     s.speak()

 

2.類的多重繼承
class 類名(父類1,父類2,....,父類n)
<語句1>

須要注意圓括號中父類的順序，如果父類中有相同的方法名，而在子類使用時未指定，python從左至右搜索，即方法在子類中未找到時，從左到右查找父類中是否包含方法

#另外一個類，多重繼承以前的準備  

1 class speaker():  
2     topic = ''  
3     name = ''  
4     def __init__(self,n,t):  
5         self.name = n  
6         self.topic = t  
7     def speak(self):  
8         print("I am %s,I am a speaker!My topic is %s"%(self.name,self.topic))  

#多重繼承  

1 class sample(speaker,student):  
2     a =''  
3     def __init__(self,n,a,w,g,t):  
4         student.__init__(self,n,a,w,g)  
5         speaker.__init__(self,n,t)  
6 
7 test = sample("Tim",25,80,4,"Python")  
8 test.speak()#方法名同，默認調用的是在括號中排前地父類的方法

 

 

4、類的專業方法

Python 類能夠定義專用方法,專用方法是在特殊狀況下或當使用特別語法時由 Python 替你調用的，而不是在代碼中直接調用（象普通的方法那樣）。

1 __init__
相似於構造函數

1 #!/usr/local/bin/python
2 class Study:
3         def __init__(self,name=None):
4                 self.name = name
5         def say(self):
6                 print self.name
7 study = Study("Badboy")
8 study.say()

2 __del__
相似於析構函數

 1 #!/usr/local/bin/python
 2 class Study:
 3         def __init__(self,name=None):
 4                 self.name = name
 5         def __del__(self):
 6                 print "Iamaway,baby!"
 7         def say(self):
 8                 print self.name
 9 study = Study("zhuzhengjun")
10 study.say()

3__repr__
使用repr(obj)的時候，會自動調用__repr__函數，該函數返回對象字符串表達式，
用於重建對象，若是eval(repr(obj))會獲得一個對象的拷貝。

 1 #!/usr/local/bin/python
 2 class Study:
 3         def __init__(self,name=None):
 4                 self.name = name
 5         def __del__(self):
 6                 print "Iamaway,baby!"
 7         def say(self):
 8                 print self.name
 9         def __repr__(self):
10                 return "Study('jacky')"
11 study = Study("zhuzhengjun")
12 study.say()
13 print type(repr(Study("zhuzhengjun"))) # str
14 print type(eval(repr(Study("zhuzhengjun")))) # instance
15 
16 study = eval(repr(Study("zhuzhengjun")))
17 
18 study.say()

4__str__
Python能用print語句輸出內建數據類型。有時，程序員但願定義一個類，要求它的對象也能用print語句輸出。Python類可定義特殊方法__str__，爲類的對象提供一個不正式的字符串表示。若是類的客戶程序包含如下語句：

print objectOfClass
那麼Python會調用對象的__str__方法，並輸出那個方法所返回的字符串。

 1 #!/usr/local/bin/python
 2 
 3 class PhoneNumber:
 4         def __init__(self,number):
 5                  self.areaCode=number[1:4]
 6                  self.exchange=number[6:9]
 7                  self.line=number[10:14]
 8 
 9         def __str__(self):
10                 return "(%s) %s-%s"%(self.areaCode,self.exchange,self.line)
11 
12 def test():
13          newNumber=raw_input("Enter phone number in the form. (123) 456-7890: \n")
14          phone=PhoneNumber(newNumber)
15          print "The phone number is:"
16          print phone
17 
18 if__name__=="__main__":
19          test()

方法__init__接收一個形如"(xxx) xxx-xxxx"的字符串。字符串中的每一個x都是電話號碼的一個位數。方法對字符串進行分解，並將電話號碼的不一樣部分做爲屬性存儲。

方法__str__是一個特殊方法，它構造並返回PhoneNumber類的一個對象的字符串表示。解析器一旦遇到以下語句：

print phone

就會執行如下語句：

print phone.__str__()

程序若是將PhoneNumber對象傳給內建函數str(如str(phone)),或者爲PhoneNumber對象使用字符串格式化運算符%(例如"%s"%phone),Python也會調用__str__方法。

5__cmp __
比較運算符，0：等於 1：大於 -1：小於

class Study:  
     def __cmp__(self, other):  
         if other > 0 :  
             return 1  
         elif other < 0:  
             return - 1  
         else:  
             return 0  
   
study = Study()  
if study > -10:print 'ok1'  
if study < -10:print 'ok2'  
if study == 0:print 'ok3' 

打印：ok2 ok3
說明:在對類進行比較時，python自動調用__cmp__方法，如-10 < 0 返回 -1，也就是說study 應該小與 -10，估打印ok2

6__getitem__
__getitem__ 專用方法很簡單。象普通的方法 clear，keys 和 values 同樣，它只是重定向到字典，返回字典的值。

 1 class Zoo:  
 2      def __getitem__(self, key):  
 3          if key == 'dog':return 'dog'  
 4          elif key == 'pig':return  'pig'  
 5          elif key == 'wolf':return 'wolf'  
 6          else:return 'unknown'  
 7    
 8 zoo = Zoo()  
 9 print zoo['dog']  
10 print zoo['pig']  
11 print zoo['wolf']

打印 dog pig wolf

7__setitem__
__setitem__ 簡單地重定向到真正的字典 self.data ，讓它來進行工做。

 1 class Zoo:  
 2      def __setitem__(self, key, value):  
 3          print 'key=%s,value=%s' % (key, value)  
 4    
 5 zoo = Zoo()  
 6 zoo['a'] = 'a'  
 7 zoo['b'] = 'b'  
 8 zoo['c'] = 'c'
 9 打印：
10 key=a,value=a
11 key=b,value=b
12 key=c,value=c

8 __delitem__
__delitem__ 在調用 del instance[key] 時調用 ，你可能記得它做爲從字典中刪除單個元素的方法。當你在類實例中使用 del 時，Python 替你調用 __delitem__ 專用方法。

1 class A:  
2      def __delitem__(self, key):  
3          print 'delete item:%s' %key  
4    
5 a = A()  
6 del a['key']