坚实的原理 - python-DEV365 开发者社区

可靠的原理是有关如何为生产就绪软件编写代码的一组说明。每个软件开发人员都必须了解这些关键原则以开发任何应用程序，固体代表

s - 单一责任原则
o - 开放/关闭原理
l - Liskov的替代原则
i - 接口隔离原理
d - 依赖性反转原理

单一责任原则：

班级应该对处理流程负责，如果有任何更改的东西，它不应影响其他类别。单个职责原则的主要目的是设计具有彼此相关的属性和方法的软件组件，并且不应处理更多的东西；班级越小，

如果所有方法彼此耦合，它都可以具有任何数量的方法；否则，我们需要将这些方法分为单独的类。

Class Game:

    def initializer_method(self):
        pass

    def draw_method(self):
        pass

    def running_method(self):
        pass

    def endCond_method(self):
        pass

在上面的示例中，我们必须将游戏类中的所有方法解除，因为其中一些（绘制，运行）彼此无关。

开放原则：

开放/封闭的原理全部要开放，但要进行修改。
它与单个责任原则是相关的。我们正在编写的代码应该能够添加额外的功能而不会破坏现有代码。

def read_file(file):
    return open(file, "r").read()

def get_text_from_url(URL):
    return text

def count_word_occurrences(word, content):
    counter = 0
    for e in content.split():
        if word.lower() == e.lower():
            counter += 1
    return counter

def csv_reader(file):
    return text

在上面的示例中，我们通过阅读文件和网络来计算文件中的单词数。当我们想从另一个资源（例如CSV文件）读取文件时会发生什么？我们可以创建一个函数来读取CSV数据并将上述文本返回到Count_word函数。

Liskov的替代原则：

它指出，父类的对象应在不破坏现有代码/应用程序的情况下替换为其子类的对象。

例如，考虑以下一个混音器课程正在继承厨房父级，如果我们想添加另一个必须从厨房课中继承的欧文，那么我们可以单独使用这些方法，但我们必须使用使用父类中的所有方法。

class kitchen():

    def on():
        pass

    def off():
        pass

    def set_level():
        pass

class mixer(Kitchen):
    def on():
        pass

    def off():
        pass

    def set_level():
        pass

class mixer(Kitchen):

    def on():
        pass

    def off():
        pass

为了克服这一点，我们可以创建另一个类来设置混音器的级别，我们可以继承该类并使用其方法。

class kitchen():
    def on():
        pass
    def off():
        pass

class mixer_level(kitchen):
    def set_level():
        pass

class mixer(mixer_level):
    def on():
        pass
    def off():
        pass
    def set_level():
        pass

class mixer(Kitchen):
    def on():
        pass
    def off():
        pass

界面隔离原理：

类或函数不应具有单个方法中的所有功能；相反，它们应该分开。

在下面的示例中，我们强制该函数读取来自URL和文件的数据；但是，如果调用此功能的类不需要从URL获取数据怎么办？在这种情况下，我们必须为该功能创建一个单独的类。如果课程需要从两者中读取数据，则可以初始化类的对象并调用主要功能。
```
def get_text_from_url(URL):
    pass

def count_word_occurrences(word, content):
    file_data=open(file, "r").read()
    url_data = get_text_from_url(URL)
    counter = 0
    for e in content.split():
        if word.lower() == e.lower():
            counter += 1
    return counter
```

依赖性反转：

该原则指出，高级模块不应取决于低级模块。相反，两者都应取决于抽象。
在下面的示例中，食物，生产就像基类一样，如果我们想添加另一种食物，我们可以创建另一个班级并从食物类中继承而不会破坏它。这样，低水平和高水平的班级取决于抽象类食物。

```
class FOOD:
    def bake(self): 
        pass
    def eat(self): 
        pass

class Bread(FOOD):
    def bake(self):
        print("Bread was baked")
    def eat(self):
        print("Bread was eaten")


class Production:
    def __init__(self, food):
        self.food = food 

    def produce(self):
        self. food.bake() 

    def consume(self):
        self. food.eat()  

ProduceBread = Production(Bread())
```

单一责任原则：

开放原则：

Liskov的替代原则：

界面隔离原理：

依赖性反转：

参考