python學習筆記（十九）面向對象編程，類

時間 2019-11-30

原文原文鏈接

1、面向對象編程mysql

面向對象，是一種程序設計思想。redis

編程範式：編程範式就是你按照什麼方式去編程，去實現一個功能。不一樣的編程範式本質上表明對各類類型的任務採起的不一樣的解決問題的思路，兩種最重要的編程範式分別是面向過程編程和麪向對象編程。sql

面向過程：什麼是面向過程，面向過程的思想就是把一個項目，一件事情按照必定的順序，從頭至尾一步一步的作下去，先作什麼，後作什麼，一直到結束。這種編程思想，只要前面一個步驟變了，那麼後面的就也要變，後面維護一塊兒比較麻煩，這樣的編程思想，咱們在寫一些簡單的小程序，只執行一次的腳本時可使用。數據庫

面向對象：面向對象的思想就是把一個項目，一件事情分紅更小的項目，或者說分紅一個個更小的部分，每一部分負責什麼方面的功能，最後再由這些部分組合而成爲一個總體。這種思想比較適合多人的分工合做，就像一個大的機關，分各個部門，每一個部門分別負責某樣職能，各個部門能夠充分發揮本身的特點，只有符合一個前提就行。編程

二，面向對象的特性：小程序

類：classapp

類，對比現實世界來講就是一個種類，一個模型編程語言

一個類便是對一類擁有相同屬性的對象的抽象，藍圖，原型函數式編程

在類中定義了這些對象的都具有的屬性，共同的方法。函數

對象：object

對象，也就是指模型造出來的具體的東西

一個對象既是一個類的實例化後實例，一個類必須通過實例化方可在程序中調用，一個類能夠實例化多個對象，每一個對象亦能夠有不一樣的屬性，就像人類是指全部人，每一個人是指具體的對象，人與人之間有性，亦有不一樣

實例化：

初始化一個類，造了一個對象。把一個類變成一個具體的對象的過程，叫作實例化

封裝：

把一些功能的實現細節不對外暴露，類中對數據的賦值，內部調用對外部用戶是透明的，這使類變成了一個膠囊或者容器，裏面包含着類的數據和方法

繼承：

一個類能夠派生出子類，在這個父類裏定義的屬性，方法自動被子類繼承。

繼承是爲了代碼的重用

多態：

對不一樣類的對象發出相同的消息將會有不一樣的行爲。

多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來，再經過這個抽象的事物，與不一樣的具體事物進行對話

一種接口，多種實現

三，面向對象的好處

對於編程語言的初學者來說，OOP不是一個很容易理解的編程方式，你們雖然都按老師講的都知道OOP的三大特性是繼承、封裝、多態，而且你們也都知道了如何定義類、方法等面向對象的經常使用語法，可是一到真正寫程序的時候，仍是不少人喜歡用函數式編程來寫代碼，特別是初學者，很容易陷入一個窘境就是「我知道面向對象，我也會寫類，但我依然沒發如今使用了面向對象後，對咱們的程序開發效率或其它方面帶來什麼好處，由於我使用函數編程就能夠減小重複代碼並作到程序可擴展了，爲啥子還用面向對象？」對於此，我我的以爲緣由應該仍是由於你沒有充分了解到面向對象能帶來的好處。

不管用什麼形式來編程，咱們都要明確記住如下原則：

寫重複代碼是很是很差的低級行爲

你寫的代碼須要常常變動

開發正規的程序跟那種寫個運行一次就扔了的小腳本一個很大不一樣就是，你的代碼老是須要不斷的更改，不是修改bug就是添加新功能等，因此爲了往後方便程序的修改及擴展，你寫的代碼必定要遵循易讀、易改的原則（專業數據叫可讀性好、易擴展）。

若是你把一段一樣的代碼複製、粘貼到了程序的多個地方以實如今程序的各個地方調用，這個功能，那往後你再對這個功能進行修改時，就須要把程序裏多個地方都改一遍，這種寫程序的方式是有問題的，由於若是你不當心漏掉了一個地方沒改，那可能會致使整個程序的運行都 出問題。 所以咱們知道 在開發中必定要努力避免寫重複的代碼，不然就至關於給本身再挖坑。

