設計模式的定義:為了解決面向對象系統中重要和重復的設計封裝在一起的一種代碼實現框架,可以使得代碼更加易于擴展和調用

四個基本要素:模式名稱,問題,解決方案,效果

六大原則:

1.開閉原則:一個軟件實體,如類,模塊和函數應該對擴展開放，對修改封閉。既軟件實體應盡量在不修改原有代碼的情況下進行擴展。

2.里氏替換原則:所有引用父類的方法必須能透明的使用其子類的對象

3.依賴倒置原則:高層模塊不應該依賴底層模塊，二者都應該依賴其抽象,抽象不應該依賴于細節，細節應該依賴抽象，換而言之,要針對接口編程而不是針對實現編程

4.接口隔離原則:使用多個專門的接口,而不是使用單一的總接口,即客戶端不應該依賴那些并不需要的接口

5.迪米特法則:一個軟件實體應該盡可能的少與其他實體相互作用

6.單一直責原則:不要存在多個導致類變更的原因.即一個類只負責一項職責

零:接口

定義:一種特殊的類,聲明了若干方法,要求繼承該接口的類必須實現這種方法

作用:限制繼承接口的類的方法的名稱及調用方式,隱藏了類的內部實現

from abc import ABCMeta,abstractmethodclass Payment(metaclass=ABCMeta):@abstractmethod#定義抽象方法的關鍵字def pay(self,money):pass# @abstractmethod# def pay(self,money):# raise NotImplementedErrorclass AiliPay(Payment):#子類繼承接口,必須實現接口中定義的抽象方法,否則不能實例化對象def pay(self,money):print('使用支付寶支付%s元'%money)class ApplePay(Payment):def pay(self,money):print('使用蘋果支付支付%s元'%money)

一:單例模式

定義:保證一個類只有一個實例,并提供一個訪問它的全局訪問點

適用場景:當一個類只能有一個實例而客戶可以從一個眾所周知的訪問點訪問它時

優點:對唯一實例的受控訪問,相當于全局變量,但是又可以防止此變量被篡改

class Singleton(object):#如果該類已經有了一個實例則直接返回,否則創建一個全局唯一的實例def __new__(cls, *args, **kwargs):if not hasattr(cls,'_instance'):cls._instance = super(Singleton,cls).__new__(cls)return cls._instanceclass MyClass(Singleton):def __init__(self,name):if name:self.name = namea = MyClass('a') print(a) print(a.name)b = MyClass('b') print(b) print(b.name)print(a) print(a.name)

二:簡單工廠模式

定義:不直接向客戶暴露對象創建的實現細節,而是通過一個工廠類來負責創建產品類的實例

角色:工廠角色,抽象產品角色,具體產品角色

優點:隱藏了對象創建代碼的細節,客戶端不需要修改代碼

缺點:違反了單一職責原則,將創建邏輯集中到一個工廠里面,當要添加新產品時,違背了開閉原則

''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：579817333 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' from abc import ABCMeta,abstractmethodclass Payment(metaclass=ABCMeta):#抽象產品角色@abstractmethoddef pay(self,money):passclass AiliPay(Payment):#具體產品角色def __init__(self,enable_yuebao=False):self.enable_yuebao = enable_yuebaodef pay(self,money):if self.enable_yuebao:print('使用余額寶支付%s元'%money)else:print('使用支付寶支付%s元'%money)class ApplePay(Payment):# 具體產品角色def pay(self,money):print('使用蘋果支付支付%s元'%money)class PaymentFactory:#工廠角色def create_payment(self,method):if method == 'alipay':return AiliPay()elif method == 'yuebao':return AiliPay(True)elif method == 'applepay':return ApplePay()else:return NameErrorp = PaymentFactory() f = p.create_payment('yuebao') f.pay(100)

三:工廠方法模式

定義:定義一個創建對象的接口(工廠接口),讓子類決定實例化哪個接口

角色:抽象工廠角色,具體工廠角色,抽象產品角色,具體產品角色

適用場景:需要生產多種,大量復雜對象的時候,需要降低代碼耦合度的時候,當系統中的產品類經常需要擴展的時候

