标签：初始 怎么 efi ios系统 tac 类对象 影响 创建 success
Christopher Alexander：“每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心*。这样你就能一次又一次地使用该方案而不必做重复劳动。”
设计模式是经过总结、优化的，对我们经常会碰到的一些编程问题的可重用解决方案。一个设计模式并不像一个类或一个库那样能够直接作用于我们的代码。反之，设计模式更为高级，它是一种必须在特定情形下实现的一种方法模板。设计模式不会绑定具体的编程语言。一个好的设计模式应该能够用大部分编程语言实现(如果做不到全部的话，具体取决于语言特性)。最为重要的是，设计模式也是一把双刃剑，如果设计模式被用在不恰当的情形下将会造成灾难，进而带来无穷的麻烦。然而如果设计模式在正确的时间被用在正确地地方，它将是你的救星。
起初，你会认为“模式”就是为了解决一类特定问题而特别想出来的明智之举。说的没错，看起来的确是通过很多人一起工作，从不同的角度看待问题进而形成的一个最通用、最灵活的解决方案。也许这些问题你曾经见过或是曾经解决过，但是你的解决方案很可能没有模式这么完备。
虽然被称为“设计模式”，但是它们同“设计“领域并非紧密联系。设计模式同传统意义上的分析、设计与实现不同，事实上设计模式将一个完整的理念根植于程序中，所以它可能出现在分析阶段或是更高层的设计阶段。很有趣的是因为设计模式的具体体现是程序代码，因此可能会让你认为它不会在具体实现阶段之前出现(事实上在进入具体实现阶段之前你都没有意识到正在使用具体的设计模式)。
可以通过程序设计的基本概念来理解模式：增加一个抽象层。抽象一个事物就是隔离任何具体细节，这么做的目的是为了将那些不变的核心部分从其他细节中分离出来。当你发现你程序中的某些部分经常因为某些原因改动，而你不想让这些改动的部分引发其他部分的改动，这时候你就需要思考那些不会变动的设计方法了。这么做不仅会使代码可维护性更高，而且会让代码更易于理解，从而降低开发成本。
三种最基本的设计模式：
接口：一种特殊的类，声明了若干方法，要求继承该接口的类必须实现这些方法。
作用：限制继承该接口的类的方法的名称及调用方式；隐藏了类的内部实现。
接口就是一种抽象的基类（父类），限制继承它的类必须实现接口中定义的某些方法。
Python中使用ABCMeta、abstractmethod的抽象类、抽象方法来实现接口的功能。接口类定义方法，不具体实现，限制子类必须有该方法。在接口子类中实现具体的功能。
# 通过抽象类和抽象方法，做抽象用
from abc import ABCMeta
from abc import abstractmethod # 导入抽象方法
class Father(metaclass=ABCMeta): # 创建抽象类
@abstractmethod
def f1(self):
pass
@abstractmethod
def f2(self):
pass
class F1(Father):
def f1(self):
pass
def f2(self):
pass
def f3(self):
pass
obj = F1()
报错定义接口
class Interface:
def method(self, arg):
raise NotImplementedError
创建模式可以在直接使用类的构造方法实例化对象并不方便时，为开发者提供更好的实例化对象的方式。
内容：不直接向客户端暴露对象创建的实现细节，而是通过一个工厂类来负责创建产品类的实例。
角色：
优点：
缺点：
PaymentFactory简单工厂
from abc import abstractmethod, ABCMeta
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self, money):
pass
class Alipay(Payment):
def __init__(self, enable_yuebao=False):
self.enable_yuebao = enable_yuebao
def 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 Alipay()
elif method == ‘yuebao‘:
return Alipay(enable_yuebao=True)
elif method == "applepay":
return ApplePay()
else:
raise NameError(method)
f = PaymentFactory()
p = f.create_payment("yuebao")
p.pay(100)
内容：定义一个用于创建对象的接口（工厂接口），让子类决定实例化哪一个产品类。
角色：
工厂方法模式相比简单工厂模式将每个具体产品都对应了一个具体工厂。
适用场景：
优点：
缺点：
工厂方法
from abc import abstractmethod, ABCMeta
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self, money):
pass
class Alipay(Payment):
def pay(self, money):
print("支付宝支付%s元" % money)
class ApplePay(Payment):
def pay(self, money):
print("苹果支付%s元" % money)
class PaymentFactory(metaclass=ABCMeta):
@abstractmethod
def create_payment(self):
pass
class 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(120)
内容：定义一个工厂类接口，让工厂子类来创建一系列相关或相互依赖的对象。
例：生产一部手机，需要手机壳、CPU、操作系统三类对象进行组装，其中每类对象都有不同的种类。对每个具体工厂，分别生产一部手机所需要的三个对象中对应的一个。
角色：
相比工厂方法模式，抽象工厂模式中的每个具体工厂都生产一套产品。
适用场景：
优点：
缺点：
抽象工厂
from abc import abstractmethod, ABCMeta
# ------抽象产品------
class PhoneShell(metaclass=ABCMeta):
@abstractmethod
def show_shell(self):
pass
class CPU(metaclass=ABCMeta):
@abstractmethod
def show_cpu(self):
pass
class OS(metaclass=ABCMeta):
@abstractmethod
def show_os(self):
pass
# ------抽象工厂------
class PhoneFactory(metaclass=ABCMeta):
@abstractmethod
def make_shell(self):
pass
@abstractmethod
def make_cpu(self):
pass
@abstractmethod
def 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 Android(OS):
def show_os(self):
print("Android系统")
class IOS(OS):
def show_os(self):
print("iOS系统")
# ------具体工厂------
class MiFactory(PhoneFactory):
def make_cpu(self):
return SnapDragonCPU()
def make_os(self):
return Android()
def make_shell(self):
return BigShell()
class HuaweiFactory(PhoneFactory):
def make_cpu(self):
return MediaTekCPU()
def make_os(self):
return Android()
def make_shell(self):
return SmallShell()
class IPhoneFactory(PhoneFactory):
def make_cpu(self):
return AppleCPU()
def make_os(self):
return IOS()
def make_shell(self):
return AppleShell()
# ------客户端------
class Phone:
def __init__(self, cpu, os, shell):
self.cpu = cpu
self.os = os
self.shell = shell
def show_info(self):
print("手机信息:")
self.cpu.show_cpu()
self.os.show_os()
self.shell.show_shell()
def make_phone(factory):
cpu = factory.make_cpu()
os = factory.make_os()
shell = factory.make_shell()
return Phone(cpu, os, shell)
p1 = make_phone(HuaweiFactory())
p1.show_info()
内容：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
角色：
建造者模式与抽象工厂模式相似，也用来创建复杂对象。主要区别是建造者模式着重一步步构造一个复杂对象，而抽象工厂模式着重于多个系列的产品对象。
适用场景：
优点：
建造者模式
from abc import abstractmethod, ABCMeta
# ------产品------
class Player:
def __init__(self, face=None, body=None, arm=None, leg=None):
self.face = face
self.arm = arm
self.leg = leg
self.body = body
def __str__(self):
return "%s, %s, %s, %s" % (self.face, self.arm, self.body, self.leg)
# ------建造者------
class PlayerBuilder(metaclass=ABCMeta):
@abstractmethod
def build_face(self):
pass
@abstractmethod
def build_arm(self):
pass
@abstractmethod
def build_leg(self):
pass
@abstractmethod
def build_body(self):
pass
@abstractmethod
def get_player(self):
pass
class BeautifulWomanBuilder(PlayerBuilder):
def __init__(self):
self.player = Player()
def build_face(self):
self.player.face = "漂亮脸蛋"
def build_arm(self):
self.player.arm = "细胳膊"
def build_body(self):
self.player.body = "细腰"
def build_leg(self):
self.player.leg = "长腿"
def get_player(self):
return self.player
class PlayerDirector:
def build_player(self, builder):
builder.build_body()
builder.build_arm()
builder.build_leg()
builder.build_face()
return builder.get_player()
director = PlayerDirector()
builder = BeautifulWomanBuilder()
p = director.build_player(builder)
print(p)
内容：保证一个类只有一个实例，并提供一个访问它的全局访问点。
角色：
适用场景
当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时
单例模式也可以用于对应用中共享的资源或功能的访问进行限制.
比如数据库的连接对象或者记录日志的对象就可以用单例模式创建, 全局使用一份, 不仅避免了每次重新实例化对象浪费的资源, 也便于应用整体的管理.
优点：
与单例模式功能相似的概念：全局变量、静态变量（方法）
首先, 为了保证一个类的对象在应用中只有一份, 我们除了要在实例化的过程中进行限制以外, 还需要注意禁止对这类对象的拷贝.
另外, Python中使用单例模式的一大误区就是依靠重写__new__方法的方式实现单例模式. 这种写法可能在一般使用情况下没有问题, 但当需要继承扩展使用单例模式的类时就会出现一些无法预期的效果. 虽然单例类一般不应该被继承扩展, 尤其不该有多层继承, 但是了解可能出现的错误以及如何避免可以让代码更加的健壮.
__new__ 方法）class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
class Child(Singleton):
pass
def identity_test():
s1 = Singleton()
s2 = Singleton()
print(s1 is s2) # True
exit(0)
def create_parent_first():
s1 = Singleton()
c1 = Child()
print(c1 is s1) # True
exit(0)
def create_child_first():
c1 = Child()
s1 = Singleton()
print(c1 is s1) # False
exit(0)
从以上示例代码的执行结果中可以看出重写 __new__ 方法实现单例模式的类被继承时的一些问题:
注意：在交互解释器中连续执行create_parent_first()和create_child_first(), 在执行第二个函数时由于内存中已经有了实例化的对象, 会显示错误的结果.
1、单例模式的正确写法应该是使用元类. 首先定义一个单例元类, 然后在声明需要使用单例模式的类时指定单例元类作为元类.
class SingletonType(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class DatabaseConnector(metaclass=SingletonType):
pass
class MySQLConnector(DatabaseConnector):
pass
def identity_test():
d1 = DatabaseConnector()
d2 = DatabaseConnector()
m1 = MySQLConnector()
m2 = MySQLConnector()
print(d1 is d2) # True
print(m1 is m2) # True
exit(0)
def create_parent_first():
d = DatabaseConnector()
m = MySQLConnector()
print(d is m) # False
exit(0)
def create_child_first():
m = MySQLConnector()
d = DatabaseConnector()
print(d is m) # False
exit(0)
从执行结果中可以看出, 在错误写法中出现的问题在使用元类实现单例时都不存在, 子类与父类永远指向不同的单例对象, 不受实例化顺序的影响.
2、装饰器方法
def singleton(cls, *args, **kw):
instances = {}
def get_instance():
if cls not in instances:
instances[cls] = cls(*args, **kw)
return instances[cls]
return get_instance
@singleton
class MyClass2:
a = 1
one = MyClass2()
two = MyClass2()
print(id(one)) # 31495472
print(id(two)) # 31495472
print(one == two)
print(one is two)
Python开发者对于单例模式的不同看法
单例模式在Python中是比较受争议的一种设计模式. 许多开发者认为使用单例模式来保证程序中某些东西的唯一性的写法过于臃肿, 在Python中可以借助语言的一些特性用更自然, 更符合Python风格的写法实现类似的功能.
同时, 在一些场景中应该谨慎使用或者避免单例模式, 比如分布式计算, 自动化测试等. 这些场景中使用单例模式可能反而会产生负面效果.
要不要用单例模式, 怎么用单例模式要根据具体情况而定. 我个人认为, 重要的不是实现方式, 而是实现方式背后单例模式的思想.
Borg(也叫做Monostate)是由Alex Martelli提出的一种实现类似单例模式行为的写法, 它并不是传统设计模式中的一种.
这种写法的核心思想是: 不限制一个类有多少的实例, 只要类的所有实例的状态都是共享的, 同样可以实现类似单例模式中的统一性.
具体实现就是在使用Borg实例化新对象时, 所有对象都共享一个__dict__.
使用Borg也可以解决错误实现方式中的继承问题. 但是Borg写法也有着自己的隐患. 当继承Borg的子类中重写了__getattr__方法可能出现问题.
class Borg:
_state = {}
def __new__(cls, *args, **kwargs):
obj = super().__new__(cls, *args, **kwargs)
obj.__dict__ = cls._state
return obj
class DatabaseConnector:
_state = {}
def __new__(cls, db, *args, **kwargs):
obj = super().__new__(cls, *args, **kwargs)
obj.__dict__ = cls._state
return obj
def __init__(self, db):
self.db = db
if __name__ == "__main__":
d1 = DatabaseConnector("MySQL")
d2 = DatabaseConnector("PostgreSQL")
print(d1.db) # PostgreSQL
print(d2.db) # PostgreSQL
Python中的模块可以用于代替上面提到的几种写法实现单例模式, 因为Python中的模块本身已经是单例了.
最常见的用法就是在模块中实例化需要作为单例使用的对象并赋值给模块中的作用域是整个模块的变量, 然后开发者在需要时直接从模块中导入这个对象来使用而不自己手动实例化.
这种写法相对而言并不稳妥, 因为我们可以随时给指向单例对象的变量重新赋值, 也依然可以直接实例化对象.
但是换个角度来看, 这种做法也让我们的代码更加的灵活, 我们可以写文档注释来提示其他开发者某些对象应该作为单例来使用, 但当他们有其它需求时也可以直接实例化创建多个对象。
# Python的模块是天然的单例模式。
# module_name.py
class MySingleton(object):
def foo(self):
print(‘danli‘)
my_singleton = MySingleton()
# to use
from .module_name import my_singleton
my_singleton.foo()
print(id(my_singleton))
from .module_name import my_singleton
my_singleton.foo()
print(id(my_singleton))
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。在Python中最简单的原型模式可以使用copy模块中的deepcopy函数来实现，它接收一个对象作为参数，然后返回这个对象的拷贝对象。正是因为在Python中拷贝是内置功能，使用起来非常方便和自然，因此在使用时也较少被称为一种模式。
当系统中已有一个对象时，如果需要修改它的一些属性，但同时我们不想直接对它做出修改，此时就可以使用原型模式。以已有对象作为原型创建拷贝，然后修改和使用拷贝的对象。
比如在Django中，
HttpRequest对象中的GET和POST是QueryDict类型的对象，它默认是不可变的。 如图所示：
虽然
HttpRequest的初始化方法中创建QueryDict时设置为了可变，但在视图中修改request.GET时会报错。
所以当我们需要修改
request.GET时，就可以创建一份拷贝。拷贝得到的对象是可变的，我们可以对拷贝的对象进行修改后使用。使用QueryDict对象的copy方法就可以创建拷贝。从源码截图中可以看出，copy`方法内部调用的还是Python内置的深拷贝。
import copy
class Prototype:
def __init__(self):
self._objects = {}
def register_object(self, name, obj):
"""Register an object"""
self._objects[name] = obj
def unregister_object(self, name):
"""Unregister an object"""
del self._objects[name]
def clone(self, name, **attr):
"""Clone a registered object and update inner attributes dictionary"""
obj = copy.deepcopy(self._objects.get(name))
obj.__dict__.update(attr)
return obj
def main():
class A:
def __str__(self):
return "I am A"
a = A()
prototype = Prototype()
prototype.register_object(‘a‘, a)
b = prototype.clone(‘a‘, a=1, b=2, c=3)
print(a)
print(b.a, b.b, b.c)
if __name__ == ‘__main__‘:
main()
使用抽象工厂（Abstract Factory）、原型（Prototype）或者建造者（Builder）的设计甚至比工厂方法（Factory Method）的那些设计更灵活，但它们也更加复杂。通常，设计以使用工厂方法（Factory Method）开始。并且当设计者发现需要更大的灵活性时，设计便会想其他创建模式烟花。当你在设计标准之间权衡的时候，了解多个模式可以给你提供给更多的选择余地。
依赖于继承的创建型模式：工厂方法模式
依赖于组合的创建型模式：抽象工厂模式、创建者模式
这些设计模式在大型应用中十分重要，它们为开发者提供了划分代码组织结构的方法，以及如何让应用中的各个部分协同工作的方法。
内容：将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
角色：
两种实现方式：
适用场景：
类适配器：
对象适配器：
适配器模式示例代码：
from abc import abstractmethod, ABCMeta
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self, money):
raise NotImplementedError
class Alipay(Payment):
def pay(self, money):
print("支付宝支付%s元" % money)
class ApplePay(Payment):
def pay(self, money):
print("苹果支付%s元" % money)
# ------待适配类------
class WechatPay:
def cost(self, money):
print("微信支付%s元" % money)
# 类适配器
class RealWechatPay(WechatPay, Payment):
def pay(self, money):
return self.cost(money)
# 对象适配器
class RealWechatPay2(Payment):
def __init__(self):
self.payment = WechatPay()
def pay(self, money):
return self.payment.cost(money)
p = RealWechatPay2()
p.pay(111)
内容：将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
角色：
适用场景：
优点：
缺点：
组合模式示例代码：
from abc import abstractmethod, ABCMeta
class Graphic(metaclass=ABCMeta):
@abstractmethod
def draw(self):
pass
@abstractmethod
def add(self, graphic):
pass
def getchildren(self):
pass
# 图元
class Point(Graphic):
def __init__(self, x, y):
self.x = x
self.y = y
def draw(self):
print(self)
def add(self, graphic):
raise TypeError
def getchildren(self):
raise TypeError
def __str__(self):
return "点(%s, %s)" % (self.x, self.y)
class Line(Graphic):
def __init__(self, p1, p2):
self.p1 = p1
self.p2 = p2
def draw(self):
print(self)
def add(self, graphic):
raise TypeError
def getchildren(self):
raise TypeError
def __str__(self):
return "线段[%s, %s]" % (self.p1, self.p2)
class Picture(Graphic):
def __init__(self):
self.children = []
def add(self, graphic):
self.children.append(graphic)
def getchildren(self):
return self.children
def draw(self):
print("------复合图形------")
for g in self.children:
g.draw()
print("------END------")
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()
#pic1.draw()
#point.draw()
内容：
装饰模式允许我们使用其它对象将提供核心功能的对象包装起来, 借此提供额外的功能或者修改原对象的行为和功能. 被装饰后的对象应与原对象拥有相同的接口, 这样允许我们在不影响代码其它部分的情况下自由选择使用装饰后的对象还是原对象. 装饰是可以嵌套的, 由在最内层的对象提供核心功能.
装饰模式与Python装饰器：
首先要明确一点, 装饰模式与Python中的装饰器是不同的概念.
本篇文章仅讨论装饰模式, 以后也会整理发布Python装饰器相关的文章供大家参考.
装饰模式是一种无关具体语言的设计模式, 而Python语言中的装饰器是一种可调用对象, 它接收一个函数作为参数, 也会返回一个函数作为结果. 一般会将返回的函数重新赋值代替原函数来扩展函数, 方法或类的功能.
Python中的函数也是对象, 在Python中使用装饰器装饰函数其实就是在应用装饰模式. Python开发者们经常会用到这种用法, 以至于Python为装饰器提供了@decorator的语法糖来简化这种写法.
当对函数进行装饰时, 一般都是为了永久的扩展或修改函数的功能, 所以都是在函数定义时, 而不是在运行时决定是否使用装饰器. 使用语法糖的好处是可以很清晰的看出函数是被装饰过的. 语法糖仅能用于我们自己的代码, 在想要装饰第三方的代码时, 由于我们无法修改源码, 所以依然只能使用重新赋值的方式进行装饰.
适用场景：
在需要拓展一些通用功能时可以考虑使用装饰模式, 比如:
在Django中就提供了许多视图的装饰器, 其中就有一些可以用来校验访问用户的权限或者缓存视图提高处理响应的效率.
装饰模式与继承：
以下讨论适用于单继承以及多继承.
由于装饰模式也可以给对象添加额外的功能, 有时也可以用装饰模式来代替继承.
对比使用继承, 装饰模式主要有两大优势, 或者说只有满足以下两点中的条件时才应该优先选择装饰模式:
装饰模式示例代码：
下面这个简单的例子中, 根据
debug以及log条件的值, 最终的adder对象的行为也会发生变化. 当两个值都为True时, 最终的adder对象是经过了两层装饰后的对象, 在调用add方法时既会在控制台中打印, 也会写入日志文件.
假如我们只需要写入日志的额外功能, 即只需要
LogAdder类, 那么LogAdder类也可以使用继承Adder类的方式来实现. 如上文中提到的, 当有多个可选扩展和/或需要动态决定是否使用扩展功能时, 使用装饰模式更加简便.
class Adder:
def add(self, a, b):
return a + b
class PrintAdder:
def __init__(self, adder):
self.adder = adder
def add(self, a, b):
res = self.adder.add(a, b)
print(f"{a} + {b} = {res}")
return res
class LogAdder:
def __init__(self, adder):
self.adder = adder
def add(self, a, b):
res = self.adder.add(a, b)
with open("adder.log", "w") as f:
f.write(f"{a} + {b} = {res}\n")
return res
if __name__ == "__main__":
debug = True
log = True
adder = Adder()
if debug:
adder = PrintAdder(adder)
if log:
adder = LogAdder(adder)
adder.add(1, 1)
print("from log: ", end="")
with open("adder.log", "r") as f:
print(f.read())
"""
1 + 1 = 2
from log: 1 + 1 = 2
"""
上面的例子主要为了展示装饰模式的思想, 在Python中可以使用装饰器更简单的完成上面的例子, 一般也更推荐使用那种方式.
内容：
桥接模式与适配器模式看起来十分相似, 它们的区别在于: 适配器模式是用在已有代码上让它们一起工作, 而桥接模式用在开始写其它代码之前.
桥接模式可以让我们将抽象部分与具体实现部分分开, 用组合代替继承, 这样后续调整扩展抽象部分或实现部分时更简单.
Python中的桥接模式中主要有两类角色:
当有需要时也可以按照传统的桥接模式定义四类角色来实现(参考http://c.biancheng.net/view/1364.html):
上面的内容可能不太好理解, 看看示例代码就容易理解了.
适用场景：
想要在多个对象中共享实现时可以使用桥接模式.
桥接模式示例代码：
下面的代码中的IOPrinter是抽象化角色, 它目前拥有两个功能: 从指定I/O读取全部数据或者预览I/O中的部分内容. 这两个功能的实现被所有具体实现化角色共享.
StdinReader是具体实现化角色, 它内部实现了抽象化角色需要调用的read()方法, 同时Python内置的文件对象中也有read()方法, 所以也可以作为一种具体实现.
class IOPrinter:
def __init__(self, reader):
self.reader = reader
def print_all(self):
print(self.reader.read())
def preview(self):
print(self.reader.read()[:5], "...")
class StdinReader:
def read(self):
return input("stdin: ")
if __name__ == "__main__":
with open("file.txt", "r") as f:
printer = IOPrinter(f)
printer.print_all()
printer = IOPrinter(StdinReader())
printer.preview()
这段代码也展示了使用桥接模式带来的程序扩展性, 我们可以通过扩展抽象化角色添加新的功能, 比如增加倒序打印, 同时也可以通过创建新的具体实现化角色来添加新的功能, 比如从网络上或从数据库读取数据.
内容：为其他对象提供一种代理以控制对这个对象的访问。
角色：
适用场景：
优点：
代理模式示例代码：
from abc import ABCMeta, abstractmethod
class Subject(metaclass=ABCMeta):
@abstractmethod
def get_content(self):
pass
def set_content(self, content):
pass
class RealSubject(Subject):
def __init__(self, filename):
self.filename = filename
print("读取%s文件内容" % filename)
f = open(filename)
self.__content = f.read()
f.close()
def get_content(self):
return self.__content
def set_content(self, content):
f = open(self.filename, ‘w‘)
f.write(content)
self.__content = content
f.close()
# ---远程代理
class ProxyA(Subject):
def __init__(self, filename):
self.subj = RealSubject(filename)
def get_content(self):
return self.subj.get_content()
def set_content(self, content):
return self.subj.set_content(content)
# ---虚代理
class ProxyB(Subject):
def __init__(self, filename):
self.filename = filename
self.subj = None
def get_content(self):
if not self.subj:
self.subj = RealSubject(self.filename)
return self.subj.get_content()
x = ProxyB(‘abc.txt‘)
# print(x.get_content())
# ---保护代理
class ProxyC(Subject):
def __init__(self, filename):
self.subj = RealSubject(filename)
def get_content(self):
self.subj.get_content()
def set_content(self, content):
raise PermissionError
# filename = "abc.txt"
# username = input()
# if username!="alex":
# p = ProxyC(filename)
# else:
# p = ProxyA(filename)
#
# print(p.get_content())
内容：
MVC其实是一种架构模式而不是一种设计模式, 两者的区别就是前者的应用范围更加广泛. 因为这个模式太重要了, 又和设计模式有一定关联, 于是决定放在一起讨论.
MVC模式是软件设计中的SoC(Separation of Concerns)原则应用在面向对象编程模式中的一种体现. SoC原则大致可以理解为: 将程序分成不同的部分, 每个部分都都有自己明确的分工, 每个部分只关注负责自己的分工.
MVC模式将应用程序分成三大部分: 模型(model), 视图(view)和控制器(controller). 这个模式的名称也来源于这三大部分.
使用控制器作为传话筒看起来有些冗余, 但它有着存在的必要: 使用控制器可以在不修改模型的情况下让它拥有多个视图. 一般而言, 想要做到这一点的话每个视图都应该有着自己的控制器.
应用MVC模式的程序的典型使用流程：
优点与应用：
优点：
- 模型与视图的分离可以让负责不同部分的开发者同时进行开发互不影响.
- 模型与视图耦合性低, 修改扩展已有的模型和视图时不会相互干扰. 添加新的视图也很简单.
- 每部分分工明确, 易于后期维护。
应用：
一般来讲我们不需要从零开始实现MVC架构而是直接使用已有的应用了MVC架构或其变种的框架.
MVC或者它的变种在框架中非常常见, 比如Django框架就使用了从MVC演变来的MTV(Model-Template-View)模式.
名称对照表:
| 传统MVC模式 | Django MTV模式 |
|---|---|
| model | model |
| view | template |
| controller | view |
Django的设计者认为视图(view)描述控制着什么(what)数据可以被用户看到, 所以他使用视图来命名负责这个功能的组件. 而模板(template)在Django中负责展示数据, 它决定数据是怎样(how)展示给用户.
当已有的框架都不能满足我们的需求时, 我们也可以自己实现MVC模式.
当从零开始实现MVC时, 模型, 视图和控制器需要满足以下原则.
当我们想要确认是否正确的实现了MVC模式时, 可以试着回答以下问题:
内容：
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
角色：
例：
适用场景：
优点：
缺点：
请假流程：
from abc import ABCMeta, abstractmethod
class Handler(metaclass=ABCMeta):
@abstractmethod
def handle_leave(self, day):
pass
class GeneralManagerHandler(Handler):
def handle_leave(self, day):
if day < 10:
print("总经理批准%d天假" % day)
return True
else:
print("呵呵")
return False
class DepartmentManagerHandler(Handler):
def __init__(self):
self.successor = GeneralManagerHandler()
def handle_leave(self, day):
if day < 7:
print("部门经理批准%d天假" % day)
return True
else:
print("部门经理无权准假")
return self.successor.handle_leave(day)
class ProjectDirectorHandler(Handler):
def __init__(self):
self.successor = DepartmentManagerHandler()
def handle_leave(self, day):
if day < 3:
print("项目主管批准%d天假" % day)
return True
else:
print("项目主管无权准假")
return self.successor.handle_leave(day)
day = 11
h = ProjectDirectorHandler()
print(h.handle_leave(day))
模仿js事件处理
# --高级例子--模仿js事件处理
from abc import ABCMeta, abstractmethod
class Handler(metaclass=ABCMeta):
@abstractmethod
def add_event(self, func):
pass
@abstractmethod
def handle(self):
pass
class BodyHandler(Handler):
def __init__(self):
self.func = None
def add_event(self, func):
self.func = func
def handle(self):
if self.func:
return self.func()
else:
print("已到最后一级，无法处理")
class ElementHandler(Handler):
def __init__(self, successor):
self.func = None
self.successor = successor
def add_event(self, func):
self.func = func
def handle(self):
if self.func:
return self.func()
else:
return self.successor.handle()
# 客户端
# <body><div><a>
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‘].append(div)
div[‘children‘].append(a)
# print(body)
body[‘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)
# test
def func_a():
print("这是给a的函数")
def func_div():
print("这是给div的函数")
def func_body():
print("这是给body的函数")
attach_event(a, func_a)
attach_event(div, func_div)
attach_event(body, func_body)
a[‘event_handler‘].handle()
内容：
提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。
适用场景：
实现方法：iter、next
链表：
class LinkList:
"""链表 头结点保存链表的长度"""
class Node:
def __init__(self, item=None):
self.item = item
self.next = None
class LinkListIterator:
def __init__(self, node):
self.node = node
def __next__(self):
if self.node:
cur_node = self.node
self.node = cur_node.next
return cur_node.item
else:
raise StopIteration
def __iter__(self):
return self
def __init__(self, iterable=None):
self.head = LinkList.Node(0)
self.tail = self.head
self.extend(iterable)
def append(self, obj):
s = LinkList.Node(obj)
self.tail.next = s
self.tail = s
self.head.item += 1
def extend(self, iterable):
for obj in iterable:
self.append(obj)
def __iter__(self):
return self.LinkListIterator(self.head.next)
def __len__(self):
return self.head.item
def __str__(self):
return "<<" + ", ".join(map(str, self)) + ">>"
li = [i for i in range(100)]
lk = LinkList(li)
print(lk)
内容：
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。观察者模式又称“发布-订阅”模式
角色：
适用场景：
优点：
缺点：
发布者——订阅者：
from abc import ABCMeta, abstractmethod
class Observer(metaclass=ABCMeta):
@abstractmethod
def update(self, notice):
pass
class Notice:
def __init__(self):
self.observers = []
def attach(self, obs):
self.observers.append(obs)
def detach(self, obs):
self.observers.remove(obs)
# obs.company_info=None
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
def detach(self, obs):
super().detach(obs)
obs.company_info = None
@property
def company_info(self):
return self.__company_info
@company_info.setter
def company_info(self, info):
self.__company_info = info
self.notify()
class Manager(Observer):
def __init__(self):
self.company_info = None
def update(self, noti):
self.company_info = noti.company_info
notice = ManagerNotice()
alex = Manager()
wusir = Manager()
print(alex.company_info)
print(wusir.company_info)
notice.attach(alex)
notice.attach(wusir)
notice.company_info = "公司运行良好"
print(alex.company_info)
print(wusir.company_info)
notice.company_info = "公司将要上市"
print(alex.company_info)
print(wusir.company_info)
notice.detach(wusir)
notice.company_info = "公司要破产了，赶快跑路"
print(alex.company_info)
print(wusir.company_info)
notice.company_info = "公司已经破产了"
print(alex.company_info)
print(wusir.company_info)
内容：
定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
角色：
适用场景：
优点：
缺点：
策略模式示例代码：
from abc import ABCMeta, abstractmethod
import random
class Sort(metaclass=ABCMeta):
@abstractmethod
def sort(self, data):
pass
class QuickSort(Sort):
def quick_sort(self, data, left, right):
if left < right:
mid = self.partition(data, left, right)
self.quick_sort(data, left, mid - 1)
self.quick_sort(data, mid + 1, right)
def partition(self, data, left, right):
tmp = data[left]
while left < right:
while left < right and data[right] >= tmp:
right -= 1
data[left] = data[right]
while left < right and data[left] <= tmp:
left += 1
data[right] = data[left]
data[left] = tmp
return left
def sort(self, data):
print("快速排序")
return self.quick_sort(data, 0, len(data) - 1)
class MergeSort(Sort):
def merge(self, data, low, mid, high):
i = low
j = mid + 1
ltmp = []
while i <= mid and j <= high:
if data[i] <= data[j]:
ltmp.append(data[i])
i += 1
else:
ltmp.append(data[j])
j += 1
while i <= mid:
ltmp.append(data[i])
i += 1
while j <= high:
ltmp.append(data[j])
j += 1
data[low:high + 1] = ltmp
def merge_sort(self, data, low, high):
if low < high:
mid = (low + high) // 2
self.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 = data
self.strategy = strategy
def set_strategy(self, strategy):
self.strategy = strategy
def do_strategy(self):
if self.strategy:
self.strategy.sort(self.data)
else:
raise TypeError
li = list(range(100000))
random.shuffle(li)
context = Context(li, MergeSort())
context.do_strategy()
# print(context.data)
random.shuffle(context.data)
context.set_strategy(QuickSort())
context.do_strategy()
内容：
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
角色：
适用场景：
模板方法示例代码：
from abc import ABCMeta, abstractmethod
class IOHandler(metaclass=ABCMeta):
@abstractmethod
def open(self, name):
pass
@abstractmethod
def deal(self, change):
pass
@abstractmethod
def 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 World")
标签：初始 怎么 efi ios系统 tac 类对象 影响 创建 success
原文地址：https://www.cnblogs.com/fengting0913/p/13508348.html