還好，函數的出現就能幫咱們輕鬆的解決重複代碼的問題，對於須要重複調用的功能，只須要把它寫成一個函數，而後在程序的各個地方直接調用這個函數名就行了，而且當須要修改這個功能時，只需改函數代碼，而後整個程序就都更新了。

其實OOP編程的主要做用也是使你的代碼修改和擴展變的更容易，那麼小白要問了，既然函數都能實現這個需求了，還要OOP幹毛線用呢？ 呵呵，說這話就像，古時候，人們打仗殺人都用刀，後來出來了槍，它的主要功能跟刀同樣，也是殺人，而後小白就問，既然刀能殺人了，那還要槍幹毛線，哈哈，顯而易見，由於槍能更好更快更容易的殺人。函數編程與OOP的主要區別就是OOP可使程序更加容易擴展和易更改。

4、類
屬性：屬性就是裏面的一個變量，有類變量和實例變量，類變量是類在定義的時候就有的，實例變量是在實例化的時候才產生的變量。這個能夠理解爲，人是一個類，他的名字，年齡，性別就是它的屬性

方法：方法就是類的功能，也就是定義在類裏面的函數，它實現了某個功能，好比說人有睡覺的功能。

構造函數：就是類在實例化的時候作的某些初始化操做

析構函數：就是這個實例在銷燬的時候作的一些操做

定義類：

定義類使用class關鍵字，類名通常首字母大寫。

 1 class Car():#模型，模板
 2     def __del__(self):
 3         #析構函數，這個實例被銷燬的執行的。
 4         print('over..')
 5 
 6     def my_self(self):
 7         print(
 8             '我是一個汽車 個人顏色是【%s】,我有【%s】個窗戶'%(self.color,self.window)
 9         )
10         self.price = 10002
11     def run(self):
12         print(self.color)
13         print(self.window)
14         print(self.price)
15         print('汽車在跑。。。')
16 
17     def __init__(self,color,window):
18         #
19         #構造函數，是類在初始化的時候會執行它
20         #若是你的類在實例化的時候要傳入一些參數，那麼你就要在__init__這個函數裏寫參數了
21         self.color = color  #綁定屬性
22         self.window = window
23         print('執行我了。。')
24 
25 #把模型作成實際的一個汽車，這個過程叫作實例化。
26 bus = Car('黃色','3開門') #實例化
27 bus2 = Car('黑色','4開門') #實例化
28 bus3 = Car('粉色','2開門') #實例化
29 bus.my_self()   #
30 bus2.my_self()
31 bus3.my_self()
32 
33 #實例就是指具體造出來的東西，經過類實例化處理的東西，就是實例
34 #對象，就是實例
35 #

繼承：

 1 class WssFather(object):
 2     @property
 3     def money(self):
 4         return 10000000
 5     def smoke(self):
 6         self.yan = '玉溪'
 7         print('抽菸')
 8     def drink(self):
 9         print('喝酒')
10     def tangtou(self):
11         print('燙頭')
12 
13 class Wss(WssFather):
14     def driver(self):
15         print('開車')
16 
17 class Animal(object):
18     def eat(self,name):
19         print('吃')
20 
21 
22 class Brid(Animal):
23     pass

實例變量：

 1 class Person(object):
 2     country = 'China' #類變量
 3     def __init__(self,name,age,sex):
 4         self.name=name #實例變量，必須實例化以後才能用,成員變量
 5         self.age=age
 6         self.sex=sex
 7 
 8     def say_my_country(self):
 9         print(self.country)
10 
11 print(Person.country)
12 # dsx = Person(小師妹,23,'男')
13 # print(dsx.name)
14 # print(dsx.age)
15 # print(dsx.sex)
16 # print(dsx.country)
17 # ybq = Person('綠蘿',28,'男')

靜態方法，類方法：

私有方法、私有屬性：

什麼是私有，私有就是隻有在類裏面能夠訪問，實例化以後不能夠訪問和調用，有私有方法和私有屬性。私有就把變量名或者函數名前面加上"__"兩個下劃線，其實就是經過私有來實現封裝的


　　import redis
 2 class MyRedis():
 3     xiaohei = '哈哈哈'
 4     def __init__(self,host,password='',port=6379):
 5         self.__host = host #私有屬性
 6         self.passwd = password
 7         self.port = port
 8         self.__coon_redis()
 9     def __coon_redis(self): #私有方法