優點:每個具體的產品都對應一個具體工廠,不需要修改工廠類的代碼,工廠類可以不知道它所創建的具體的類,隱藏了對象創建的實現細節

缺點:每增加一個具體的產品類,就必須增加一個相應的工廠類

#!/usr/bin/env python # -*- coding: utf-8 -*- # __author__= 'luhj'from abc import ABCMeta,abstractmethodclass Payment(metaclass=ABCMeta):#抽象產品@abstractmethoddef pay(self,money):passclass AliPay(Payment):#具體產品def pay(self,money):print('使用支付寶支付%s元'%money)class ApplePay(Payment):def pay(self,money):print('使用蘋果支付支付%s元'%money)class PaymentFactory(metaclass=ABCMeta):#抽象工廠@abstractmethoddef create_payment(self):passclass AliPayFactory(PaymentFactory):#具體工廠def create_payment(self):return AliPay()class ApplePayFactory(PaymentFactory):def create_payment(self):return ApplePay()af = AliPayFactory() ali = af.create_payment() ali.pay(100)#如果要新增支付方式 class WechatPay(Payment):def pay(self,money):print('使用微信支付%s元'%money)class WechatPayFactory(PaymentFactory):def create_payment(self):return WechatPay()w = WechatPayFactory() wc = w.create_payment() wc.pay(200)

四:抽象工廠模式

定義:定義一個工廠類接口,讓工廠子類來創建一系列相關或相互依賴的對象

角色:抽象工廠角色,具體工廠角色,抽象產品角色,具體產品角色,客戶端

適用場景:系統要獨立于產品的創建和組合時,強調一系列相關產品的對象設計以便進行聯合調試時,提供一個產品類庫,想隱藏產品的具體實現時

優點:將客戶端與類的具體實現相分離,每個工廠創建了一個完整的產品系列,易于交換產品.有利于產品的一致性

缺點:難以支持新種類的產品

''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：579817333 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' from abc import abstractmethod, ABCMeta# ------抽象產品------ class PhoneShell(metaclass=ABCMeta):@abstractmethoddef show_shell(self):passclass CPU(metaclass=ABCMeta):@abstractmethoddef show_cpu(self):passclass OS(metaclass=ABCMeta):@abstractmethoddef show_os(self):pass# ------抽象工廠------ class PhoneFactory(metaclass=ABCMeta):@abstractmethoddef make_shell(self):pass@abstractmethoddef make_cpu(self):pass@abstractmethoddef make_os(self):pass# ------具體產品------ class SmallShell(PhoneShell):def show_shell(self):print('小手機殼')class BigShell(PhoneShell):def show_shell(self):print('大手機殼')class AppleShell(PhoneShell):def show_shell(self):print('蘋果機殼')class SnapDragonCPU(CPU):def show_cpu(self):print('驍龍CPU')class MediaTekCPU(CPU):def show_cpu(self):print('聯發科CPU')class AppleCPU(CPU):def show_cpu(self):print('蘋果CPU')class Andriod(OS):def show_os(self):print('安卓系統')class IOS(OS):def show_os(self):print('iOS系統')# ------具體工廠------ class MiFactory(PhoneFactory):def make_shell(self):return BigShell()def make_os(self):return Andriod()def make_cpu(self):return SnapDragonCPU()class HuaweiFactory(PhoneFactory):def make_shell(self):return SmallShell()def make_os(self):return Andriod()def make_cpu(self):return MediaTekCPU()class AppleFactory(PhoneFactory):def make_shell(self):return AppleShell()def make_os(self):return IOS()def make_cpu(self):return AppleCPU()# ------客戶端------ class Phone:def __init__(self,shell,os,cpu):self.shell=shellself.os=osself.cpu=cpudef show_info(self):print('手機信息')self.cpu.show_cpu()self.shell.show_shell()self.os.show_os()def make_phone(factory):cpu = factory.make_cpu()os = factory.make_os()shell = factory.make_shell()return Phone(shell,os,cpu)p1 = make_phone(AppleFactory()) p1.show_info()

