python 基礎筆記十九 - 面向對象

一、類：用來描述具備相同的屬性和方法的對象的集合。它定義了該集合中每一個對象所共有的屬性和方法。

二、對象：類的實例

三、類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體以外。

四、數據成員：類變量或者實例變量，用於處理類及其實例對象的相關數據。

五、實例變量：定義在方法中的變量，只能做用域當前實例的類。

六、實例化：建立一個類的實例，類的具體對象。

七、方法：類中定義的函數

八、對象：經過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

 

建立類：

使用 class 語句來建立一個新類，class 以後爲類的名稱並以冒號結尾

class ClassName:
   '類的幫助信息'   #類文檔字符串
   class_suite  #類體

類的幫助信息能夠經過ClassName.__doc__查看。

class_suite 由類成員，方法，數據屬性組成。

 

類的構造方法：

 建立對象的時候，會調用構造函數

1 class People:
2     def __init__(self):
3         print('這是構造函數')
4 
5 people = People()   #建立對象的時候，會調用構造函數，打印：這是構造函數

 類的析構方法：

 運行結束的時候，會自動調用類的析構函數

1 class People:
2     def __init__(self):
3         print('這是構造函數')
4 
5     def __del__(self):
6         print('這是析構函數！')
7 
8 people = People()   #建立對象的時候，會調用構造函數，打印：這是構造函數
9 #運行結束的時候，會自動調用類的析構函數

Python垃圾回收機制：其實是一個引用計數器和一個循環垃圾收集器。當對象建立時，就建立了一個引用計數，當這個對象再也不須要時，也就是說，這個對象的引用計數變爲0時，它被垃圾回收。可是回收不是「當即」的，由解釋器在適當的時機，將垃圾對象佔用的內存空間回收。

類的屬性方法：

屬性變爲私有屬性，加斷言

 1 class People:
 2     def __init__(self):
 3         print('這是構造函數')
 4     #普通的類方法
 5     def print_Name(self,name):
 6         print('這我的的名字是%s'%name)
 7 
 8     @property  #屬性方法
 9     def print_age(self):
10         print('這是一個屬性方法')
11 
12     def __del__(self):
13         print('這是析構函數！')
14 
15 people = People()   #建立對象的時候，會調用構造函數，打印：這是構造函數
16 people.print_Name('wuxuewen')
17 people.print_age    #屬性方法調用時，不能傳入參數，只能是經過.方法名調用

self的含義：

self表明類的實例，而非類。類的方法與普通的函數只有一個特別的區別：他們必須有一個額外的第一個參數名稱，按照慣例它的名稱是self。

 

私有變量、私有方法：

用兩個下劃線‘__變量名’開頭的變量，在類裏能夠調用，可是出了類就不能夠被調用

 1 class DB:
 2     def __init__(self,host,user,password,db):
 3         self.host = host
 4         self.__user = user  #私有變量
 5         self.__password = password  #私有變量
 6         self.db = db
 7 
 8     def sql(self,sql):
 9         print('執行SQL')
10         self.__text()  #在類裏能夠調用私有方法
11 
12     def help(self):
13         print(self.host)
14         print(self.__user)
15         print(self.__password)
16         print(self.db)
17         
18     def __text(self):
19         print('這是一個私有方法，出了類不能被調用')
20 
21 db = DB('127.0.0.1','root','123456','wxw')
22 print(db.host)  #類外能夠直接調用實例變量，可是不能夠調用私有變量
23 db.help()
24 db.__text()  #會報錯

 

類變量：

定義在類裏，在方法以外的變量，

 1 class DB:
 2     port = 3306
 3     def __init__(self,host,user,password,db):
 4         self.host = host
 5         self.__user = user  #私有變量
 6         self.__password = password  #私有變量
 7         self.db = db
 8 
 9     def get_port(self):
10         print(self.port)
11 
12 
13 db = DB('127.0.0.1','root','123456','wxw')
14 db.get_port()  #3306
15 db.port=3307  #這裏只是給實例db新增了一個實例變量port，並無修改類變量
16 db.get_port()  #3307
17 
18 DB.port = 3308 #經過類名.類變量，能夠修改類變量，且全部實例共享
19 print(DB.port)  #3308
20 oracle = DB('127.0.0.1','root','123456','wxw')
21 oracle.get_port()  #3308
22 db.get_port()  #3307,會優先取實例變量
23 my = DB('127.0.0.1','root','123456','wxw')
24 my.get_port()  #3308

 

實例方法：

方法的參數加了self的函數，只能經過對象.方法名()來調用，不能經過類名.方法名()來調用

 

類方法：

類裏面定義的公共方法，不須要實例化就能夠調用，只須要類名.方法名()就能夠實現，加斷言：@classmethod

何時用類方法：這個方法裏面沒有用到實例變量或者沒有調用實例方法的時候，只用到類變量，就能夠給它定義成一個類方法。

 1 class DB:
 2     port = 3306
 3     @classmethod
 4     def help(cls):
 5         print('這是一個類方法，不須要實例化就能夠調用')
 6         print('類變量的地址：%s' %id(cls))
 7 
 8 DB.help()  #經過類名直接調用類方法，輸出：5818952
 9 print('類地址：%s'%id(DB))  #直接打印類的地址，輸出：5818952