10         self.coon = redis.Redis(host=self.__host,password=self.passwd,port=self.port)
11     def get(self,k):
12         print('__host...',self.__host)
13         return self.coon.get(k).decode()
14 
15     @staticmethod #靜態方法
16     def other():
17         print('我是other')
18     @classmethod#類方法，也不須要實例化，直接就能用。它靜態方法高級一點
19     #它可使用類變量和類方法。
20     def class_fun(cls):
21         print(cls.xiaohei)
22         cls.class_fun2()
23     @classmethod
24     def class_fun2(cls):
25         print('我是類方法2')
26 # r = MyRedis('211.149.218.16','123456')
27 MyRedis.class_fun()

小練習：
#簽名，做用爲了做弊

#sign ：82B20DE4-40C2-4859-9DBC-C93B0FBFD09C

#1.先取用戶的設備號碼，md5 加密一次

#2.再取加密以後前10位

#3.再加鹽，再給md5一次

#4.最後生成一個字符串

 1 from hashlib import md5
 2 class GetSign(object):
 3     slat='SDF234_&#$_12'
 4     def __init__(self,device_id):
 5         self.device_id=device_id
 6     def md5(self,str):
 7         #md5加密的
 8         s=str.encode()
 9         m=md5(s)
10         return m.hexdigest()
11     @property #把這個函數變成一個屬性方法 ,若是這個方法沒有入參，那就能夠給變成一個屬性方法
12     def get_res(self):
13         first_md5 = self.md5(self.device_id)
14     tmp = first_md5[:10] #取前10位
15     after_salt = tmp+self.slat
16     self.sign = self.md5(after_salt)
17     return self.sign
18 res = GetSign('82B20DE4-40C2-4859-9DBC-C93B0FBFD09C')
19 print(res.device_id)
20 print(res.get_res)

寫日誌：

 1 import logging
 2 from logging import handlers
 3 
 4 
 5 class Logger(object):
 6     level_relations = {
 7         'debug': logging.DEBUG,
 8         'info': logging.INFO,
 9         'warning': logging.WARN,
10         'error': logging.ERROR,
11         'crit': logging.CRITICAL
12     }  # 日誌級別關係映射
13 
14     def __init__(self, fp, level='debug', when='midnight', interval=1, backCount=5, encoding='utf-8'):
15         '''
16 
17         :param fp:日誌文件路徑
18         :param level: 日誌級別 默認是debug
19         :param when: 分割日誌的單位 S 秒、M 分、 H 小時、 D 天、 W 每星期（interval==0時表明星期一）、midnight 天天凌晨
20         :param interval: 時間間隔 默認天天凌晨
21         :param backCount: 備份文件個數 默認5個
22         :param encoding: 日誌文件編碼
23         '''
24         self.level = self.level_relations.get(level)
25         self.logger = logging.getLogger(fp)
26         self.logger.setLevel(self.level)
27         fmt = logging.Formatter('%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s')
28         sh = logging.StreamHandler()
29         sh.setFormatter(fmt)
30         sh.setLevel(self.level)
31         th = handlers.TimedRotatingFileHandler(fp, when=when, interval=interval, backupCount=backCount,
32                                                encoding=encoding)
33         th.setFormatter(fmt)
34         th.setLevel(self.level)
35         self.logger.addHandler(th)
36         self.logger.addHandler(sh)
37 
38     def debug(self, msg):
39         self.logger.debug(msg)
40 
41     def info(self, msg):
42         self.logger.info(msg)
43 
44     def warning(self, msg):
45         self.logger.warning(msg)
46 
47     def error(self, msg):
48         self.logger.error(msg)
49 
50     def crit(self, msg):
51         self.logger.critical(msg)
52 
53 
54 if __name__ == '__main__':
55     l = Logger('a.log')  # 實例化
56     l.info('hehehe')  # 調用
57     l.debug('哈哈哈')
58     l.error('xxx')

 1 class My():
 2     def __init__(self,name):
 3         self.name = name
 4         self.cry()
 5     def cry(self): #實例方法，必須得實例化後才能夠調用
 6         print('%s在哭。。。'%self.name)
 7     def learn(self):
 8         self.skill = ['開車']
 9     def my_self(self):