五:建造者模式

定義:將一個復雜對象的構建與它的表示分離,使得同樣的構建過程可以創建不同的表示

角色:抽象建造者,具體建造者,指揮者,產品

適用場景:當創建復雜對象的算法應該獨立于對象的組成部分以及它的裝配方式,當構造過程允許被構造的對象有不同的表示

優點:隱藏了一個產品的內部結構和裝配過程,將構造代碼與表示代碼分開,可以對構造過程進行更精確的控制

from abc import abstractmethod, ABCMeta#------產品------ class Player:def __init__(self,face=None, body=None, arm=None, leg=None):self.face =faceself.body=bodyself.arm=armself.leg=legdef __str__(self):return '%s,%s,%s,%s'%(self.face,self.body,self.arm,self.leg)#------建造者------ class PlayerBuilder(metaclass=ABCMeta):@abstractmethoddef build_face(self):pass@abstractmethoddef build_body(self):pass@abstractmethoddef build_arm(self):pass@abstractmethoddef build_leg(self):pass@abstractmethoddef get_player(self):pass#------具體建造者------ class BeautifulWoman(PlayerBuilder):def __init__(self):self.player=Player()def build_face(self):self.player.face = '白臉蛋'def build_body(self):self.player.body = '好身材'def build_arm(self):self.player.arm = '細胳膊'def build_leg(self):self.player.leg = '大長腿'def get_player(self):return self.player#------指揮者------ class PlayerDirecter:def build_player(self,builder):builder.build_face()builder.build_body()builder.build_arm()builder.build_leg()return builder.get_player()director = PlayerDirecter() builder = BeautifulWoman() p = director.build_player(builder) print(p)

六:適配器模式

定義:將一個接口轉換為客戶希望的另一個接口,該模式使得原本由于接口不兼容而不能一起工作的那些類可以一起工作

角色:目標接口,待適配的類,適配器

適用場景:想使一個已經存在的類,但其接口不符合你的要求.想對一些已經存在的子類.不可能每一個都是用子類來進行適配,對象適配器可以適配其父類接口

''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：579817333 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' from abc import abstractmethod, ABCMetaclass Payment(metaclass=ABCMeta):@abstractmethoddef pay(self, money):raise NotImplementedErrorclass Alipay(Payment):def pay(self, money):print("支付寶支付%s元"%money)class ApplePay(Payment):def pay(self, money):print("蘋果支付%s元"%money)#------待適配的類----- class WeChatPay:def fuqian(self,money):print('微信支付%s元'%money)#------類適配器------ class RealWeChatPay(Payment,WeChatPay):def pay(self, money):return self.fuqian(money)#-----對象適配器----- class PayAdapter(Payment):def __init__(self,payment):self.payment=paymentdef pay(self, money):return self.payment.fuqian(money)#RealWeChatPay().pay(100)p=PayAdapter(WeChatPay()) p.pay(200)

七:組合模式

定義:將對象組合成樹形結構以表示’部分-整體’的層次結構.組合模式使得用戶對單個對象和組合對象的使用具有一致性

角色:抽象組件,葉子組件,復合組件,客戶端

適用場景:表示對象的’部分-整體’層次結構,希望用戶忽略組合對象與單個對象的不同,用戶統一使用組合結構中的所有對象

優點:定義了包含基本對象和組合對象的類層次結構,簡化客戶端代碼,即客戶端可以一致的使用組合對象和單個對象,更容易新增新類型的組件

缺點:很難限制組合中的組件

