python设计模式

观察者模式

python观察者模式是一种设计模式
需求：员工上班在偷偷看股票，拜托前台一旦老板进来，就通知他们，让他们停止看股票。
这里有两类人，一类是观察者，即员工，一类是通知者，即前台，员工在观察前台的状态，前台负责通知员工最新的动态。

#encoding=utf-8
__author__ = 'kevinlu1010@qq.com'
from abc import ABCMeta, abstractmethod

class Subject():
    __metaclass__ = ABCMeta
    observers=[]
    status=''
    @abstractmethod
    def attach(self,observer):
        pass
    @abstractmethod
    def detach(self,observer):
        pass
    @abstractmethod
    def notify(self):
        pass

class Observer():
    __metaclass__ = ABCMeta
    def __init__(self,name,sub):
        self.name=name
        self.sub=sub
    @abstractmethod
    def update(self):
        pass

class Boss(Subject):
    def __init__(self):
        pass
    def attach(self,observer):
        self.observers.append(observer)

    def detach(self,observer):
        self.observers.remove(observer)
    def notify(self):
        for observer in self.observers:
            observer.update()

class StockObserver(Observer):
    def update(self):
        print '%s,%s停止看股票'%(self.sub.status,self.name)
class NBAObserver(Observer):
    def update(self):
        print '%s,%s停止看NBA'%(self.sub.status,self.name)

if __name__=='__main__':
    boss=Boss()
    observe1=StockObserver('张三',boss)
    observe2=NBAObserver('李四',boss)
    boss.attach(observe1)
    boss.attach(observe2)
    boss.detach(observe2)
    boss.status='我是老板，我来了'
    boss.notify()

如果觉得这个有点复杂没看懂，那就看下面这个简单一点的

# 设计模式：一种通用的解决方案
# 观察者模式

class Observer:
    """
    观察者
    """
    def __init__(self, name):
        self.name = name

    def update(self, msg):
        print(self.name + '收到消息：' + msg)

class Subject:
    """

    """
    def __init__(self):
        self.observers = []

    def add_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

    def notify(self, msg):
        for observer in self.observers:
            observer.update(msg)

xiaoming = Observer('xiaoming')
lihua = Observer('lihua')

rain = Subject()
rain.add_observer(xiaoming)
rain.add_observer(lihua)
rain.notify('下雨了。。。')
rain.remove_observer(lihua)

rain.notify("打雷了")

单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。这里我们讲解一个单例模式的实现方法——通过重写系统创建对象时分类内存的函数new

class S:
    instance = None
    # __new__方法用来制作单例
    def __new__(cls, *args, **kwargs):
        if S.instance == None:
            S.instance = super().__new__(cls) # 这句话是用来分配内存的，
        return S.instance
s1 = S()
print(id(s1))
s2 = S()
print(id(s2))

2159709448232
2159709448232

编程常用技巧：鸭子类型

简单来说，就是用不同的类给同一个变量赋值，这些类之间有同名的方法，用变量.方法调用时，变量是用哪个类的对象就调用哪个类里面的方法。这样可以优化程序，可读性也更高。

class Programer:
    def dowork(self):
        print("biancheng")
class Manger:
    def dowork(self):
        print("guanli")

employee = Manger()
employee.dowork()
employee = Programer()
employee.dowork()