10 db = DB()   #實例化對象
11 db.help()   #經過對象調用類方法，打印的是類的地址，輸出：5818952
12 print("db 的地址: %s"%id(db)) #打印的是對象的地址，輸出：43827096

 

靜態方法：

只是定義在類裏面的一個普通的函數，加斷言：@staticmethod

何時用靜態方法：若是這個函數沒有用到類變量、類方法、實例變量、實例方法，那麼就能夠把它定義成靜態方法，類方法、實例方法能夠隨便調用靜態方法。可是靜態方法不能調用其餘的方法。

 1 class Pig:
 2     words = 'aaaaaa'
 3     @classmethod
 4     def print_words(cls):
 5         cls.words = 'wwwwwwww'   #會修改類變量的值
 6         print('這是一個類方法，words= %s'%cls.words)
 7         # cls.print_word()  #不能調用實例方法，會報錯
 8 
 9     @staticmethod
10     def print_static():
11         print('這是一個靜態方法,不能調用任何變量、方法')
12 
13     def print_word(self):
14         Pig.words = '自定義方法'
15         print(Pig.words)
16 
17 print(Pig.words)  #aaaaaa
18 Pig.print_words()  #wwwwwwww
19 Pig.print_static()  #這是一個靜態方法,不能調用任何變量
20 print(Pig.words)  #wwwwwwww

類的繼承 ：

面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是經過繼承機制。經過繼承建立的新類稱爲子類或派生類，被繼承的類稱爲基類、父類或超類。

繼承語法：

1 class 派生類名(基類名)
2     ...

在python中繼承中的一些特色：

• 一、若是在子類中須要父類的構造方法就須要顯示的調用父類的構造方法，或者不重寫父類的構造方法。
• 二、在調用基類的方法時，須要加上基類的類名前綴，且須要帶上 self 參數變量。區別在於類中調用普通函數時並不須要帶上 self 參數
• 三、Python 老是首先查找對應類型的方法，若是它不能在派生類中找到對應的方法，它纔開始到基類中逐個查找。（先在本類中查找調用的方法，找不到纔去基類中找）。

 1 class Parent:
 2     parentAttr = 100
 3     def __init__(self):
 4         print('調用父類的構造函數！')
 5 
 6     def parentMethod(self):
 7         print('調用父類方法')
 8 
 9     def setAttr(self,attr):
10         Parent.parentAttr = attr
11 
12     def getAttr(self):
13         print('父類屬性 ： ',Parent.parentAttr)
14 
15 class Child(Parent):
16     def __init__(self):
17         print('調用子類構造方法！')
18 
19     def childMethod(self):
20         print('調用子類方法')
21 
22     def childGetParent(self):
23         print('子類調用父類的方法')
24         self.getAttr()  #在子類中調用父類的方法，用self
25 
26 c = Child()      #實例化子類
27 c.childMethod()  #調用子類的方法
28 c.parentMethod() #調用父類的方法
29 c.setAttr(200)   #調用父類的方法設置類變量
30 c.getAttr()      #調用父類的方法
31 c.childGetParent() #調用子類的方法，子類方法中調用父類的方法

繼承多個類的語法：

class A:        # 定義類 A
.....

class B:         # 定義類 B
.....

class C(A, B):   # 繼承類 A 和 B

你可使用issubclass()或者isinstance()方法來檢測。

• issubclass() - 布爾函數判斷一個類是另外一個類的子類或者子孫類，語法：issubclass(sub,sup)
• isinstance(obj, Class) 布爾函數若是obj是Class類的實例對象或者是一個Class子類的實例對象則返回true。

方法重寫：

若是你的父類方法的功能不能知足你的需求，你能夠在子類重寫你父類的方法

 1 class Parent:
 2     parentAttr = 100
 3     def __init__(self):
 4         print('調用父類的構造函數！')
 5 
 6     def setAttr(self,attr):
 7         Parent.parentAttr = attr
 8 
 9     def getAttr(self):
10         print('父類屬性 ： ',Parent.parentAttr)
11 
12 class Child(Parent):
13     def __init__(self):
14         print('調用子類構造方法！')
15 
16     def setAttr(self,attr):
17         self.parentAttr = attr #給實例對象新增parentAttr 的屬性
18         print('子類重寫父類的方法,self.parentAttr = %s'%self.parentAttr)
19 
20 c = Child()      #實例化子類
21 c.setAttr(200)   #調用子類的方法設置類變量,輸出：200
22 c.getAttr()      #調用父類的方法，輸出： 100

使用super()方法調用父類方法

 1 class Parent:
 2     parentAttr = 100
 3     def __init__(self):
 4         print('調用父類的構造函數！')
 5 
 6     def setAttr(self,attr):
 7         Parent.parentAttr = attr
 8 
 9     def getAttr(self):
10         print('父類屬性 ： ',Parent.parentAttr)
11 
12 class Child(Parent):
13     def __init__(self):
14         print('調用子類構造方法！')
15 
16     def setAttr(self,attr):
17         super().setAttr(attr)  #super()調用父類的方法
18         print('子類重寫父類的方法,self.parentAttr = %s'%self.parentAttr)

21 c = Child()      #實例化子類
22 c.childMethod()  #調用子類的方法
23 c.parentMethod() #調用父類的方法
24 c.setAttr(200)   #調用子類的方法設置類變量,輸出：200
25 c.getAttr()      #調用父類的方法，輸出： 200