Python设计模式(一)

ops/2024/9/25 19:18:17/

一、简单工厂模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-26 20:24
# @Author  : Maple
# @File    : 01-简单工厂模式.pyfrom abc import ABC,abstractmethod# 1. 简单入门
class Dog:def speak(self):return "I am Dog"class Cat:def speak(self):return "I am cat"class MyFactory1:@staticmethoddef getAnimal(name):if name == "dog":return Dog()elif name == "cat":return Cat()else:raise ValueError("请输入正确的类型")# 2. 进阶1:增加一个注册类的功能
class MyFactory2:cls_dict = {}@classmethoddef register_cls(cls,name,clss):cls.cls_dict[name] = clss@classmethoddef get_obj(cls,name):kls = cls.cls_dict.get(name)if kls is None:raise ValueError(f"Plugin with name {name} not registered.")else:return kls()class Person:passclass Student:pass# 3. 进阶2:利用抽象类
# 抽象工厂类
class UIFactory:def create_button(self):raise NotImplementedErrordef create_textbox(self):raise NotImplementedError# 具体工厂类:Windows
class WindowsUIFactory(UIFactory):def create_button(self):return WindowsButton()def create_textbox(self):return WindowsTextbox()# 具体工厂类:MacOS
class MacOSUIFactory(UIFactory):def create_button(self):return MacOSButton()def create_textbox(self):return MacOSTextbox()# 抽象产品类:Button
class Button:def render(self):raise NotImplementedError# 抽象产品类:Textbox
class Textbox:def render(self):raise NotImplementedError# 具体产品类:Windows Button
class WindowsButton(Button):def render(self):return "Rendering a Windows style button"# 具体产品类:Windows Textbox
class WindowsTextbox(Textbox):def render(self):return "Rendering a Windows style textbox"# 具体产品类:MacOS Button
class MacOSButton(Button):def render(self):return "Rendering a MacOS style button"# 具体产品类:MacOS Textbox
class MacOSTextbox(Textbox):def render(self):return "Rendering a MacOS style textbox"# Usage
def client_code(factory: UIFactory):button = factory.create_button()textbox = factory.create_textbox()print(button.render())print(textbox.render())# 4. 进阶3:要创建的类带初始化参数,并且不同的子类参数不一样
class Character:def __init__(self, name, level):self.name = nameself.level = leveldef __str__(self):return f"{self.name}, Level {self.level}"class Warrior(Character):def __init__(self, name, level, weapon):super().__init__(name, level)self.weapon = weapondef __str__(self):return f"{super().__str__()}, armed with {self.weapon}"class Mage(Character):def __init__(self, name, level, element):super().__init__(name, level)self.element = elementdef __str__(self):return f"{super().__str__()}, wielding {self.element} magic"class CharacterFactory:@staticmethoddef create_character(type, name, level, **kwargs):if type == "warrior":return Warrior(name, level, kwargs.get('weapon', 'sword'))elif type == "mage":return Mage(name, level, kwargs.get('element', 'fire'))else:raise ValueError("Unknown character type")if __name__ == '__main__':print('*******1. 简单入门测试*****************')# 1. 简单入门测试dog = MyFactory1.getAnimal("dog")print(dog.speak())cat = MyFactory1.getAnimal("cat")print(cat.speak())print('*******2. 进阶测试-1*******************')# 2. 进阶测试-1MyFactory2.register_cls('Person',Person)MyFactory2.register_cls('Student',Student)p = MyFactory2.get_obj('Person')print(p)s = MyFactory2.get_obj('Student')print(s)# 3. 进阶测试-2print('*******3. 进阶测试-2*******************')# Depending on the OS environment, we might choose a different factorycurrent_os = 'Windows'  # This could be determined by some runtime checkif current_os == 'Windows':factory = WindowsUIFactory()elif current_os == 'MacOS':factory = MacOSUIFactory()"""Rendering a Windows style buttonRendering a Windows style textbox"""client_code(factory)# 4. 进阶测试-3print('*******4. 进阶测试-3*******************')warrior = CharacterFactory.create_character("warrior", "Aragorn", 5, weapon="long sword")mage = CharacterFactory.create_character("mage", "Gandalf", 10, element="lightning")print(warrior)  # Output: Aragorn, Level 5, armed with long swordprint(mage)  # Output: Gandalf, Level 10, wielding lightning magic

