当前位置：首页 > 文章列表 > 文章 > python教程 > 软件开发的坚实原则

软件开发的坚实原则

来源：dev.to 2024-08-01 18:27:51 0浏览收藏

从现在开始，努力学习吧！本文《软件开发的坚实原则》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

软件开发的坚实原则

在软件开发领域，solid 原则是一组五个设计原则，旨在创建健壮、可维护和可扩展的软件系统。这些原则由 robert c. martin（也称为 bob 叔叔）提出，为开发人员提供了遵循的指南，以确保他们的代码库干净且可扩展。在这里，我们将探索每个 solid 原则，并通过 python 示例演示如何实现它们。

1.单一职责原则（srp）

定义：一个类应该只有一个改变的理由，这意味着它应该只有一项工作或职责。

示例：

class order:
    def __init__(self, items):
        self.items = items

    def calculate_total(self):
        return sum(item.price for item in self.items)

class invoiceprinter:
    @staticmethod
    def print_invoice(order):
        print("invoice:")
        for item in order.items:
            print(f"{item.name}: ${item.price}")
        print(f"total: ${order.calculate_total()}")

# usage
class item:
    def __init__(self, name, price):
        self.name = name
        self.price = price

items = [item("apple", 1), item("banana", 2)]
order = order(items)
invoiceprinter.print_invoice(order)

在这个例子中，order类只负责管理订单，而invoiceprinter类负责打印发票。这通过确保每个类都有单一职责来遵守 srp。

2. 开闭原理（ocp）

定义：软件实体应该对扩展开放，对修改关闭。

示例：

class discount:
    def apply(self, total):
        return total

class percentagediscount(discount):
    def __init__(self, percentage):
        self.percentage = percentage

    def apply(self, total):
        return total - (total * self.percentage / 100)

class fixeddiscount(discount):
    def __init__(self, amount):
        self.amount = amount

    def apply(self, total):
        return total - self.amount

def calculate_total(order, discount):
    total = order.calculate_total()
    return discount.apply(total)

# usage
discount = percentagediscount(10)
print(calculate_total(order, discount))

在此示例中，discount 类由 percentagediscount 和 fixdiscount 扩展，无需修改基类，遵循 ocp。

3.里氏替换原理（lsp）

定义：子类型必须可以替换其基本类型，而不改变程序的正确性。

示例：

class bird:
    def fly(self):
        pass

class sparrow(bird):
    def fly(self):
        print("sparrow is flying")

class ostrich(bird):
    def fly(self):
        raise exception("ostrich can't fly")

def make_bird_fly(bird):
    bird.fly()

# usage
sparrow = sparrow()
make_bird_fly(sparrow)

ostrich = ostrich()
try:
    make_bird_fly(ostrich)
except exception as e:
    print(e)

这里，ostrich 违反了 lsp，因为它不能飞，因此它不能替代 bird 基类。

4. 接口隔离原则（isp）

定义：客户端不应该被迫依赖他们不使用的接口。

示例：

from abc import abc, abstractmethod

class printer(abc):
    @abstractmethod
    def print_document(self, document):
        pass

class scanner(abc):
    @abstractmethod
    def scan_document(self, document):
        pass

class multifunctionprinter(printer, scanner):
    def print_document(self, document):
        print(f"printing: {document}")

    def scan_document(self, document):
        print(f"scanning: {document}")

class simpleprinter(printer):
    def print_document(self, document):
        print(f"printing: {document}")

# usage
mfp = multifunctionprinter()
mfp.print_document("report")
mfp.scan_document("report")

printer = simpleprinter()
printer.print_document("report")

在此示例中，multifunctionprinter 实现了 printer 和 scanner 接口，而 simpleprinter 只实现了 printer，遵循 isp。

5. 依赖倒置原则（dip）

定义：高层模块不应该依赖于低层模块。两者都应该依赖于抽象。抽象不应该依赖于细节。细节应该取决于抽象。

示例：

from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def save(self, data):
        pass

class MySQLDatabase(Database):
    def save(self, data):
        print("Saving data to MySQL database")

class MongoDBDatabase(Database):
    def save(self, data):
        print("Saving data to MongoDB database")

class UserService:
    def __init__(self, database: Database):
        self.database = database

    def save_user(self, user_data):
        self.database.save(user_data)

# Usage
mysql_db = MySQLDatabase()
mongo_db = MongoDBDatabase()

user_service = UserService(mysql_db)
user_service.save_user({"name": "John Doe"})

user_service = UserService(mongo_db)
user_service.save_user({"name": "Jane Doe"})

在此示例中，userservice 依赖于数据库抽象，允许灵活性并遵守 dip。