2024年Python 中的 SOLID 原则_正交四原则和solid原则 python(1)，斗鱼直播Python开发二面被刷

感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：

①　2000多本Python电子书（主流和经典的书籍应该都有了）

②　Python标准库资料（最全中文版）

③　项目源码（四五十个有趣且经典的练手项目及源码）

④　Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）

⑤ Python学习路线图（告别不入流的学习）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

import json

class Page():
def __init__(self, title):
self._title = title

def get\_title(self):
    return self._title

def set\_title(self, title):
    self._title = title

def get\_page(self):
    return [self._title]

class JsonPageFormatter():
def format_json(page: Page):
return json.dumps(page.get_page())

这样做意味着如果我们想创建一个 XML 格式，我们只需添加一个名为XmlPageFormatter的类并编写一些简单的代码来输出 XML。我们现在只有一个理由来更改Page类。


### 开闭原则


在开闭原则中，类应该 对扩展开放，对修改关闭。本质上意味着类应该被扩展以改变功能，而不是被改变成其他东西。


以下面两个类为例。

class Rectangle():
def __init__(self, width, height):
self._width = width
self._height = height

def get\_width(self):
    return self._width

def set\_width(self, width):
    self._width = width

def get\_height(self):
    return self._height

def set\_height(self, height):
    self._height = height

class Board():
@property
def rectangles(self):
return self._rectangles

@rectangles.setter
def rectangles(self, value):
    self._rectangles = value  

def calculateArea(self):
    area = 0
    for item in self.rectangles:
        area += item.get_height() \* item.get_width()
    return area

我们有一个包含矩形数据的Rectangle类，以及一个用作Rectangle对象集合的Board类。使用此设置，我们可以通过循环遍历rectangles集合属性中的项目并计算它们的面积来轻松找出板的面积。


此设置的问题在于我们受到可以传递给Board类的对象类型的限制。例如，如果我们想将一个Circle对象传递给Board类，我们需要编写条件语句和代码来检测和计算Board的面积。


解决这个问题的正确方法是将面积计算代码移到形状类中，并让所有形状类都扩展一个Shape接口。我们现在可以创建一个Rectangle和Circle形状类，它们将在被要求时计算它们的面积。

import math

class ShapeMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))

def \_\_subclasscheck\_\_(self, subclass):
    return (hasattr(subclass, 'area') and callable(subclass.area))

class ShapeInterface(metaclass=ShapeMeta):
pass

class Rectangle(ShapeInterface):
def __init__(self, width, height):
self._width = width
self._height = height

def get\_width(self):
    return self._width

def set\_width(self, width):
    self._width = width

def get\_height(self):
    return self._height

def set\_height(self, height):
    self._height = height

def area(self):
    return self.get_width() \* self.get_height()

class Circle(ShapeInterface):
def __init__(self, radius):
self._radius = radius

def get\_radius(self):
    return self._radius

def set\_radius(self, radius):
    self._radius = radius

def area(self):
    return self.get_radius() \* self.get_radius() \* math.pi

现在 可以重新设计Board类，使其不关心传递给它的形状类型，只要它们实现 area() 方法即可。

class Board():
def __init__(self, shapes):
self._shapes = shapes

def calculateArea(self):
    area = 0
    for shape in self._shapes:
        area += shape.area()
    return area

我们现在已经设置了这些对象，这意味着如果我们有不同类型的对象，我们不需要改变Board类。我们只是创建实现Shape的对象，并以与其他类相同的方式将其传递到集合中。


### 里氏替换原则


由 Barbara Liskov 在 1987 年创建，它指出对象应该可以被它们的子类型替换而不改变程序的工作方式。换句话说，派生类必须可以替代它们的基类而不会导致错误。


下面的代码定义了一个Rectangle类，我们可以用它来创建和计算矩形的面积。

class Rectangle():
def __init__(self, width, height):
self._width = width
self._height = height

def get\_width(self):
    return self._width

def set\_width(self, width):
    self._width = width

def get\_height(self):
    return self._height

def set\_height(self, height):
    self._height = height

def area(self):
    return self.get\_width() \* self.get\_height()

