以前都是面向過程編程，做一件事是按順序來的，必須經過很多操作。現在是面向對象編程，將各種操作集合在一起，然後指揮其適用於多個場景。
上課時老師舉了一個蠻貼切的例子，比如買車，面向過程就是先去學車，然後去4s店買車，然後去辦證，然後保險，然後臨時牌照，然後正式牌照。面向對象就像將這些所有步驟會經歷的場景整合起來，直接開一個車輛
購置辦證中心，然後從學車到辦證甚至以後的繳納罰款全都在這裏處理。
在我的理解，面向對象就是給一些有共同性的事物先造一個模型，這個模型有這些事物共同的屬性，也有這些事物共同的處理方法。然後一旦需要針對某個事物單獨操作時，只要調用
這個模型，這個事物就可以根據已經配好的屬性和方法很快的建造起來。
面向對象編程有幾個基礎的點，分別是類、構造函數、屬性、方法、實例化。細化分還有類變量、實例變量、類方法、實例方法、析構函數、私有化、繼承等等。
1、類
 
類是利用class定義的，如num1和num2，這兩者的區別是類num2後面的括號裏有“object”，前者被稱為經典類，後者被稱為新式類。沒有很大的區別。

1 class num1():  
2     pass
3 
4 class num2(object):
5     pass

2、屬性

屬性其實就是變量，包括類變量（直接在類中定義的變量）和實例變量（在“def __init__(self):”下定義的變量）。

比如一個班有很多個學生，都生活在成都，學生們的年級、班級和年齡假設都是一樣的，那麽這些就是學生的共同屬性，可以用變量先定義。

1 class Students():
2
 
     county = ‘China‘  # 類變量，公共變量，每個實例都能用，可以節省內存
3     def __init__(self):
4         self.class = ‘高三二班‘  # 實例變量
5         self.age = 18

3、方法

如果我們要打印這個班學生的姓名、班級和年齡。那麽就得創造一個方法，也是一個函數。比如下面的print_info函數，就可以打印出每個對象的姓名、班級和年齡。

 1  class Students():
 2      county = ‘China‘  # 類變量，公共變量，每個實例都能用，可以節省內存
 3      def
 
 __init__(self， name):
 4           self.class = ‘高三二班‘  # 實例變量
 5           self.age = 18
 6             self.name = name
 7  
 8      def print_info(self):
 9          print(‘學生的姓名是%s‘ % self.name)
10          print(‘學生的班級是%s‘ % self.class)
11          print(‘學生的年齡是%s‘ % self.age)

4、實例化

每一個類都是必須實例化才能使用的，不能那種車輛模型開車上路對吧，還是要有一輛真正的車才行。實例化就相當於對比著自己喜歡的模型得到一個真實的物品，這個物品是根據模型對比購買的，所以它擁有和模型同樣的顏色、模樣等等。所以實例化的對象是擁有類裏面的屬性和方法的。

 1  class Students():
 2      county = ‘China‘  # 類變量，公共變量，每個實例都能用，可以節省內存
 3      def __init__(self， name):
 4           self.class = ‘高三二班‘  # 實例變量
 5           self.age = 18
 6           self.name = name
 7  
 8      def print_info(self):
 9          print(‘學生的姓名是%s‘ % self.name)
10          print(‘學生的班級是%s‘ % self.class)
11          print(‘學生的年齡是%s‘ % self.age)
12 
13 zxm = Student(name = ‘張曉明‘)  # 實例化
14 print(zxm.class)  # 輸出結果為18
15 zxm.print_info()  # 會打印zxm這個對象的姓名、班級、年齡

5、構造函數和析構函數

構造函數就是類實例化時運行的函數，析構函數就是銷毀實例化對象的函數。一般連接數據庫後需要關閉數據庫，這裏可以將關閉數據庫的代碼放在析構函數中，這樣執行完畢後自動銷毀實例同時自動關閉鏈接。

 1 class MyDb(object):
 2     # 析構函數
 3     def __del__(self):
 4         self.cur.close()
 5         self.coon.close()
 6         print(‘over....‘)
 7     # 構造函數
 8     def __init__(self,
 9                  host,user,passwd,db,
10                  port=3306,charset=‘utf8‘):
11         try:
12             self.coon = pymysql.connect(
13                 host=host,user=user,passwd=passwd,
14                 port=port,db=db,charset=charset,
15                 autocommit=True  # 自動提交，在非select語句時可以不需要再commit了
16             )
17         except Exception as e:
18             print(‘數據庫鏈接失敗！%s‘ % e)
19         else:
20             self.cur = self.coon.cursor(cursor=pymysql.cursors.DictCursor)

6、私有

變量分私有變量和公有變量，顧名思義，私有變量就是只能在類裏面調用的不可修改的變量，而公有變量是在類外對象也可以調用修改的變量。私有變量的定義方法就是在變量名前面加兩個下劃線。

 1 import redis
 2 class My(object):
 3     def __init__(self):
 4         self.__host = ‘***.*.**.**‘  # 私有變量
 5         self.__port = 6379
 6         self.__password = ‘*******‘
 7 
 8         self.r = redis.Redis(host=self.host,port=self.port,password=self.password)
 9 
10     def get(self, k):
11         res = self.r.get(k)
12         if res:
13             return res.decode()
14         return None

1 my = My()  #實例化
2 my.port = 9999  # port是私有變量無法修改
3 print(my.__host)  # host是私有變量，無法在類外調用
4 my.__close()  # close是私有方法，無法在類外調用

7、繼承

定義新式類時括號中一般會寫“object”，其實這就是定義的類繼承了object類。所以寫在括號中的類就是定義的類所要繼承的類。被繼承的類可以成為父類或者基類，新的類成為子類。子類可以繼承父類的所有屬性和方法，並可以定義自己的屬性和方法且不會影響父類。

比如下面，定義了一個連接數據庫的基礎類，這個類有一些屬性如host、port、password等等。而不論連接mysql數據庫或者redis數據庫都會用到這些屬性。那麽定義MySQL類和redis類時就可以直接繼承Base類，這樣host、port、password這些屬性就可以直接使用了。

 1 class Base(object):
 2     def __init__(self, host, port, password):
 3         self.host = host
 4         self.port = port
 5         self.password = password
 6 
 7 
 8 class Mysql(Base):
 9     pass
10 
11 
12 class Redis(Base):
13     pass

接口測試學習-python第七課（面向對象編程）