一.面向對象技術簡介：

• 類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
• 類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為實例變量使用。
• 數據成員：類變量或者實例變量用於處理類及其實例對象的相關的數據。
• 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
• 實例變量：定義在方法中的變量，只作用於當前實例的類。
• 繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，素以Dog也是一個Animal。
• 實例化：創建一個類的實例，類的具體對象。
• 方法：類中定義的函數。
• 對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

二.類：

　　三種定義類的方式：

class My:  #經典類
    pass

class My2(object):  #新式類
    pass

class My3(): #新式類
    pass

簡單例子：定義一個叫MyDb數據庫操作類，裏面包含數據庫的一些方法。

 1 class MyDb:
 2     def __init__(self,host,user,password,db,port=3306,charset=‘utf8
 
‘):#構造函數，
 3         print(‘連接數據庫‘)
 4         self.conn = pymysql.connect(host=host,user=user,password=password,
 5                         db=db,port=port,charset=charset)
 6         self.cur = self.conn.cursor()
 7 
 8     def execute_one(self,sql):
 9         print(‘返回單條數據‘)
10         self.cur.execute(sql)
 
11         res = self.cur.fetchone()
12         return res
13 
14     def execute_many(self,sql):
15         print(‘返回多條數據的‘)
16         self.cur.execute(sql)
17         res = self.cur.fetchall()
18         return res
19 
20     def __del__(self):#析構函數
21         print(‘關閉數據庫連接‘)
22         self.cur.close()
23         self.conn.close()
24 
25 my = MyDb(‘192.168.1.40‘,‘jxz‘,‘123456‘,‘jxz‘) #實例化
26 
27 #一個變量前面加了self之後，那麽在這個類裏面的其他的函數都可以用了。
28 
29 res = my.execute_one(‘select * from app_myuser where username="testuser1";‘)
30 print(res)
31 
32 res2 = my.execute_many(‘select * from app_myuser limit 10;‘)
33 
34 print(res2)

其中__init__和__del__分別是構造函數和析構函數。構造函數是在實例化時候被調用，一般都是為這個實例化對象賦初始值，析構函數是在這個對象生命周期結束的時候調用。他們默認都是自動調用。但是也有顯示調用。

__init__()方法是可選的，如果不提供，Python 會給出默認的__init__方法。

__del__()也是可選的，如果不提供，則Python 會在後臺提供默認析構函數如果要顯式的調用析構函數，可以使用del關鍵字，方式如下：

 1 class Car:
 2     wheel = 4 #類變量
 3     def __init__(self,color,p):
 4         self.color = color #實例變量
 5         self.p = p
 6 
 7     def help(self):
 8         print(‘汽車有%s個輪子‘%self.wheel)
 9         print(‘汽車的顏色是%s‘%self.color)
10         print(‘牌子%s‘%self.p)
11         print(‘=‘*10)
12         self.haha()
13         self.check_wheel()
14 
15     @classmethod
16     def check_wheel(cls):#類方法
17         print(‘cls的內存地址‘,id(cls))
18         print(cls.wheel)
19         cls.haha()
20 
21     @classmethod
22     def haha(cls):
23         print(‘哈哈哈‘)
24         cls.help2()
25 
26     @staticmethod
27     def help2():#靜態方法
28         print(‘這個類的作用是造汽車，它裏面有xxx方法‘)
29 
30     @property
31     def yesterday(self):#屬性方法
32         import datetime
33         res = datetime.date.today()  + datetime.timedelta(-1)
34         return str(res)
35 
36     def tom(self):
37         import datetime
38         res = datetime.date.today()  + datetime.timedelta(1)
39         return str(res)

　實例屬性：類裏的實例方法的第一個參數必須為self，這是實例方法的唯一標誌。可以理解為self就是實例本身，因此實例方法必須在實例化後才可以調用（因為不實例化就是不存在的）。各個實例有自己獨立的實例空間，存放自己的實例屬性（變量和方法）。所以在實例化後，可以新增實例屬性（實例變量）。實例方法裏面可以隨便通過self來調用實例方法，類方法，靜態方法，類變量。

　類屬性：包括方法和變量，類方法必須由@classmethod裝飾，並且方法的第一個參數必須是cls，不需要實例化就可以調用，類屬性的空間和實例屬性的空間是獨立的，一個類的屬性空間只有一個，雖然類屬性可以被其他對象訪問，但是由於空間獨立，類屬性只能由類自己修改，實例可以訪問，無權修改。

1 Car.help2()
2 mcb = Car(‘赤橙黃綠青藍紫‘,‘馬春波‘)
3 print(mcb.wheel)#實例沒有定義wheel的時候，默認使用類變量
4 mcb.wheel=8
5 print(mcb.wheel)#當實例定義了自己的wheel屬性的時候，使用的就是自己的wheel
6 print(Car.wheel)

結果：

這個類的作用是造汽車，它裏面有xxx方法
4
8
4

要註意的是：實例名.類屬性和類名.類屬性是兩個獨立的空間，值互不影響。

　　靜態方法：不需要實例化就可以調用的，它就是一個定義在類裏面的普通函數，不能使用實例變量、實例方法、不能使用類變量、類方法。用@staticmethod裝飾，沒有必寫參數。一般用來打印信息。

　　私有方法：變量、函數，前面加兩個下劃線就代表是一個私有的，只能在類裏面用。在類外面就不能使用，只能通過類方法或者實例方法去修改。出於安全考慮，就是提供了修改或操作的接口才能進行修改，否則其他無權修改。

 1 class My:
 2     def test(self):
 3         self.__password = 123456
 4     def say(self):
 5         print(‘password‘,self.__password)
 6     def __set_password(self):
 7         self.__password = 7890
 8     def update(self):
 9         self.__set_password()
10 
11 m = My()
12 m.test()
13 m.say()
14 m.update()
15 m.say()

password 123456
password 7890

　　屬性方法：用@property裝飾，改方法不允許帶參數，例如上述的yesterday（），作用就是在調用的時候省去括號，比如這個方法調用就是print(mcb.yesterday)。

四.繼承：

　　子類可以繼承父類的方法而無需重新定義他們。繼承最大的好處是子類獲得了父類的全部功能。當然，也可以對子類增加一些方法。或者重寫父類的方法。

class Lm:
    money = 1000000
    house = 5
    def driver(self):
        print(‘會開車‘)

class Mcb(Lm):
    def about_me(self):
        print(‘我有 %s 錢 ,%s 房子‘%(self.money,self.house))
        self.driver()

    def driver(self):#方法重載
        print(‘會開28個輪子的汽車‘)


m = Mcb()
m.driver()
m.about_me()

會開28個輪子的汽車
我有 1000000 錢 ,5 房子
會開28個輪子的汽車

學習筆記九 面向對象編程