from abc import abstractmethod, ABCMeta#-------抽象組件-------- class Graph(metaclass=ABCMeta):@abstractmethoddef draw(self):pass@abstractmethoddef add(self,graph):passdef get_children(self):pass#---------葉子組件-------- class Point(Graph):def __init__(self,x,y):self.x = xself.y = ydef draw(self):print(self)def add(self,graph):raise TypeErrordef get_children(self):raise TypeErrordef __str__(self):return '點(%s,%s)'%(self.x,self.y)class Line(Graph):def __init__(self,p1,p2):self.p1 = p1self.p2 = p2def draw(self):print(self)def add(self,graph):raise TypeErrordef get_children(self):raise TypeErrordef __str__(self):return '線段(%s,%s)'%(self.p1,self.p2)#--------復合組件--------- class Picture(Graph):def __init__(self):self.children = []def add(self,graph):self.children.append(graph)def get_children(self):return self.childrendef draw(self):print('-----復合圖形-----')for g in self.children:g.draw()print('結束')#---------客戶端--------- pic1 = Picture() point = Point(2,3) pic1.add(point) pic1.add(Line(Point(1,2),Point(4,5))) pic1.add(Line(Point(0,1),Point(2,1)))pic2 = Picture() pic2.add(Point(-2,-1)) pic2.add(Line(Point(0,0),Point(1,1)))pic = Picture() pic.add(pic1) pic.add(pic2)pic.draw()

八:代理模式

定義:為其他對象提供一種代理以控制對特定對象的訪問

角色:抽象實體,實體,代理

適用場景:遠程代理(為遠程的對象提供代理),虛代理(根據需要創建很大的對象,即懶加載),保護代理(控制對原始對象的訪問,用于具有不同訪問權限的對象)

優點:遠程代理(可以隱藏對象位于遠程地址空間的事實),虛代理(可對大對象的加載進行優化),保護代理(允許在訪問一個對象時有一些附加的處理邏輯,例如權限控制)

''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：579817333 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' from abc import ABCMeta, abstractmethod#抽象實體 class Subject(metaclass=ABCMeta):@abstractmethoddef get_content(self):pass#實體 class RealSubject(Subject):def __init__(self,filename):print('讀取文件%s內容'%filename)f = open(filename)self.content = f.read()f.close()def get_content(self):return self.content#遠程代理 class ProxyA(Subject):def __init__(self,filename):self.subj =RealSubject(filename)def get_content(self):return self.subj.get_content()#虛代理 class ProxyB(Subject):def __init__(self,filename):self.filename = filenameself.subj = Nonedef get_content(self):if not self.subj:self.subj = RealSubject(self.filename)return self.subj.get_content()#保護代理 class ProxyC(Subject):def __init__(self,filename):self.subj = RealSubject(filename)def get_content(self):return '???'#客戶端 filename = 'abc.txt' username = input('>>') if username!='alex':p=ProxyC(filename) else:p=ProxyB(filename)print(p.get_content())

九:觀察者模式

定義:定義對象間的一種一對多的依賴關系,當一個對象的狀態發生改變時,所有依賴它的對象都會得到通知并被自動更新.觀察者模式又稱為’發布訂閱’模式

角色:抽象主題,具體主題(發布者),抽象觀察者,具體觀察者(訂閱者)

適用場景:當一個抽象模型有兩個方面,其中一個方面依賴于另一個方面.將兩者封裝在獨立的對象中以使它們各自獨立的改變和復用

• 當一個對象的改變需要同時改變其他對象,而且不知道具體有多少對象以待改變

• 當一個對象必須通知其他對象,而又不知道其他對象是誰,即這些對象之間是解耦的

優點:目標和觀察者之間的耦合最小,支持廣播通信

缺點:多個觀察者之間互不知道對方的存在,因此一個觀察者對主題的修改可能造成錯誤的更新

from abc import ABCMeta, abstractmethod#抽象主題 class Oberserver(metaclass=ABCMeta):@abstractmethoddef update(self):pass#具體主題 class Notice:def __init__(self):self.observers = []def attach(self,obs):self.observers.append(obs)def detach(self,obs):self.observers.remove(obs)def notify(self):for obj in self.observers:obj.update(self)#抽象觀察者 class ManagerNotice(Notice):def __init__(self,company_info=None):super().__init__()self.__company_info = company_info@propertydef company_info(self):return self.__company_info@company_info.setterdef company_info(self,info):self.__company_info = infoself.notify()#具體觀察者 class Manager(Oberserver):def __init__(self):self.company_info = Nonedef update(self,noti):self.company_info = noti.company_info#消息訂閱-發送 notice = ManagerNotice()alex=Manager() tony=Manager()notice.attach(alex) notice.attach(tony) notice.company_info="公司運行良好" print(alex.company_info) print(tony.company_info)notice.company_info="公司將要上市" print(alex.company_info) print(tony.company_info)notice.detach(tony) notice.company_info="公司要破產了，趕快跑路" print(alex.company_info) print(tony.company_info)

