（一）python 设计模式 --- 六大原则

单一职责原则（SRP：Single responsibility principle），一个类或者模块应该有且只有一个改变的原因，例如，搓衣板，既可以用来跪，也可以用来洗衣服。而在单一职责原理下，搓衣板的两个功能就是引起这个类变化的两个原因，就应该写成两个类

# -*- coding: utf-8 -*-

"""
单一职责原则
"""


class Person(object):

    """ 人类 """

    def duty(self, one):

        """ Coder 的职责是写代码 ，农民就负责斗地主，其余的学习 """

        return one is "Coder" and "Coding" or one is "Farmer" and "Chinese poker" or "Studying"


if __name__ == '__main__':
    p = Person()
    print(p.duty("Coder"))

• 此时如果细分责任到每一个人，岂不是一堆的判断，肯定不科学，所以尽量让一个类或者一个模块做一件事

# -*- coding: utf-8 -*-

"""
单一职责原则
"""


class Person(object):

    """ 人类 """

    def duty(self, one):

        """ Coder 的职责是写代码 ，农民就负责斗地主，其余的学习 """

        return one is "Coder" and "Coding" or one is "Farmer" and "Chinese poker" or "Studying"


class Coder(Person):

    """ 农民 """

    def duty(self):

        """ Coder 的职责是写代码 """

        return "Coding"


class Farmer(Person):

    """ 程序员 """

    def duty(self):

        """ 农民就负责斗地主 """

        return "Chinese poker"

if __name__ == '__main__':
    c = Coder()
    print(c.duty())
    f = Farmer()
    print(f.duty())

---

里氏替换原则( LSP：Liskov Substitution Principle)：任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为

• 子类必须完全实现父类的抽象方法，但不能覆盖父类的非抽象方法

• 子类可以实现自己特有的方法

• 当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

• 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

• 子类的实例可以替代任何父类的实例，但反之不成立

# -*- coding: utf-8 -*-
import abc
import time
"""
里氏替换原则
"""
HOUR = 3600

class Person(object):

    """ 人类 """
    @abc.abstractmethod
    def duty(self):

        """ 职责 """
        pass


class Coder(Person):

    """ 程序员 """

    def duty(self):

        """ Coder 的职责是写代码 """

        return "Coding"

    def sleep(self):

        """ 有时睡5小时 """

        time.sleep(5*HOUR)


class Farmer(Person):

    """ 程序员 """

    def duty(self):

        """ 农民就负责斗地主 """

        return "Chinese poker"

    def sleep(self):

        """ 农民可以睡八小时 """

        time.sleep(8*HOUR)

依赖倒置原则(Dependence Inversion Principle)：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象

# -*- coding: utf-8 -*-
import abc
import time
"""
里氏替换原则
"""
HOUR = 3600

class Person(object):

    """ 人类 """
    @abc.abstractmethod
    def duty(self):

        """ 职责 """
        pass


class Coder(Person):

    """ 程序员 """

    def duty(self):

        """ Coder 的职责是写代码 """

        return "Coding"

    def sleep(self):

        """ 睡5小时 """

        time.sleep(5*HOUR)

接口隔离原则（Interface Segregation Principle） 这个原则的意思是：每个接口中不存在子类用不到却必须实现的方法，如果不然就要将接口拆分，使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个接口）要好

# -*- coding: utf-8 -*-
"""
接口隔离原则
"""
import abc
import time
import types

HOUR = 3600

class Person(object):

    """ 人类 """
    @abc.abstractmethod
    def duty(self):

        """ 职责 """
        pass


class Coder(Person):

    """ 程序员 """

    def duty(self):

        """ Coder 的职责是写代码 """

        return "Coding"

    def sleep(self):

        """ 有时睡5小时 """

        time.sleep(5*HOUR)

# 方法一
# def programme(self, language='Php'):
#     """ 实例动态方法 """
#     return language

# 方法二
# @classmethod
# def programme(cls, language='Php'):
#     """ 类动态方法 """
#     return language

# 方法三
@staticmethod
def programme(language='Php'):
    """ 静态方法 """
    return language

if __name__ == '__main__':

    # 方法一：给实例绑定方法
    # p = Coder()
    # p.programme = types.MethodType(programme, p)
    # print(p.programme('Python'))

    # 方法二：
    # p = Coder()
    # Coder.programme = programme
    # print(Coder.programme('Java'))
    # print(p.duty())

    # 方法三：静态方法
    p = Coder()
    Coder.programme = programme
    print(Coder.programme('Java'))
    print(p.programme('Golang'))
    print(p.duty())

迪米特原则: 一个对象应该对其他对象保持最少的了解。

• 问题由来：类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。

• 解决方案：尽量降低类与类之间的耦合。

• 软件编程的总的原则：低耦合，高内聚。无论是面向过程编程还是面向对象编程，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。低耦合的优点不言而喻，要做到低耦合，正是迪米特法则要去完成的。

• 迪米特法则又叫最少知道原则，最早是在1987年由美国Northeastern University的Ian Holland提出。通俗的来讲，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的公共方法，不对外泄漏任何信息。迪米特法则还有一个更简单的定义：只与直接的朋友通信。首先来解释一下什么是直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、组合、聚合等。其中，我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。

开闭原则：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭

• 不要改你以前写的代码，你应该加一些代码去扩展原来的功能，来实现新的需求。好处很好理解，改原来的代码很容易影响原来的功能，特别是接手别人的代码，不理解原先业务场景的情况下。