面向對象進階
阿新 • • 發佈：2017-11-06
影響 面向 eat 其他 imp 分布式計算 進階 exception 使用 
一、isistance(obj,cls)和issubclass(sub,supper)
isistance(obj,cls)檢查obj是否是類cls的對象
class Foo(object):
pass
obj = Foo()
isinstance(obj, Foo)
issubclass(sub, super)檢查sub類是否是 super 類的派生類
class Foo(object): pass class Bar(Foo): pass issubclass(Bar, Foo)
二、反射
一、什麽是反射
反射的概念式有Smith在1982年首次提出的，主要是指程序可以訪問、檢測和修改它本身狀態或行為的一種能力（自省）。
二、Python中面向對象中的反射
通過字符串的形式操作對象先關的屬性。Python中的一切事物都是對象，都可以使用反射。
1、反射相關的四個函數（適用於類和對象：Python中一切皆對象，類本身也是一個對象）
1、hasattr(object,name) 判斷object中有沒有一個name字符串對應的方法或屬性 2、getattr(object, name, default=None) def getattr(object, name, default=None): #known special case of getattr """ getattr(object, name[, default]) -> value Get a named attribute from an object; getattr(x, ‘y‘) is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn‘t exist; without it, an exception is raised in that case.""" pass 3、setattr(x, y, v) def setattr(x, y, v): # real signature unknown; restored from __doc__ """ Sets the named attribute on the given object to the specified value. setattr(x, ‘y‘, v) is equivalent to ``x.y = v‘‘ """ pass 4、delattr(x, y) def delattr(x, y): # real signature unknown; restored from __doc__ """ Deletes the named attribute from the given object. delattr(x, ‘y‘) is equivalent to ``del x.y‘‘ """ pass
2、使用實踐
應用：可以判斷使用模塊或者類中是否包含某個屬性或方法，有則執行，沒有告知。
1 # 通過輸入的內容，找到相應的值 2 class Person: 3 role = ‘Person‘ 4 country = ‘China‘ 5 6 def __init__(self,name,age): 7 self.name = name 8 self.age = age 9 10 def func(self): 11 print(‘%s in func‘ %self.name) 12 alex = Person(‘alex‘,20) 13 # # 通過反射調用類中的屬性 14 # name = input(‘屬性名：‘) 15 # 判斷類中是否有相應的屬性，有的話，返回結果；沒有的話，什麽都不做 16 # person.role 17 if hasattr(Person,name): 18 print(getattr(Person,name)) 19 20 # 通過輸入字符串的形式，訪問類中的變量 alex.name alex.age 21 if hasattr(alex,‘age‘): 22 print(getattr(alex,‘age‘)) 23 24 # 通過反射調用類中的方法 25 if hasattr(alex,‘func‘): 26 func = getattr(alex,‘func‘) 27 func() 28 29 30 def func2(self): 31 print(‘%s in func2‘ % self.name) 32 # # setattr 33 # alex.sex = None 34 # setattr(alex,‘sex‘,‘不詳‘) 35 # print(alex.sex) 36 37 # setattr(alex,‘func2‘,func2) ##setattr綁定方法是一個假的，在使用的時候必須要手動傳self 38 # alex.func2(alex) 39 # print(alex.func) 40 41 42 # delattr 43 # delattr(alex,‘name‘) #等價於del alex.name ##刪除屬性
三、使用反射的好處
好處一：實現可插拔機制
有倆程序員，一個lili，一個是egon，lili在寫程序的時候需要用到egon所寫的類，但是egon去跟女朋友度蜜月去了，還沒有完成他寫的類，lili想到了反射，使用了反射機制lili可以繼續完成自己的代碼，等egon度蜜月回來後再繼續完成類的定義並且去實現lili想要的功能。
總之反射的好處就是，可以事先定義好接口，接口只有在被完成後才會真正執行，這實現了即插即用，這其實是一種‘後期綁定’，什麽意思？即你可以事先把主要的邏輯寫好（只定義接口），然後後期再去實現接口的功能
1 class FtpClient: 2 ‘ftp客戶端,但是還麽有實現具體的功能‘ 3 def __init__(self,addr): 4 print(‘正在連接服務器[%s]‘ %addr) 5 self.addr=addregon還沒有完成功能
1 #from module import FtpClient 2 f1=FtpClient(‘192.168.1.1‘) 3 if hasattr(f1,‘get‘): 4 func_get=getattr(f1,‘get‘) 5 func_get() 6 else: 7 print(‘---->不存在此方法‘) 8 print(‘處理其他的邏輯‘)不影響lili代碼編寫
好處二：動態導入模塊（基於反射當前模塊成員）
三、類中的裝飾器property、classmethod和staticmethod
一：綁定方法（綁定給誰，誰來調用就自動將它本身當作第一個參數傳入）：
1. 綁定到類的方法：用classmethod裝飾器裝飾的方法。
為類量身定制
類.boud_method(),自動將類當作第一個參數傳入
（其實對象也可調用，但仍將類當作第一個參數傳入）
2. 綁定到對象的方法：沒有被任何裝飾器裝飾的方法。
為對象量身定制
對象.boud_method(),自動將對象當作第一個參數傳入
（屬於類的函數，類可以調用，但是必須按照函數的規則來，沒有自動傳值那麽一說）
二：非綁定方法：用staticmethod裝飾器裝飾的方法
1. 不與類或對象綁定，類和對象都可以調用，但是沒有自動傳值那麽一說。就是一個普通工具而已
註意：與綁定到對象方法區分開，在類中直接定義的函數，沒有被任何裝飾器裝飾的，都是綁定到對象的方法，可不是普通函數，對象調用該方法會自動傳值，而staticmethod裝飾的方法，不管誰來調用，都沒有自動傳值一說
一、property 將功能屬性轉化為數據屬性
1、計算圓的周長和面積
1 # area和perimeter方法偽裝成屬性 2 from math import pi 3 class Circle: 4 def __init__(self,r): 5 self.r = r 6 @property 7 def perimeter(self): 8 return self.r*pi*2 9 @property 10 def area(self): 11 return pi*self.r**2 12 c1 = Circle(5) 13 print(c1.area) 14 print(c1.perimeter)
2、在類的外面訪問類的私有屬性
1 class A: 2 def __init__(self,name): 3 self.__name = name 4 5 @property 6 def name(self): 7 return self.__name 8 a = A(‘alex‘) 9 print(a.name)
3、在外面可以訪問私有屬性，又可以修改私有屬性
1 class A: 2 def __init__(self,name): 3 self.__name = name 4 5 @property 6 def name(self): 7 return self.__name 8 @name.setter 9 def name(self,new_name): ##可以做出限制 10 if type(new_name) is str: 11 self.__name = new_name 12 a = A(‘alex‘) 13 # print(a.name) 14 a.name = ‘alex_sb‘ 15 print(a.name)
二、classmethod綁定給類的方法
classmehtod是給類用的，即綁定到類，類在使用時會將類本身當做參數傳給類方法的第一個參數（即便是對象來調用也會將類當作第一個參數傳入），python為我們內置了函數classmethod來把類中的函數定義成類方法
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 # __author__ = "wzs" 4 #2017/11/6 5 6 HOST=‘127.0.0.1‘ 7 PORT=3306 8 DB_PATH=r‘G:\data\PyCharm_Project\Python\s19\day8\面向對象編程\db‘settings.py
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 # __author__ = "wzs" 4 #2017/11/6 5 6 import settings 7 class MySQL: 8 def __init__(self,host,port): 9 self.host=host 10 self.port=port 11 12 @classmethod 13 def from_conf(cls): 14 print(cls) 15 return cls(settings.HOST,settings.PORT) 16 17 print(MySQL.from_conf) #<bound method MySQL.from_conf of <class ‘__main__.MySQL‘>> 18 conn=MySQL.from_conf() 19 20 conn.from_conf() #對象也可以調用，但是默認傳的第一個參數仍然是類db.py
三、staticmethod
在類內部用staticmethod裝飾的函數即非綁定方法，就是普通函數
staticmethod不與類或對象綁定，誰都可以調用，沒有自動傳值效果
1 import hashlib 2 import time 3 class MySQL: 4 def __init__(self,host,port): 5 self.id=self.create_id() 6 self.host=host 7 self.port=port 8 @staticmethod 9 def create_id(): #就是一個普通工具 10 m=hashlib.md5(str(time.time()).encode(‘utf-8‘)) 11 return m.hexdigest() 12 13 14 print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看結果為普通函數 15 conn=MySQL(‘127.0.0.1‘,3306) 16 print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看結果為普通函數staticmethod
四、classmethod與staticmethod的區別
1 class A: 2 country = ‘China‘ 3 #必須先是實例化才能調用對象的方法且可以使用示例的屬性 4 def func(self): 5 self.name = ‘alex‘ 6 7 @classmethod #類方法：不需要傳具體的對象，但是可以使用類的靜態屬性 8 def c_method(cls): 9 print(‘in class method‘) 10 print(cls.country) 11 12 @staticmethod ##靜態方法：不需要傳任何參數，但是也不能使用任何屬性 13 def s_method(): 14 print(‘in the static method‘) 15 16 A.c_method() 17 A.s_method()簡單
1 import settings 2 class MySQL: 3 def __init__(self,host,port): 4 self.host=host 5 self.port=port 6 7 @staticmethod 8 def from_conf(): 9 return MySQL(settings.HOST,settings.PORT) 10 11 # @classmethod #哪個類來調用,就將哪個類當做第一個參數傳入 12 # def from_conf(cls): 13 # return cls(settings.HOST,settings.PORT) 14 15 def __str__(self): 16 return ‘就不告訴你‘ 17 18 class Mariadb(MySQL): 19 def __str__(self): 20 return ‘<%s:%s>‘ %(self.host,self.port) 21 22 23 m=Mariadb.from_conf() 24 print(m) #我們的意圖是想觸發Mariadb.__str__,但是結果觸發了MySQL.__str__的執行，打印就不告訴你：深入：mariadb是mysql
五、練習
1、定義MySQL類
1.對象有id、host、port三個屬性
2.定義工具create_id，在實例化時為每個對象隨機生成id，保證id唯一
3.提供兩種實例化方式，方式一：用戶傳入host和port 方式二：從配置文件中讀取host和port進行實例化
4.為對象定制方法，save和get_obj_by_id，save能自動將對象序列化到文件中，文件路徑為配置文件中DB_PATH,文件名為id號，保存之前驗證對象是否已經存在，若存在則拋出異常，;get_obj_by_id方法用來從文件中反序列化出對象
原文鏈接：http://www.cnblogs.com/dkblog/archive/2011/10/10/2205200.html Python官方Doc：《20.15. uuid — UUID objects according to RFC 4122》 UUID的算法介紹：《A Universally Unique IDentifier (UUID) URN Namespace》 概述： UUID是128位的全局唯一標識符，通常由32字節的字符串表示。 它可以保證時間和空間的唯一性，也稱為GUID，全稱為： UUID —— Universally Unique IDentifier Python 中叫 UUID GUID —— Globally Unique IDentifier C# 中叫 GUID 它通過MAC地址、時間戳、命名空間、隨機數、偽隨機數來保證生成ID的唯一性。 UUID主要有五個算法，也就是五種方法來實現： 1、uuid1()——基於時間戳 由MAC地址、當前時間戳、隨機數生成。可以保證全球範圍內的唯一性， 但MAC的使用同時帶來安全性問題，局域網中可以使用IP來代替MAC。 2、uuid2()——基於分布式計算環境DCE（Python中沒有這個函數） 算法與uuid1相同，不同的是把時間戳的前4位置換為POSIX的UID。 實際中很少用到該方法。 3、uuid3()——基於名字的MD5散列值 通過計算名字和命名空間的MD5散列值得到，保證了同一命名空間中不同名字的唯一性， 和不同命名空間的唯一性，但同一命名空間的同一名字生成相同的uuid。 4、uuid4()——基於隨機數 由偽隨機數得到，有一定的重復概率，該概率可以計算出來。 5、uuid5()——基於名字的SHA-1散列值 算法與uuid3相同，不同的是使用 Secure Hash Algorithm 1 算法 使用方面： 首先，Python中沒有基於DCE的，所以uuid2可以忽略； 其次，uuid4存在概率性重復，由無映射性，最好不用； 再次，若在Global的分布式計算環境下，最好用uuid1； 最後，若有名字的唯一性要求，最好用uuid3或uuid5。 編碼方法： # -*- coding: utf-8 -*- import uuid name = "test_name" namespace = "test_namespace" print uuid.uuid1() # 帶參的方法參見Python Doc print uuid.uuid3(namespace, name) print uuid.uuid4() print uuid.uuid5(namespace, name)創建唯一id之UUID
1 #settings.py內容 2 ‘‘‘ 3 HOST=‘127.0.0.1‘ 4 PORT=3306 5 DB_PATH=r‘E:\CMS\aaa\db‘ 6 ‘‘‘ 7 import settings 8 import uuid 9 import pickle 10 import os 11 class MySQL: 12 def __init__(self,host,port): 13 self.id=self.create_id() 14 self.host=host 15 self.port=port 16 17 def save(self): 18 if not self.is_exists: 19 raise PermissionError(‘對象已存在‘) 20 file_path=r‘%s%s%s‘ %(settings.DB_PATH,os.sep,self.id) 21 pickle.dump(self,open(file_path,‘wb‘)) 22 23 @property 24 def is_exists(self): 25 tag=True 26 files=os.listdir(settings.DB_PATH) 27 for file in files: 28 file_abspath=r‘%s%s%s‘ %(settings.DB_PATH,os.sep,file) 29 obj=pickle.load(open(file_abspath,‘rb‘)) 30 if self.host == obj.host and self.port == obj.port: 31 tag=False 32 break 33 return tag 34 @staticmethod 35 def get_obj_by_id(id): 36 file_abspath = r‘%s%s%s‘ % (settings.DB_PATH, os.sep, id) 37 return pickle.load(open(file_abspath,‘rb‘)) 38 39 @staticmethod 40 def create_id(): 41 return str(uuid.uuid1()) 42 43 @classmethod 44 def from_conf(cls): 45 print(cls) 46 return cls(settings.HOST,settings.PORT) 47 48 # print(MySQL.from_conf) #<bound method MySQL.from_conf of <class ‘__main__.MySQL‘>> 49 conn=MySQL.from_conf() 50 conn.save() 51 52 conn1=MySQL(‘127.0.0.1‘,3306) 53 conn1.save() #拋出異常PermissionError: 對象已存在 54 55 56 obj=MySQL.get_obj_by_id(‘7e6c5ec0-7e9f-11e7-9acc-408d5c2f84ca‘) 57 print(obj.host)settings.py
2、其他練習
1 class Date: 2 def __init__(self,year,month,day): 3 self.year=year 4 self.month=month 5 self.day=day 6 @staticmethod 7 def now(): #用Date.now()的形式去產生實例,該實例用的是當前時間 8 t=time.localtime() #獲取結構化的時間格式 9 return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建實例並且返回 10 @staticmethod 11 def tomorrow():#用Date.tomorrow()的形式去產生實例,該實例用的是明天的時間 12 t=time.localtime(time.time()+86400) 13 return Date(t.tm_year,t.tm_mon,t.tm_mday) 14 15 a=Date(‘1987‘,11,27) #自己定義時間 16 b=Date.now() #采用當前時間 17 c=Date.tomorrow() #采用明天的時間 18 19 print(a.year,a.month,a.day) 20 print(b.year,b.month,b.day) 21 print(c.year,c.month,c.day) 22 23 24 #分割線============================== 25 import time 26 class Date: 27 def __init__(self,year,month,day): 28 self.year=year 29 self.month=month 30 self.day=day 31 @staticmethod 32 def now(): 33 t=time.localtime() 34 return Date(t.tm_year,t.tm_mon,t.tm_mday) 35 36 class EuroDate(Date): 37 def __str__(self): 38 return ‘year:%s month:%s day:%s‘ %(self.year,self.month,self.day) 39 40 e=EuroDate.now() 41 print(e) #我們的意圖是想觸發EuroDate.__str__,但是結果為 42 ‘‘‘ 43 輸出結果: 44 <__main__.Date object at 0x1013f9d68> 45 ‘‘‘ 46 因為e就是用Date類產生的,所以根本不會觸發EuroDate.__str__,解決方法就是用classmethod 47 48 import time 49 class Date: 50 def __init__(self,year,month,day): 51 self.year=year 52 self.month=month 53 self.day=day 54 # @staticmethod 55 # def now(): 56 # t=time.localtime() 57 # return Date(t.tm_year,t.tm_mon,t.tm_mday) 58 59 @classmethod #改成類方法 60 def now(cls): 61 t=time.localtime() 62 return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪個類來調用,即用哪個類cls來實例化 63 64 class EuroDate(Date): 65 def __str__(self): 66 return ‘year:%s month:%s day:%s‘ %(self.year,self.month,self.day) 67 68 e=EuroDate.now() 69 print(e) #我們的意圖是想觸發EuroDate.__str__,此時e就是由EuroDate產生的,所以會如我們所願 70 ‘‘‘ 71 輸出結果: 72 year:2017 month:3 day:3 73 ‘‘‘其他練習
四、其他
見鏈接 http://www.cnblogs.com/linhaifeng/articles/6204014.htm
面向對象進階