十:策略模式

定義:定義一系列的算法把它們一個個封裝起來,并且使它們可相互替換.該模式使得算法可獨立于使用它的客戶而變化

角色:抽象策略,具體策略,上下文

適用場景:許多相關的類僅僅是行為有異,需使用一個算法的不同變體,算法使用了客戶端無需知道的數據,一個類中的多個行為以多個條件語句存在可以將其封裝在不同的策略類中

優點:定義了一系列可重用的算法和行為,消除了一些條件語句,可提供相同行為的不同實現

缺點:客戶必須了解不同的策略,策略與上下文之間的通信開銷,增加了對象的數目

''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：579817333 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' from abc import ABCMeta, abstractmethod import random#抽象策略 class Sort(metaclass=ABCMeta):@abstractmethoddef sort(self,data):pass#具體策略 class QuickSort(Sort):def quick_sort(self,data,left,right):if left<right:mid = self.partation(data,left,right)self.quick_sort(data,left,mid-1)self.quick_sort(data,mid+1,right)def partation(self,data,left,right):tmp = data[left]while left < right:while left<right and data[right]>=tmp:right -= 1data[left] = data[right]while left<right and data[left]<=tmp:left += 1data[right] = data[left]data[left] = tmpreturn leftdef sort(self,data):print("快速排序")return self.quick_sort(data,0,len(data)-1)class MergeSort(Sort):def merge(self,data,low,mid,high):i = lowj = mid+1ltmp = []while i <= mid and j <= high:if data[i] <= data[j]:ltmp.append(data[i])i+=1else:ltmp.append(data[j])j+=1while i <= mid:ltmp.append(data[i])i+=1while j <= high:ltmp.append(data[j])j+=1data[low:high+1]=ltmpdef merge_sort(self,data,low,high):if low<high:mid = (low+high)//2self.merge_sort(data,low,mid)self.merge_sort(data,mid+1,high)self.merge(data,low,mid,high)def sort(self,data):print("歸并排序")return self.merge_sort(data,0,len(data)-1)#上下文 class Context:def __init__(self,data,strategy=None):self.data=dataself.strategy=strategydef set_strategy(self,strategy):self.strategy=strategydef do_strategy(self):if self.strategy:self.strategy.sort(self.data)else:raise TypeErrorli = list(range(100000)) random.shuffle(li) context = Context(li,MergeSort()) context.do_strategy()random.shuffle(context.data) context.set_strategy(QuickSort()) context.do_strategy()

十一:責任鏈模式

定義:使多個對象有機會處理請求,從而避免請求的發布者和接收者之間的耦合關系,將這些對象連成一條鏈,并沿著這條鏈傳遞該請求,直到有一個對象能處理它為止

角色:抽象處理者,具體處理者,客戶端

適用場景:有多個對象可以處理一個請求,哪個對象處理由運行時決定

優點:降低耦合度,一個對象無需知道是其他哪一個對象處理其請求

缺點:請求不保證被接收,鏈的末端沒有處理或鏈配置錯誤

from abc import ABCMeta, abstractmethodclass Handler(metaclass=ABCMeta):@abstractmethoddef handel_leave(self,day):passclass GeneralManagerHandler(Handler):def handel_leave(self,day):if day < 10:print('總經理批準請假%s天'%day)else:print('不能請假')class DepartmentManagerHandler(Handler):def __init__(self):self.successor = GeneralManagerHandler()def handel_leave(self,day):if day < 7:print('部門經理批準請假%s天' % day)else:print('部門經理無權批假')self.successor.handel_leave(day)class ProjectDirectorHandler(Handler):def __init__(self):self.successor = DepartmentManagerHandler()def handel_leave(self,day):if day < 3:print('項目經理批準請假%s天' % day)else:print('項目經理無權批假')self.successor.handel_leave(day)day = 6 h = ProjectDirectorHandler() h.handel_leave(day)