二、代理模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-26 22:03
# @Author  : Maple
# @File    : 02-代理模式.py"""
代理设计模式是一种结构型设计模式,允许对象在访问另一个对象时提供一个代替品或占位符。
这样可以控制对这个对象的访问,添加额外的功能或者管理生命周期等。在Python中实现代理模式通常涉及定义一个代理类,
该类包含对实际对象的引用,并通过重写方法以添加额外的行为。
""""""
例子1:简单的保护代理
在这个简单的例子中,代理类控制对另一个类的访问,只有当满足特定条件时才允许访问
"""class SensitiveInfo:def display_info(self):return "Sensitive Information: Only authorized users can see this."class ProtectedProxy:def __init__(self, user):self.user = userself._sensitive_info = SensitiveInfo()def display_info(self):if self.user == "authorized_user":return self._sensitive_info.display_info()else:return "Access Denied: You are not authorized to access this information.""""
例子2:虚拟代理
这个例子中,代理类延迟实际对象的创建,只有在真正需要时才创建,用于节省资源或延迟计算开销。
"""
class HeavyObject:def __init__(self):import timetime.sleep(2)  # Simulating a heavy creation taskprint("Heavy Object Created")def process(self):return "Processing complete."class VirtualProxy:def __init__(self):self._object = Nonedef process(self):# 当真正需要调用HeavyObject的process方法时,才会去创建HeavyObject实例对象# 虚拟代理是一种懒加载(Lazy Loading)机制if self._object is None:self._object = HeavyObject()return self._object.process()"""
例子3:智能引用代理
在更复杂的情况下,代理类可以添加对对象的智能引用管理,比如记录对象操作的次数或实现引用计数。
"""class DataStore:def load_data(self):return "Data loaded"def save_data(self, data):print(f"Data saved: {data}")class LoggingProxy:def __init__(self, target):self._target = targetself._load_count = 0self._save_count = 0def load_data(self):self._load_count += 1print(f"Data load operation count: {self._load_count}")return self._target.load_data()def save_data(self, data):self._save_count += 1print(f"Data save operation count: {self._save_count}")return self._target.save_data(data)"""
例子4:远程代理
远程代理用于控制对远程对象(比如网络上的服务)的访问。远程代理作为本地对象的代表
,通过网络与远程对象进行交互
"""import requestsclass RemoteServiceProxy:def __init__(self, service_url):self.service_url = service_urldef fetch_data(self):response = requests.get(self.service_url)if response.status_code == 200:return response.json()else:return None"""
例子 5:缓存代理
缓存代理用于管理对资源密集型对象的访问,它保存结果并在后续请求中重用,以提高效率和速度。
"""class DataHeavyService:def complex_query(self, parameters):# Simulate a complex queryreturn f"Results for {parameters}"class CacheProxy:def __init__(self, target):self.target = targetself.cache = {}def complex_query(self, parameters):if parameters not in self.cache:self.cache[parameters] = self.target.complex_query(parameters)return self.cache[parameters]if __name__ == '__main__':print("*************案例1:简单的保护代理************")proxy = ProtectedProxy("authorized_user")print(proxy.display_info())  # Output: Sensitive Information: Only authorized users can see this.proxy_unauthorized = ProtectedProxy("unauthorized_user")print(proxy_unauthorized.display_info())  # Output: Access Denied: You are not authorized to access this information.print("*************案例2:虚拟代理************")proxy = VirtualProxy()print(proxy.process())  # Output: Heavy Object Created\nProcessing complete.print("*************案例3:智能引用代理************")data_store = DataStore()proxy = LoggingProxy(data_store)print(proxy.load_data())  # Output: Data load operation count: 1\nData loadedproxy.save_data("Some data")  # Output: Data save operation count: 1\nData saved: Some dataprint("*************案例4:远程代理************")proxy = RemoteServiceProxy("https://www.baidu.com")data = proxy.fetch_data()print(data)  # Outputs the data fetched from the remote serviceprint("*************案例5:缓存代理************")service = DataHeavyService()proxy = CacheProxy(service)print(proxy.complex_query("param1"))  # Slow the first timeprint(proxy.complex_query("param1"))  # Fast, uses cache

三、单例模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-27 7:05
# @Author  : Maple
# @File    : 03-单例模式.py"""
单例模式是一种常见的设计模式,用于确保一个类有且只有一个实例
并提供一个全局访问点来访问这个实例。单例模式通常用于全局状态或共享资源的管理,如配置管理器、连接池等。""""""
案例1:基础单例模式
这是实现单例模式的最基础形式,使用了一个类变量来存储该类的唯一实例。
"""
class Singleton:_instance = None@staticmethoddef get_instance():if Singleton._instance is None:Singleton._instance = Singleton()return Singleton._instancedef __init__(self):if Singleton._instance is not None:raise Exception("This class is a singleton!")else:Singleton._instance = selfdef release_instance(self):Singleton._instance = None"""
案例2:线程安全的单例模式
在多线程环境中,确保单例实例的创建过程是线程安全的,这通常通过使用线程锁来实现。
"""from threading import Lock, Threadclass ThreadSafeSingleton:_instance = None_lock = Lock()  # 创建一个锁@staticmethoddef getInstance():if ThreadSafeSingleton._instance is None:with ThreadSafeSingleton._lock:if ThreadSafeSingleton._instance is None:ThreadSafeSingleton._instance = ThreadSafeSingleton()return ThreadSafeSingleton._instancedef __init__(self):if ThreadSafeSingleton._instance is not None:raise Exception("This class is a singleton!")else:ThreadSafeSingleton._instance = self"""
这个例子展示了如何使用Python装饰器来创建一个单例
这种方法将单例的逻辑封装在装饰器中,使得实现单例模式变得更加优雅。
"""
def singleton(cls):instance = Nonedef get_instance(*args, **kwargs):nonlocal instanceif instance is None:instance = cls(*args, **kwargs)return instancereturn get_instance@singleton
class DecoratedSingleton:def __init__(self, value):self.value = valueif __name__ == '__main__':print('*******案例1: 基础入门************')s0 = Singleton()s1 = Singleton.get_instance()s2 = Singleton.get_instance()print(s1 == s2)  # Output: Trueprint(s0 == s1)  # Output: True# 此时Singleton._instance已经不是None了,所以会raise Exception("This class is a singleton!")try:s3 = Singleton()except Exception as e:print("This class is a singleton!")# 销毁实例s0.release_instance()# 重新创建实例s4 = Singleton()print(s4) # <__main__.Singleton object at 0x000002216E63FE80>s5 = Singleton.get_instance()print(s4 == s5) # Trueprint('*******案例2: 线程安全的单例模式************')def test_singleton():singleton = ThreadSafeSingleton.getInstance()print(id(singleton))threads = [Thread(target=test_singleton) for _ in range(5)]"""25666379961602566637996160256663799616025666379961602566637996160"""for thread in threads:thread.start()for thread in threads:thread.join()print('*******案例3: 使用装饰器的单例模式************')s1 = DecoratedSingleton(10)# 第二次传入的初始化参数将被忽略s2 = DecoratedSingleton(20)print(s1.value)  # Output: 10print(s2.value)  # Output: 10【注意这里仍然是10】print(s1 is s2)  # Output: True

四、观察者模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-27 7:17
# @Author  : Maple
# @File    : 04-观察者模式.py"""观察者模式是一种设计模式,其中一个对象(称为“主题”)维护一组依赖于它的对象(称为“观察者”)
,并在主题的状态发生改变时自动通知它们。这种模式在实现事件处理系统、数据同步等功能时非常有用。
""""""
例子1:基本的观察者模式
这个例子中,我们创建了一个简单的新闻发布系统,新闻机构可以订阅新闻服务并在有新新闻时收到通知。 
"""class NewsPublisher:def __init__(self):self.subscribers = []self.latest_news = Nonedef add_subscriber(self, subscriber):self.subscribers.append(subscriber)def remove_subscriber(self, subscriber):self.subscribers.remove(subscriber)def notify_subscribers(self):for subscriber in self.subscribers:subscriber.update(self.latest_news)def add_news(self, news):self.latest_news = newsself.notify_subscribers()class NewsAgency:def update(self, news):print(f"News Agency received news: {news}")"""
例子2:使用回调函数的观察者模式
这个例子中,我们创建了一个简单的新闻发布系统,新闻机构可以订阅新闻服务并在有新新闻时收到通知。 
"""class EventManager:def __init__(self):self.listeners = {}def subscribe(self, event_type, listener):if event_type not in self.listeners:self.listeners[event_type] = []self.listeners[event_type].append(listener)def unsubscribe(self, event_type, listener):if event_type in self.listeners:self.listeners[event_type].remove(listener)def notify(self, event_type, data):if event_type in self.listeners:for listener in self.listeners[event_type]:listener(data) # listener是一个回调函数,当触发notify的时候,会调用该方法def handle_temperature_change(data):print(f"Temperature Alert: {data} degrees")def handle_pressure_change(data):print(f"Pressure Alert: {data} hPa")"""
案例3:复杂的多主题观察者模式
这个例子中,我们创建了一个可以处理多种事件和多个主题的系统,使得观察者可以订阅多个主题的多种事件。
"""class MultiSubjectManager:def __init__(self):self.subjects = {}def register_subject(self, subject_name):if subject_name not in self.subjects:self.subjects[subject_name] = {}def subscribe(self, subject_name, event_type, observer):""":param subject_name: 主题:param event_type: 事件:param observer: 观察着:return:"""if subject_name in self.subjects:if event_type not in self.subjects[subject_name]:self.subjects[subject_name][event_type] = []self.subjects[subject_name][event_type].append(observer)def unsubscribe(self, subject_name, event_type, observer):if subject_name in self.subjects and event_type in self.subjects[subject_name]:self.subjects[subject_name][event_type].remove(observer)def notify(self, subject_name, event_type, data):if subject_name in self.subjects and event_type in self.subjects[subject_name]:for observer in self.subjects[subject_name][event_type]:observer(data)def stock_event_handler(data):print(f"Stock Event: {data}")def weather_event_handler(data):print(f"Weather Update: {data}")if __name__ == '__main__':print('*******案例1:基本的观察者模式 **********')publisher = NewsPublisher()agency1 = NewsAgency()agency2 = NewsAgency()publisher.add_subscriber(agency1)publisher.add_subscriber(agency2)publisher.add_news("New economic policies released.")"""Output:News Agency received news: New economic policies released.News Agency received news: New economic policies released."""print('*******案例2:使用回调函数的观察者模式 **********')manager = EventManager()manager.subscribe("temperature", handle_temperature_change)manager.subscribe("pressure", handle_pressure_change)"""Temperature Alert: 26 degreesPressure Alert: 1013 hPa"""manager.notify("temperature", 26)manager.notify("pressure", 1013)print('*******案例3:复杂的多主题观察者模式 **********')manager = MultiSubjectManager()manager.register_subject("stock")manager.register_subject("weather")manager.subscribe("stock", "price_change", stock_event_handler)manager.subscribe("weather", "temperature_change", weather_event_handler)manager.notify("stock", "price_change", "AAPL stock price dropped 2%")manager.notify("weather", "temperature_change", "Temperature rose to 75°F")

五、建造者模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-27 14:28
# @Author  : Maple
# @File    : 05-建造者模式.py"""
例子 1:简单的餐饮包建造者
这个例子中,我们将创建一个简单的快餐餐包建造者,可以组合不同类型的主菜、小吃和饮料。"""
class Meal:def __init__(self):self.items = []def add_item(self, item):self.items.append(item)def get_cost(self):return sum(item.price for item in self.items)def show_items(self):for item in self.items:print(f"Item: {item.name}, Packing: {item.packing()}, Price: {item.price}")# 商品抽象类,包含三个属性: 名称, 打包方式, 价格
class Item:def name(self):raise NotImplementedErrordef packing(self):raise NotImplementedErrordef price(self):raise NotImplementedError# 商品打包方式的具体实现类-1
class Wrapper:def pack(self):return "Wrapper"# 商品打包方式的具体实现类-1
class Bottle:def pack(self):return "Bottle"# Burger和Drink代表两类产品
class Burger(Item):def packing(self):return Wrapper().pack()class Drink(Item):def packing(self):return Bottle().pack()# VegBurger是具体的产品--源头是继承item
# 因此会具备item的三个属性: 名称, 打包方式-才Burger中继承而来(Wrapper), 价格
class VegBurger(Burger):@propertydef price(self):return 25@propertydef name(self):return "Veg Burger"# 同上
class ChickenBurger(Burger):@propertydef price(self):return 50@propertydef name(self):return "Chicken Burger"# 同上
class Coke(Drink):@propertydef price(self):return 15@propertydef name(self):return "Coke"# 同上
class Pepsi(Drink):@propertydef price(self):return 10@propertydef name(self):return "Pepsi"class MealBuilder:def prepare_veg_meal(self):meal = Meal()meal.add_item(VegBurger())meal.add_item(Coke())return mealdef prepare_non_veg_meal(self):meal = Meal()meal.add_item(ChickenBurger())meal.add_item(Pepsi())return meal"""
案例2:复杂的汽车建造者
在这个例子中,我们将创建一个更复杂的汽车建造者,可以选择不同的汽车型号、引擎、内饰等。
"""class Car:def __init__(self):self.features = {}def add_feature(self, key, value):self.features[key] = valuedef show_details(self):for feature, value in self.features.items():print(f"{feature}: {value}")class CarBuilder:def __init__(self):self.car = Car()def add_model(self, model):self.car.add_feature("model", model)return selfdef add_engine(self, engine):self.car.add_feature("engine", engine)return selfdef add_interior(self, interior):self.car.add_feature("interior", interior)return selfdef build(self):return self.car"""
案例3:软件配置建造者
这个例子展示了如何使用建造者模式来构建软件配置文件。这种方法可以动态地创建和管理软件配置,尤其适用于配置项繁多且复杂的场景。使用场景
这种建造者模式的实现特别适合于需要动态创建复杂配置的应用,例如:
云基础设施配置
多环境部署(开发、测试、生产)
服务端应用配置
这个模式提高了代码的可读性和可维护性,尤其在配置参数众多且频繁变动的系统中,可以显著简化配置管理工作。
"""class Configuration:def __init__(self):self.parameters = {}def set_parameter(self, key, value):self.parameters[key] = valuedef show_configuration(self):for param, value in self.parameters.items():print(f"{param}: {value}")class ConfigurationBuilder:def __init__(self):self.configuration = Configuration()def set_database(self, db_name):self.configuration.set_parameter("database", db_name)return selfdef set_server_ip(self, ip):self.configuration.set_parameter("server_ip", ip)return selfdef set_max_connections(self, max_connections):self.configuration.set_parameter("max_connections", max_connections)return selfdef set_timeout(self, timeout):self.configuration.set_parameter("timeout", timeout)return selfdef build(self):return self.configurationif __name__ == '__main__':print('********案例1:餐饮包建造者 *****************')meal_builder = MealBuilder()veg_meal = meal_builder.prepare_veg_meal()veg_meal.show_items()"""Item: Veg Burger, Packing: Wrapper, Price: 25Item: Coke, Packing: Bottle, Price: 15"""print(f"Total Cost: {veg_meal.get_cost()}") # Total Cost: 40non_veg_meal = meal_builder.prepare_non_veg_meal()non_veg_meal.show_items()"""Item: Chicken Burger, Packing: Wrapper, Price: 50Item: Pepsi, Packing: Bottle, Price: 10"""print(f"Total Cost: {non_veg_meal.get_cost()}") # Total Cost: 60print('********案例2:复杂的汽车建造者 *****************')builder = CarBuilder()car = (builder.add_model("Sports Car").add_engine("V8 Engine").add_interior("Leather Interior").build())"""model: Sports Carengine: V8 Engineinterior: Leather Interior"""car.show_details()print('********案例3:软件配置建造者 *****************')config_builder = ConfigurationBuilder()configuration = (config_builder.set_database("MySQL").set_server_ip("192.168.1.100").set_max_connections(100).set_timeout(30).build())"""database: MySQLserver_ip: 192.168.1.100max_connections: 100timeout: 30"""configuration.show_configuration()

六、适配器模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-27 15:03
# @Author  : Maple
# @File    : 06-适配器模式.py"""
适配器模式是一种结构型设计模式,它允许接口不兼容的对象能够合作。
适配器模式通常用于确保由于接口不兼容而无法一起工作的类可以一起工作。
它通过在一个独立的类中封装现有的类,这个独立的类提供了符合目标接口的行为。
""""""
例子 1:电源适配器
展示如何使用适配器模式将一个类的接口转换为另一个接口
假设我们有一个只能接受特定电压的设备,而电源插座的输出电压与设备不匹配,我们需要一个适配器来调整电压
"""# 目标接口
class EuropeanSocketInterface:def voltage(self):pass# 适配者 --电源插座: 230V
class Socket(EuropeanSocketInterface):def voltage(self):return 230# 客户端 - 用户设备: 只能使用120V的插座
class Radio:def __init__(self, power_source):self.power_source = power_sourcedef plug_in(self):if self.power_source.voltage() == 120:print("Radio playing music!")else:print("Can't use this socket!")# 适配器
class SocketAdapter(EuropeanSocketInterface):def __init__(self, socket):self.socket = socket#  将电源插座的电压从230V调整到120Vdef voltage(self):return self.socket.voltage() // 1.916"""
案例2:遗留代码与现代系统的集成
假设我们有一个遗留系统的类,它返回用户数据的格式与新系统不兼容。新系统需要JSON格式,但遗留系统提供的是字典列表。
"""import json# 遗留系统
class OldSystem:def get_user_data(self):return [{"name": "John", "age": 30}, {"name": "Alice", "age": 25}]# 新系统的期望接口
class NewSystem:# 新系统期望处理的是JSON格式的数据def process_user_data(self, user_data):print(f"Processing data: {user_data}")# 适配器
class Adapter:def __init__(self, old_system):self.old_system = old_systemdef get_user_data(self):old_data = self.old_system.get_user_data()# 旧系统返回的数据转换成Json格式return json.dumps(old_data)"""
案例3:多个数据库适配
在这个更复杂的例子中,假设我们的应用需要与多种数据库交互,但每种数据库的接口不同。我们可以使用适配器模式统一这些接口。
"""
# 目标接口
class DatabaseInterface:def connect(self):passdef execute(self):pass# 适配者:MySQL数据库
class MySQLDatabase:def connect_mysql(self):print("Connecting to MySQL database.")def execute_mysql(self, query):print(f"Executing '{query}' on MySQL database.")# 适配者:SQLite数据库
class SQLiteDatabase:def connect_sqlite(self):print("Connecting to SQLite database.")def execute_sqlite(self, query):print(f"Executing '{query}' on SQLite database.")# 适配器
class MySQLAdapter(DatabaseInterface):def __init__(self, mysql_db):self.mysql_db = mysql_dbdef connect(self):self.mysql_db.connect_mysql()def execute(self, query):self.mysql_db.execute_mysql(query)class SQLiteAdapter(DatabaseInterface):def __init__(self, sqlite_db):self.sqlite_db = sqlite_dbdef connect(self):self.sqlite_db.connect_sqlite()def execute(self, query):self.sqlite_db.execute_sqlite(query)"""
案例4:多源输入适配器
在从多个数据源接收数据时,适配器可以帮助统一和标准化数据格式。
"""
class SensorA:def get_temperature(self):return 22.5  # Celsiusclass SensorB:def read_temp(self):return "Temperature is 295.65K"  # Kelvinclass SensorAdapter:def __init__(self, sensor):self.sensor = sensordef get_temperature_celsius(self):if isinstance(self.sensor, SensorA):return self.sensor.get_temperature()elif isinstance(self.sensor, SensorB):kelvin = float(self.sensor.read_temp().split()[-1][:-1])return kelvin - 273.15  # Convert Kelvin to Celsiusif __name__ == '__main__':print('******案例1:电源适配器 **************')socket = Socket()adapter = SocketAdapter(socket)radio = Radio(adapter)radio.plug_in()  # Output: Radio playing music!print('******案例2:遗留代码与现代系统的集成**************')old_system = OldSystem()adapter = Adapter(old_system)new_system = NewSystem()# adapter.get_user_data()返回的是Json格式的数据,满足新系统的期望new_system.process_user_data(adapter.get_user_data())  # 正确处理JSON数据print('******案例3:多个数据库适配**************')mysql_db = MySQLDatabase()sqlite_db = SQLiteDatabase()mysql_adapter = MySQLAdapter(mysql_db)sqlite_adapter = SQLiteAdapter(sqlite_db)mysql_adapter.connect()mysql_adapter.execute("SELECT * FROM users")sqlite_adapter.connect()sqlite_adapter.execute("SELECT * FROM settings")print('******案例4:多源输入适配器**************')sensor_a = SensorA()sensor_b = SensorB()adapter_a = SensorAdapter(sensor_a)adapter_b = SensorAdapter(sensor_b)print(f"Temperature from Sensor A: {adapter_a.get_temperature_celsius()}°C")print(f"Temperature from Sensor B: {adapter_b.get_temperature_celsius()}°C")

七、桥接模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-28 8:52
# @Author  : Maple
# @File    : 07-桥接模式.py"""
桥接模式是一种结构型设计模式,用于将抽象部分与其实现部分分离,使它们可以独立地变化
这种模式非常有用,特别是在系统中某些结构可能有多种实现方式时
通过桥接模式,可以组合使用不同的抽象和实现,而不必在抽象层面固定住一个特定的实现
""""""
案例1:简单的消息发送系统
在这个简单的例子中,我们将创建一个消息发送系统,其中消息发送的方式(如通过电子邮件、短信等)和消息的优先级处理是分离的。
"""# Implementor
class MessageSender:def send(self, message):raise NotImplementedError# Concrete Implementors
class EmailSender(MessageSender):def send(self, message):print(f"Email: {message}")class SMSSender(MessageSender):def send(self, message):print(f"SMS: {message}")# Abstraction
class Message:def __init__(self, sender):self.sender = senderdef send(self, message):self.sender.send(message)# Refined Abstraction
class UrgentMessage(Message):def send(self, message):super().send(f"[Urgent] {message}")"""
案例2:多设备图形渲染系统
在这个例子中,我们将创建一个图形渲染系统
可以在不同的设备上渲染图形(如在窗口或者文件中),而渲染的具体图形(如圆形或矩形)由另一层抽象处理。
"""# Implementor(实现者)
"""
Renderer是一个接口,定义了渲染操作的基本方法,如render_circle 和 render_square。这是桥接模式中的“实现者”层。
"""
class Renderer:def render_circle(self, radius):raise NotImplementedErrordef render_square(self, dimension):raise NotImplementedError# Concrete Implementors(具体实现者)
# 渲染技术:矢量渲染
class VectorRenderer(Renderer):def render_circle(self, radius):print(f"Drawing a circle of radius {radius} with VectorRenderer")def render_square(self, dimension):print(f"Drawing a square of size {dimension} with VectorRenderer")#渲染技术:像素(栅格)方式渲染图形
class RasterRenderer(Renderer):def render_circle(self, radius):print(f"Drawing pixels for a circle of radius {radius} with RasterRenderer")def render_square(self, dimension):print(f"Drawing pixels for a square of size {dimension} with RasterRenderer")# Abstraction(抽象层)
"""
Shape 是一个抽象类,它持有一个 Renderer 类型的引用。Shape定义了一个基本的 draw 方法
该方法在具体的图形类中被实现。这是桥接模式中的“抽象”层。
"""
class Shape:def __init__(self, renderer):self.renderer = rendererdef draw(self):pass# Refined Abstraction(精化抽象)
"""
Circle 和 Square 是从Shape派生的具体类。它们分别代表圆形和方形,实现了 draw 方法来调用相应的渲染技术
"""
class Circle(Shape):def __init__(self, renderer, radius):super().__init__(renderer)self.radius = radiusdef draw(self):self.renderer.render_circle(self.radius)class Square(Shape):def __init__(self, renderer, dimension):super().__init__(renderer)self.dimension = dimensiondef draw(self):self.renderer.render_square(self.dimension)"""
案例3:多平台窗口系统
这个例子展示了如何创建一个可以在多个操作系统上运行的窗口系统,使用不同的平台API渲染窗口和不同的控件风格
"""
# Implementor
class WindowImplementor:def draw_window(self, title):raise NotImplementedErrordef draw_button(self, title):raise NotImplementedError# Concrete Implementors
"""
不同系统平台的窗口
"""
class WindowsImplementor(WindowImplementor):def draw_window(self, title):print(f"Windows window: {title}")def draw_button(self, title):print(f"Windows button: {title}")class LinuxImplementor(WindowImplementor):def draw_window(self, title):print(f"Linux window: {title}")def draw_button(self, title):print(f"Linux button: {title}")# Abstraction
class Window:def __init__(self, window_imp):self.window_imp = window_impdef draw(self):raise NotImplementedErrordef draw_button(self):raise NotImplementedError# Refined Abstraction
"""
不同风格的窗口
"""
class IconWindow(Window):def __init__(self, window_imp):super().__init__(window_imp)def draw(self, title):print("Drawing icon window...")self.window_imp.draw_window(title)def draw_button(self, button_title):self.window_imp.draw_button(button_title)class TranslucentWindow(Window):def __init__(self, window_imp):super().__init__(window_imp)def draw(self, title):print("Drawing translucent window...")self.window_imp.draw_window(title)def draw_button(self, button_title):self.window_imp.draw_button(button_title)if __name__ == '__main__':print('*******案例1:简单的消息发送系统***************')email_sender = EmailSender()sms_sender = SMSSender()message = Message(email_sender)message.send("Hello, Bridge Pattern!")urgent_message = UrgentMessage(sms_sender)urgent_message.send("Please call me ASAP!")print('*******案例2:多设备图形渲染系统**************')vector_renderer = VectorRenderer()raster_renderer = RasterRenderer()circle1 = Circle(vector_renderer, 3)circle2 = Circle(raster_renderer,3)square1 = Square(vector_renderer, 10)square2 = Square(raster_renderer, 10)"""Drawing a circle of radius 3 with VectorRendererDrawing pixels for a circle of radius 3 with RasterRendererDrawing a square of size 10 with VectorRendererDrawing pixels for a square of size 10 with RasterRenderer"""circle1.draw()circle2.draw()square1.draw()square2.draw()print('*******案例3:多平台窗口系统**************')windows_imp = WindowsImplementor()linux_imp = LinuxImplementor()icon_window = IconWindow(windows_imp)translucent_window = TranslucentWindow(linux_imp)icon_window.draw("My Application")icon_window.draw_button("OK")translucent_window.draw("My Application")translucent_window.draw_button("Cancel")"""Drawing icon window...Windows window: My ApplicationWindows button: OKDrawing translucent window...Linux window: My ApplicationLinux button: Cancel"""

八、组合模式

python">#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2024-04-28 9:29
# @Author  : Maple
# @File    : 08-组合模式.py"""
组合模式是一种结构型设计模式,用于以树形结构表示部分以及整体层次结构, 使得客户统一的方式处理个别对象以及对象的组合
这种模式非常有用于处理具有递归组成的数据结构。下面是几个示例,展示了如何从简单到复杂应用组合模式。
""""""
案例1:文件系统
在这个例子中,我们使用组合模式来管理文件系统中的文件和文件夹。文件和文件夹可以被统一看待,从而简化了对它们的操作。
"""class FileSystemElement:def show_details(self):raise NotImplementedErrorclass File(FileSystemElement):def __init__(self, name, size):self.name = nameself.size = sizedef show_details(self):print(f"File: {self.name}, Size: {self.size}KB")class Directory(FileSystemElement):def __init__(self, name):self.name = nameself.children = []def add(self, element):self.children.append(element)def remove(self, element):self.children.remove(element)def show_details(self):print(f"Directory: {self.name}")for child in self.children:child.show_details()"""
案例2:图形对象
这个例子展示了如何使用组合模式来管理图形对象,例如圆形、矩形等,以及它们的组合。
"""class Graphic:def draw(self):raise NotImplementedErrorclass Circle(Graphic):def draw(self):print("Drawing a circle")class Rectangle(Graphic):def draw(self):print("Drawing a rectangle")class CompositeGraphic(Graphic):def __init__(self):self.graphics = []def add(self, graphic):self.graphics.append(graphic)def remove(self, graphic):self.graphics.remove(graphic)def draw(self):for graphic in self.graphics:graphic.draw()
class Graphic:def draw(self):raise NotImplementedErrorclass Circle(Graphic):def draw(self):print("Drawing a circle")class Rectangle(Graphic):def draw(self):print("Drawing a rectangle")class CompositeGraphic(Graphic):def __init__(self):self.graphics = []def add(self, graphic):self.graphics.append(graphic)def remove(self, graphic):self.graphics.remove(graphic)def draw(self):for graphic in self.graphics:graphic.draw()class Graphic:def draw(self):raise NotImplementedErrorclass Circle(Graphic):def draw(self):print("Drawing a circle")class Rectangle(Graphic):def draw(self):print("Drawing a rectangle")class CompositeGraphic(Graphic):def __init__(self):self.graphics = []def add(self, graphic):self.graphics.append(graphic)def remove(self, graphic):self.graphics.remove(graphic)def draw(self):for graphic in self.graphics:graphic.draw()"""
案例3:公司结构
这个例子使用组合模式来描述一个公司的组织结构,包括部门和员工。
"""class OrganizationComponent:def __init__(self, name):self.name = namedef add(self, component):raise NotImplementedErrordef remove(self, component):raise NotImplementedErrordef get_name(self):return self.namedef display_details(self):raise NotImplementedErrorclass Department(OrganizationComponent):def __init__(self, name):super().__init__(name)self.components = []def add(self, component):self.components.append(component)def remove(self, component):self.components.remove(component)def display_details(self):print(f"Department: {self.name}")for component in self.components:component.display_details()class Employee(OrganizationComponent):def add(self, component):print("Leaf can't add component")def remove(self, component):print("Leaf can't remove component")def display_details(self):print(f"Employee: {self.name}")if __name__ == '__main__':print('******案例1:文件系统******************')root = Directory("root")child1 = Directory("child1")child2 = Directory("child2")file1 = File("file1", 100)file2 = File("file2", 200)root.add(child1)root.add(child2)child1.add(file1)child2.add(file2)"""Directory: rootDirectory: child1File: file1, Size: 100KBDirectory: child2File: file2, Size: 200KB"""root.show_details()print('******案例2:图形对象******************')circle = Circle()rectangle = Rectangle()composite = CompositeGraphic()composite.add(circle)composite.add(rectangle)"""Drawing a circleDrawing a rectangle"""composite.draw()print('******案例3:图形对象******************')dev_dept = Department("Development")hr_dept = Department("Human Resources")dev_emp1 = Employee("Alice")dev_emp2 = Employee("Bob")hr_emp1 = Employee("Charlie")dev_dept.add(dev_emp1)dev_dept.add(dev_emp2)hr_dept.add(hr_emp1)company = Department("Company")company.add(dev_dept)company.add(hr_dept)"""Department: CompanyDepartment: DevelopmentEmployee: AliceEmployee: BobDepartment: Human ResourcesEmployee: Charlie"""company.display_details()


http://www.ppmy.cn/ops/29279.html

相关文章

Golang chan 实现原理

Golang&#xff1a;context基于go1.22版本 chan的作用和使用方法共享内存的优缺点 chan 的使用方法 chanel 的底层结构channel 结构体创建channel写流程异常处理写时有阻塞读流程写时无阻塞读流程&#xff0c;缓冲区有空间写时无阻塞读流程&#xff0c;缓冲区无空间写流程整体架…

stm32f103c8t6学习笔记(学习B站up江科大自化协)-PWR电源控制

PWR简介 PVD可用在电池供电或安全要求比较高的设备&#xff0c;如果供电电压在逐渐下降&#xff0c;在电压过低的情况下可能会导致内外电路出现不确定的错误。为了避免不必要的错误&#xff0c;可以在电源电压过低的情况下&#xff0c;提前发出警告并关闭较为危险的设备 关闭的…

ROS1快速入门学习笔记 - 12ROS中的坐标管理系统

目录 一、机器人作中的坐标变换 二、海龟案例 一、机器人作中的坐标变换 TF功能包能干什么&#xff1f; 五秒钟之前&#xff0c;机器人头部坐标系相对于全局坐标系的关系是什么样子的&#xff1f;机器人夹取的物体i相对于机器人中心坐标系的位置在哪里&#xff1f;机器人中心…

js之AJAX

ajax 是一种创建交互式网页应用的网页开发技术。其中最核心的依赖是浏览器提供的XMLHttpRequest 对象&#xff0c;是这个对象使得浏览器可以发出 HTTP 请求与接收 HTTP 响应。实现了在页面不刷新的情况下和服务器进行交互 new XMLHttpRequest() 生成一个 XMLHttpRequest 对象 …

Swift - 流程控制

文章目录 Swift - 流程控制if-else2. while3. for3.1 闭区间运算符3.2 半开区间运算符3.3 for - 区间运算符用在数组上3.3.1 单侧区间 3.4 区间类型3.5 带间隔的区间值 4. switch4.1 fallthrough4.2 switch注意点 5. 复合条件6. 区间匹配、元组匹配7. 值绑定8. where9. 标签语句…

Unity Trail Renderer入门

概述&#xff1a; 在项目的开发过程中&#xff0c;一定有时候需要炫酷的尾迹效果&#xff0c;那接下来这部分的内容&#xff0c;一定不要错过&#xff01; Trail Renderer&#xff08;尾迹渲染&#xff09; Time&#xff1a;尾迹存在的时间&#xff0c;时间越长尾迹存在的越久…

2024-04-29 golang-GOPROXY-设置

摘要: 2024-04-29 golang-GOPROXY-设置 GOPROXY (会话临时性)&#xff0c;长久的可以在配置文件中配置 go env -w GOPROXYhttps://goproxy.cn,direct 长久的&#xff0c;在~/.bashrc文件中添加&#xff1a; export GOPROXYhttps://goproxy.cn,direct

ShardingSphere 5.x 系列【26】 数据分片原理之 SQL 路由

有道无术,术尚可求,有术无道,止于术。 本系列Spring Boot 版本 3.1.0 本系列ShardingSphere 版本 5.4.0 源码地址:https://gitee.com/pearl-organization/study-sharding-sphere-demo 文章目录 1. 概述2. 携带分片键2.1 直接路由2.2 标准路由2.3 笛卡尔路由3. 不携带分片…