使用它，我们可以将其扩展为Square类。因为正方形与矩形略有不同，我们需要重写一些代码以允许正方形正确存在。

class Square(Rectangle):
def __init__(self, width):
self._width = width
self._height = width

def get\_width(self):
    return self._width

def set\_width(self, width):
    self._width = width
    self._height = width

def get\_height(self):
    return self._height

def set\_height(self, height):
    self._height = height
    self._width = height

这看起来不错，但最终正方形不是矩形，因此我们添加了代码来强制这种情况起作用。


我读过的一个很好的类比是考虑类代表的鸭子和橡皮鸭。尽管可以将 Duck 类扩展为 Rubber Duck 类，但我们需要重写许多 Duck 功能以适应 Rubber Duck。例如，鸭子嘎嘎叫，但橡皮鸭不叫（好吧，也许它会吱吱叫），鸭子是活的，但橡皮鸭不是。


覆盖类中的大量代码以适应特定情况可能会导致维护问题。您为覆盖特定条件而添加的代码越多，您的代码就会变得越脆弱。


矩形与正方形情况的一种解决方案是创建一个名为Quadrilateral的接口，并在单独的Rectangle和Square 类中实现它。在这种情况下，我们允许类负责它们自己的数据，但强制要求某些方法足迹可用。

class QuadrilateralMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))

def \_\_subclasscheck\_\_(self, subclass):
    return (hasattr(subclass, 'area') and callable(subclass.area)) \
      and (hasattr(subclass, 'get\_height') and callable(subclass.get_height)) \
      and (hasattr(subclass, 'get\_width') and callable(subclass.get_width)) \

class QuadrilateralInterface(metaclass=QuadrilateralMeta):
pass

class Rectangle(QuadrilateralInterface):
pass

class Square(QuadrilateralInterface):
pass

这里的底线是，如果你发现你覆盖了很多代码，那么你的架构可能是错误的，你应该考虑 Liskov 替换原则。


### 接口隔离原则


这表明许多特定于客户端的接口优于一个通用接口。换句话说，不应强制类实现它们不使用的接口。


让我们以Worker接口为例。这定义了几种不同的方法，可以应用于典型开发机构的工作人员。

class WorkerMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))

def \_\_subclasscheck\_\_(self, subclass):
    return (hasattr(subclass, 'take\_break') and callable(subclass.take_break)) \
      and (hasattr(subclass, 'write\_code') and callable(subclass.write_code)) \
      and (hasattr(subclass, 'call\_client') and callable(subclass.call_client)) \
      and (hasattr(subclass, 'get\_paid') and callable(subclass.get_paid))

class WorkerInterface(metaclass=WorkerMeta):
pass

问题是因为这个接口太通用了，我们不得不在实现这个接口的类中创建方法来适应这个接口。


例如，如果我们创建一个Manager类，那么我们将被迫实现一个 write\_code() 方法，因为这是接口所需要的。因为经理通常不编写代码，所以我们实际上无法在此方法中执行任何操作，因此我们只返回 false。

class Manager(WorkerInterface):
def write_code(self):
pass

此外，如果我们有一个实现Worker的Developer类，那么我们将被迫实现一个 call\_client() 方法，因为这是接口所需要的。

class Developer(WorkerInterface):
def call_client(self):
pass

拥有一个臃肿的接口意味着必须实现什么都不做的方法。


正确的解决方案是将我们的界面拆分成单独的部分，每个部分处理特定的功能。在这里，我们从我们的通用Worker接口中分离出Coder和ClientFacer接口。

class WorkerMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))

def \_\_subclasscheck\_\_(self, subclass):
    return (hasattr(subclass, 'take\_break') and callable(subclass.take_break)) \
      and (hasattr(subclass, 'get\_paid') and callable(subclass.get_paid))

class WorkerInterface(metaclass=WorkerMeta):
pass

class ClientFacerMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))

def \_\_subclasscheck\_\_(self, subclass):
    return (hasattr(subclass, 'call\_client') and callable(subclass.call_client))

class ClientFacerInterface(metaclass=ClientFacerMeta):
pass

class CoderMeta(type):
def __instancecheck__(self, instance):
return self.subclasscheck(type(instance))

如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费学习大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！