代码的优化以及设计模式的引入

南鸢T

已于 2024-05-15 11:06:08 修改

阅读量907

点赞数 29

文章标签： python 设计模式

于 2024-05-15 11:04:44 首次发布

本文链接：https://blog.csdn.net/qq_56447863/article/details/138896045

版权

代码的优化和升级是为了提高程序的性能、可维护性和可扩展性，实现以下目标：

提高性能：通过优化代码，可以减少程序的执行时间和内存占用，提高系统的响应速度和效率，更好地满足用户需求。
提高可维护性：优化代码可以使程序更加清晰、易读、易理解，减少代码的冗余和复杂度，提高代码的可读性和可维护性，方便后续的维护和修改。
提高可扩展性：通过优化代码，可以使程序更加模块化、解耦合，降低各个模块之间的依赖关系，使系统更容易扩展和修改，适应不同的需求变化。
减少资源消耗：优化代码可以减少程序的资源占用，如内存、CPU等，提高系统的效率，减少资源的浪费，降低运行成本。
改进用户体验：通过优化代码，提高程序的性能和稳定性，减少卡顿和崩溃现象，提升用户的使用体验，增加用户的满意度。

下面我们以一个简单的计算器设计为例，介绍代码优化的方法

Exit_Flag = 'N'
while Exit_Flag == 'N'or Exit_Flag == 'n':
    num1 = float(input("请输入第一个数："))
    operator = input("请输入运算符号（+ - * /）：")
    num2 = float(input("请输入第二个数："))

    result = 0
    if operator == '+':
        result = num1 + num2
    elif operator == '-':
        result = num1 - num2
    elif operator == '*':
        result = num1 * num2
    elif operator == '/':
        result = num1 / num2

    print('运算结果为：',result)
    Exit_Flag = input('是否退出计算器模式：Y（退出）/ N（继续）：')

此段代码中，我们实现了一个简单的计算器功能，但存在以下不足之处：

在计算结果时，没有处理除数为0的情况。当用户输入除数为0时，程序会抛出异常。
当用户输入的运算符号不是加、减、乘、除中的一个时，程序没有给出提示。

下面对这段代码进行优化：

1.函数优化

函数的引入可以使项目模块化，这种编程方式有许多优点，包括：

可维护性：模块化的代码更易于理解和维护，因为每个模块都专注于特定的功能。
重用性：可以在不同的项目中重复使用模块，避免重复编写相似的代码。
可扩展性：可以根据需要添加新的模块或替换现有模块，以满足不断变化的需求。

def calc(num1, num2, operator):
    if operator == '+':
        return num1 + num2
    elif operator == '-':
        return num1 - num2
    elif operator == '*':
        return num1 * num2
    elif operator == '/':
        return num1 / num2


# 检查输入的运算符规范性函数
def check_operator(operator):
    if operator == '+' or operator == '-' or operator == '*' or operator == '/':
        return True
    else:
        return False


# 录入运算符号的处理函数
def input_operator():
    a = input('请输入运算符号（+ - * /）：')
    while True:
        if check_operator(a):
            return a
        else:
            a = input('运算符不正确！请重新输入（+ - * /）：')


# 输入的第二个数的处理函数
def input_num2(operator):
    num2 = float(input('请输入第二个数：'))
    while True:
        if operator == '/' and num2 == 0:
            num2 = float(input('除数不能为0，请重新输入第二个数：'))
        else:
            return num2


def run():
    Exit_Flag = 'N'
    while Exit_Flag == 'N' or Exit_Flag == 'n':
        # 输入第一个数
        Input_num1 = float(input('请输入第一个数：'))
        # 输入运算符
        Input_operator = input_operator()
        # 输入第二个数
        Input_num2 = input_num2(Input_operator)
        # 进行运算并打印出运算结果
        Result = calc(Input_num1, Input_num2, Input_operator)
        print('运算结果为：', Result)
        Exit_Flag = input('是否退出计算器模式：Y（退出）/ N（继续）：')


if __name__ == '__main__':
    run()

通过引入函数，将已有代码的相关功能进行模块化，方便后期对代码的优化以及功能的增加；同时在此段代码中，我们对代码的不足进行了处理，添加了异常处理的模块，并对运算符进行了判断，避免了程序的异常终止和非法输入，提高了代码的健壮性。

2.类和对象

面向对象将类中的信息进行封装，即将属性等和函数绑在一起。使用面向对象思想进行开发有以下优点：

易维护；采用面向对象思想设计的结构，可读性高，由于继承的存在，即使改变需求，那么维护也只是在局部模块，所以维护起来是非常方便和较低成本的。
质量高；在设计时，可重用现有的，在以前的项目的领域中已被测试过的类使系统满足业务需求并具有较高的质量。
效率高；在软件开发时，根据设计的需要对现实世界的事物进行抽象，产生类。使用这样的方法解决问题，接近于日常生活和自然的思考方式，势必提高软件开发的效率和质量。
易扩展；由于继承、封装、多态的特性，自然设计出高内聚、低耦合的系统结构，使得系统更灵活、更容易扩展，而且成本较低。

