Python 中的 SOLID 原则_正交四原则和solid原则 python(1)

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

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

二、学习软件

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

三、入门学习视频

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

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

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

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

  • 接口隔离原则
  • 依赖倒置原则

我们将依次解析它们。

单一职责原则

这表明一个类应该有单一的责任,但更重要的是,一个类应该只有一个改变的理由。

以名为Page的(简单)类为例。

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]

    def format\_json(self):
        return json.dumps(self.get_page())

此类知道 title 属性并允许通过 get() 方法检索此 title 属性。我们还可以使用此类中名为 format_json() 的方法将页面作为 JSON 字符串返回。这似乎是个好主意,因为类负责自己的格式。

但是,如果我们想要更改 JSON 字符串的输出,或者向类中添加另一种类型的输出,会发生什么情况呢?我们需要更改类以添加另一个方法或更改现有方法以适应。这对于像这样简单的类来说很好,但如果它包含更多属性,那么更改格式将更加复杂。

一个更好的方法是修改Page类,这样它只知道数据是句柄。然后我们创建一个名为JsonPageFormatter的辅助类,用于将Page对象格式化为 JSON。

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))

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

class CoderInterface(metaclass=CoderMeta):


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

**[需要这份系统化学习资料的朋友,可以戳这里获取](https://bbs.csdn.net/topics/618317507)**

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

  • 5
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值