10         print('個人名字【%s】 我會%s'%(self.name,self.skill))
11 
12 wsl = My('小黑黑') #    self = wsl
13 wsl.skill = '黑'
14 wsl.learn()
15 wsl.skill.append('花')
16 wsl.skill.append('話')
17 wsl.skill.append('滑')
18 wsl.my_self()
19 wsl.learn()
20 wsl.my_self()
21 
22 td = My('蘑菇')

鏈接數據庫：

 1 import pymysql
 2 class OpMySql1:  #經典類
 3     pass
 4 
 5 class OpMySql(object):#新式類
 6     def __init__(self,host,user,password,db,port=3306,charset='utf8'):
 7         schema = {
 8             'user':user,
 9             'host':host,
10             'password':password,
11             'db':db,
12             'port':port,
13             'charset':charset
14         }
15         try:
16             self.coon = pymysql.connect(**schema)
17         except Exception as e:
18             print('數據庫鏈接異常！%s'%e)
19             quit('數據庫鏈接異常！%s'%e)
20         else:#沒有出異常的狀況下，創建遊標
21             self.cur = self.coon.cursor(cursor=pymysql.cursors.DictCursor)
22 
23     def execute(self,sql):
24         try:
25             self.cur.execute(sql)
26         except Exception as e:
27             print('sql有錯誤%s'%e)
28             return e
29         if sql[:6].upper()=='SELECT':
30             return self.cur.fetchall()
31         else:#其餘sql語句的話
32             self.coon.commit()
33             return 'ok'
34 
35     def __del__(self):
36         self.cur.close()
37         self.coon.close()
38 
39 ybq = OpMySql('211.149.218.16','jxz','123456',db='jxz')  #實例化
40 
41 print(ybq.execute('select * from stu;'))
42 print(ybq.execute('select * from stu;'))
43 print(ybq.execute('select * from stu;'))

url編碼：

1 import urllib.parse
2 s='besttest 自動化測試'
3 print(urllib.parse.quote(s)) #url編碼
4 print(urllib.parse.quote_plus(s)) #url編碼,
5 src='https://www.baidu.com/s?wd=besttest%20%E8%87%AA%E5%8A%A8%E5%8C%96%E6%B5%8B%E8%AF%95&rsv_spt=1&rsv_iqid=0x90f615640005e9b2&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&rqlang=cn&tn=baiduhome_pg&rsv_enter=1&inputT=8129&rsv_t=0d22VbBsLUg6wkL0kNn1rPhfwhU%2F5UCRNiEBd5oqMzEh6ImgExR7fH65dNLwCf0ilzUT&rsv_sug3=36&rsv_sug1=9&rsv_sug7=100&oq=besttest&rsv_pq=f857c55a00063cfd&rsv_sug2=0&rsv_sug4=8623'
6 
7 print(urllib.parse.unquote(src)) #url解碼
8 print(urllib.parse.unquote_plus(src)) #url解碼

self表明本類對象

修改父類的方法：

重寫父類的方法的目的是爲了給他擴展一些功能

核心思想就一句話，先調用一下你要重寫的父類方法，而後再加新的代碼就行了。

1 class Coon(object):
2     def conn(self,host,passwd):
3         print(host,passwd)
4 class Coon2(Coon):
5     def conn(self):
6         #重寫父類的方法
7         print('hahahha')
8 c=Coon2()
9 c.conn() #hahahha

 1 class Coon(object):
 2     #基類
 3     def __init__(self,host,passwd,port):
 4         self.host=host
 5         self.passwd=passwd
 6         self.port=port
 7 class CoonMySql(Coon):
 8     def __init__(self,host,passwd,port,username,db,charset='utf8'):
 9         Coon.__init__(self,host,passwd,port)#在調用父類的構造方法，我們本身手動調用父類的方法
10         self.username=username
11         self.db=db
12         self.charset=charset
13     def coon_mysql(self):
14         print(self.host)
15 
16 
17 class Coon(object):
18     #基類
19     def __init__(self,host,passwd,port):
20         self.host=host
21         self.passwd=passwd
22         self.port=port
23 class CoonMySql(Coon):
24     def __init__(self,host,passwd,port,username,db,charset='utf8'):
25        super(CoonMySql,self).__init__(host,passwd,port)#super自動幫忙找到父類，而後調用
26         self.username=username
27         self.db=db
28         self.charset=charset
29     def coon_mysql(self):
30         print(self.host)