class Calculator:
    def __init__(self):
        self.num1 = None
        self.num2 = None
        self.operator = None

    def calc(self, num1, num2, operator):
        operator_dict = {
            '+': num1 + num2,
            '-': num1 - num2,
            '*': num1 * num2,
            '/': num1 / num2
        }

        return operator_dict.get(operator, None)

    def check_operator(self, operator):
        return operator in '+-*/'

    def input_operator(self):
        a = input('请输入运算符号（+ - * /）：')
        while not self.check_operator(a):
            a = input('运算符不正确！请重新输入（+ - * /）：')
        return a

    def input_num2(self, operator):
        num2 = float(input('请输入第二个数：'))
        while operator == '/' and num2 == 0:
            num2 = float(input('除数不能为0，请重新输入第二个数：'))
        return num2

    def run(self):
        exit_flag = 'N'
        while exit_flag == 'N' or exit_flag == 'n':
            self.num1 = float(input('请输入第一个数：'))
            self.operator = self.input_operator()
            self.num2 = self.input_num2(self.operator)
            result = self.calc(self.num1, self.num2, self.operator)
            print('运算结果为：', result)
            exit_flag = input('是否退出计算器模式：Y（退出）/ N（继续）：')


if __name__ == '__main__':
    calculator = Calculator()
    calculator.run()

在原有基础上，我们引入了类和对象，同时对一些模块进行了优化，利用字典对计算模块进行了重构。

    def calc(self, num1, num2, operator):
        operator_dict = {
            '+': num1 + num2,
            '-': num1 - num2,
            '*': num1 * num2,
            '/': num1 / num2
        }

        return operator_dict.get(operator, None)

3.设计模式的引入

创建型模式：描述了“怎样创建对象”，主要特点是“将对象的创建与使用分离”。

（1）单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
（2）原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
（3）工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
（4）抽象工厂（Abstract Factory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
（5）建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

结构型模式：描述了如何将类或对象按某种布局组成更大的结构。

（1）代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象(真实对象)，从而限制、增强或修改该对象的一些特性。
（2）适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
（3）桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。
（4）装饰（Decorator）模式：动态的给对象增加一些职责，即增加其额外的功能。
（5）外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
（6）享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
（7）组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。

行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。

（1）模板方法（Template Method）模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
（2）策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。
（3）命令（Command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
（4）职责链（Chain of Responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。
（5）状态（State）模式：允许一个对象在其内部状态发生改变时改变其行为能力。
（6）观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。
（7）中介者（Mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。
（8）迭代器（Iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
（9）访问者（Visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。
（10）备忘录（Memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。
（11）解释器（Interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

使用设计模式优点:

可以提高程序员的思维能力、编程能力和设计能力。
使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

我们就抽象工厂模式对代码进行优化：

from abc import abstractmethod, ABCMeta


class CalculatorFactory:
    @staticmethod
    def create_calculator():
        return Calculator()


class CalculatorFun(metaclass=ABCMeta):
    def __init__(self):
        self.num1 = None
        self.num2 = None
        self.operator = None

    @abstractmethod
    def calc(self, num1, num2, operator):
        pass

    def check_operator(self, operator):
        return operator in '+-*/'

    def input_operator(self):
        a = input('请输入运算符号（+ - * /）：')
        while not self.check_operator(a):
            a = input('运算符不正确！请重新输入（+ - * /）：')
        return a

    def input_num2(self, operator):
        num2 = float(input('请输入第二个数：'))
        while operator == '/' and num2 == 0:
            num2 = float(input('除数不能为0，请重新输入第二个数：'))
        return num2

    def run(self):
        exit_flag = 'N'
        while exit_flag == 'N' or exit_flag == 'n':
            self.num1 = float(input('请输入第一个数：'))
            self.operator = self.input_operator()
            self.num2 = self.input_num2(self.operator)
            result = self.calc(self.num1, self.num2, self.operator)
            print('运算结果为：', result)
            exit_flag = input('是否退出计算器模式：Y（退出）/ N（继续）：')


class Calculator(CalculatorFun):
    def calc(self, num1, num2, operator):
        operator_dict = {
            '+': num1 + num2,
            '-': num1 - num2,
            '*': num1 * num2,
            '/': num1 / num2
        }
        return operator_dict.get(operator, None)


if __name__ == '__main__':
    calculator = CalculatorFactory.create_calculator()
    calculator.run()

这段代码已经使用了面向对象编程的思想，将计算器相关的属性和方法封装到了Calculator类中。为了进一步优化代码，我们引入工厂模式来创建Calculator类的实例。具体来说，我们可以创建一个CalculatorFactory类，该类提供一个静态方法create_calculator()，该方法返回一Calculator类的实例。在使用Calculator类时，可以直接通过调用CalculatorFactory.create_calculator()来创建一个计算器实例。这样，我们就实现了计算器的工厂模式。这样做的好处是，如果我们需要增加新的计算器类型，只需要修改CalculatorFactory类中的create_calculator()方法即可，这样，我们就可以在不修改Calculator类的情况下，扩展计算器的功能。提高了代码的可扩展性和可维性。