---

''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：579817333 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' from abc import ABCMeta, abstractmethod #--模仿js事件處理 class Handler(metaclass=ABCMeta):@abstractmethoddef add_event(self,func):pass@abstractmethoddef handler(self):passclass BodyHandler(Handler):def __init__(self):self.func = Nonedef add_event(self,func):self.func = funcdef handler(self):if self.func:return self.func()else:print('已經是最后一級,無法處理')class ElementHandler(Handler):def __init__(self,successor):self.func = Noneself.successor = successordef add_event(self,func):self.func = funcdef handler(self):if self.func:return self.func()else:return self.successor.handler()#客戶端 body = {'type': 'body', 'name': 'body', 'children': [], 'father': None}div = {'type': 'div', 'name': 'div', 'children': [], 'father': body}a = {'type': 'a', 'name': 'a', 'children': [], 'father': div}body['children'] = div div['children'] = abody['event_handler'] = BodyHandler() div['event_handler'] = ElementHandler(div['father']['event_handler']) a['event_handler'] = ElementHandler(a['father']['event_handler'])def attach_event(element,func):element['event_handler'].add_event(func)#測試 def func_div():print("這是給div的函數")def func_a():print("這是給a的函數")def func_body():print("這是給body的函數")attach_event(div,func_div) #attach_event(a,func_a) attach_event(body,func_body)a['event_handler'].handler()

十二:迭代器模式

定義:提供一種方法可順序訪問一個聚合對象中的各個元素,而又不需要暴露該對象的內部指示

適用場景:實現方法__iter__,next

class LinkedList:class Node:def __init__(self,item=None):self.item=itemself.next=Noneclass LinkedListIterator:def __init__(self,node):self.node = node#實現next方法,返回下一個元素def __next__(self):if self.node:cur_node = self.nodeself.node = cur_node.nextreturn cur_node.itemdef __iter__(self):return selfdef __init__(self,iterable=None):self.head = LinkedList.Node(0)self.tail = self.headself.extend(iterable)#鏈表尾部追加元素def append(self,obj):s = LinkedList.Node(obj)self.tail.next = sself.tail = s#鏈表自動增加長度def extend(self,iterable):for obj in iterable:self.append(obj)self.head.item += len(iterable)def __iter__(self):return self.LinkedListIterator(self.head.next)def __len__(self):return self.head.itemdef __str__(self):return '<<'+', '.join(map(str,self)) + '>>'li = [i for i in range(100)] lk = LinkedList(li) print(lk)

十三:模板方法模式

定義:定義一個操作中算法的骨架,將一些步驟延遲到子類中,模板方法使得子類可以不改變一個算法的結構即可重定義該算法某些特定的步驟

角色:抽象類(定義抽象的原子操作,實現一個模板方法作為算法的骨架),具體類(實現原子操作)

適用場景:一次性實現一個算法不變的部分,各個子類的公共行為,應該被提取出來集中到公共的父類中以避免代碼重復,控制子類擴展

''' 遇到問題沒人解答？小編創建了一個Python學習交流QQ群：579817333 尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！ ''' from abc import ABCMeta, abstractmethod#----抽象類----- class IOHandler(metaclass=ABCMeta):@abstractmethoddef open(self,name):pass@abstractmethoddef deal(self,change):pass@abstractmethoddef close(self):pass#在父類中定義了子類的行為def process(self,name,change):self.open(name)self.deal(change)self.close()#子類中只需要實現部分算法,而不需要實現所有的邏輯 #-----具體類-------- class FileHandler(IOHandler):def open(self,name):self.file = open(name,'w')def deal(self,change):self.file.write(change)def close(self):self.file.close()f = FileHandler() f.process('abc.txt','hello')

總結

以上是生活随笔為你收集整理的python设计模式整理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。