Python 创建一个类，通过自定义方法进行矩阵乘法运算（保姆级教程）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在编程领域，矩阵运算是一项基础且重要的技能，尤其在数据科学、机器学习和算法开发中应用广泛。Python 作为一门简洁高效的语言，提供了丰富的工具库（如 NumPy）来处理这类运算。然而，对于编程初学者而言，直接使用现成库可能难以理解底层逻辑。因此，通过自定义 Python 类实现矩阵乘法运算，既能帮助开发者掌握面向对象编程的核心思想，又能深入理解矩阵运算的数学原理。本文将从零开始，逐步讲解如何通过 Python 类实现这一功能，并通过案例演示和代码解析，帮助读者构建系统化的知识体系。

矩阵乘法的基本概念与数学原理

在深入代码实现之前，我们先回顾矩阵乘法的核心数学原理。矩阵乘法并非简单的元素相乘，而是通过行与列的点积运算来完成。例如，一个 m×n 的矩阵 A 与一个 n×p 的矩阵 B 相乘，得到的将是 m×p 的矩阵 C。每个元素 C[i][j] 的计算方式为：
C[i][j] = A 的第 i 行与 B 的第 j 列对应元素的乘积之和。

形象比喻：可以将矩阵乘法想象为“快递运输网络”——矩阵 A 的行代表从不同仓库（行索引）出发的包裹数量，矩阵 B 的列代表不同运输路线（列索引）的运输能力。最终结果矩阵 C 的每个元素则表示从仓库 i 经过路线 j 到达终点的总包裹量。这种分步叠加的逻辑，正是矩阵乘法的核心思想。

通过 Python 类封装矩阵对象

为了实现矩阵乘法，我们需要先创建一个能够存储矩阵数据并支持运算的 Python 类。类的结构设计应包含以下关键部分：

1. 初始化方法：用于接收并存储矩阵的二维列表数据；
2. 乘法运算方法：重载 __mul__ 运算符，实现矩阵相乘的逻辑；
3. 验证方法：确保参与运算的矩阵维度符合数学规则。

类的初始化与数据验证

class Matrix:
    def __init__(self, data):
        # 检查输入是否为二维列表
        if not isinstance(data, list) or not all(isinstance(row, list) for row in data):
            raise ValueError("Input must be a 2D list")
        
        # 检查每行长度一致
        row_length = len(data[0])
        for row in data:
            if len(row) != row_length:
                raise ValueError("All rows must have the same length")
        
        self.data = data
        self.rows = len(data)
        self.cols = row_length

关键点解析：

• 类型检查：通过 isinstance() 确保输入是二维列表，避免其他类型引发错误；
• 维度验证：确保矩阵的行长度一致，这是矩阵运算的基础条件；
• 属性存储：将数据和维度信息（如 rows、cols）存储为类的属性，供后续方法调用。

实现矩阵乘法的核心逻辑

矩阵乘法的实现需要满足两个条件：

1. 维度兼容性：第一个矩阵的列数必须等于第二个矩阵的行数；
2. 逐元素计算：通过嵌套循环遍历行和列，计算每个结果元素的值。

重载乘法运算符 __mul__

    def __mul__(self, other):
        # 验证 other 是否为 Matrix 类型
        if not isinstance(other, Matrix):
            raise TypeError("Multiplication only allowed between two Matrix instances")
        
        # 检查维度是否兼容
        if self.cols != other.rows:
            raise ValueError(f"Columns of first matrix ({self.cols}) must match rows of second ({other.rows})")
        
        # 初始化结果矩阵
        result_data = []
        for i in range(self.rows):
            new_row = []
            for j in range(other.cols):
                # 计算第 i 行与第 j 列的点积
                dot_product = sum(
                    self.data[i][k] * other.data[k][j] 
                    for k in range(self.cols)
                )
                new_row.append(dot_product)
            result_data.append(new_row)
        
        return Matrix(result_data)

核心步骤解析：

• 类型检查：确保操作对象是另一个 Matrix 实例；
• 维度验证：通过 self.cols 和 other.rows 比较，避免无效运算；
• 点积计算：使用列表推导式和 sum() 函数，逐元素计算并累加乘积；
• 返回新对象：将计算结果包装为新的 Matrix 实例，保持类的封装性。

完整代码与案例演示

以下是完整的 Matrix 类代码，包含初始化、乘法运算和辅助方法：

class Matrix:
    def __init__(self, data):
        if not isinstance(data, list) or not all(isinstance(row, list) for row in data):
            raise ValueError("Input must be a 2D list")
        row_length = len(data[0])
        for row in data:
            if len(row) != row_length:
                raise ValueError("All rows must have the same length")
        self.data = data
        self.rows = len(data)
        self.cols = row_length

    def __mul__(self, other):
        if not isinstance(other, Matrix):
            raise TypeError("Multiplication only allowed between two Matrix instances")
        if self.cols != other.rows:
            raise ValueError(f"Columns of first matrix ({self.cols}) must match rows of second ({other.rows})")
        result_data = []
        for i in range(self.rows):
            new_row = []
            for j in range(other.cols):
                dot_product = sum(
                    self.data[i][k] * other.data[k][j] 
                    for k in range(self.cols)
                )
                new_row.append(round(dot_product, 2))  # 保留两位小数
            result_data.append(new_row)
        return Matrix(result_data)

    def __repr__(self):
        return f"Matrix({self.data})"

案例演示：2×2 矩阵与 2×3 矩阵相乘

A = Matrix([[1, 2], [3, 4]])

B = Matrix([[5, 6, 7], [8, 9, 10]])

result = A * B

print(result)  # 输出结果应为 2×3 矩阵

验证过程：

• 矩阵 A 的列数为 2，矩阵 B 的行数为 2，满足运算条件；
• 结果矩阵的行数由 A 的行数（2）决定，列数由 B 的列数（3）决定；
• 第一个元素的计算为：1×5 + 2×8 = 5 + 16 = 21，与输出一致。

性能优化与扩展思路

当前实现的局限性

虽然上述代码能完成基本运算，但在处理大规模矩阵时可能存在性能问题。例如，嵌套循环的计算复杂度为 O(n³)，当维度增大时，运算时间会显著增加。

优化方向

1. 向量化运算：利用 Python 的 numpy 库，通过 numpy.dot() 或 @ 运算符实现高效计算；
2. 并行计算：使用多线程或分布式计算框架（如 Dask）分块处理大矩阵；
3. 缓存中间结果：对重复计算的点积进行缓存，减少冗余计算。

与 NumPy 的对比

以下表格对比了手动实现与 NumPy 的性能差异（测试环境：矩阵维度 100×100）：

结论：对于实际生产环境，建议优先使用成熟的第三方库。但手动实现能帮助开发者深入理解矩阵运算的底层逻辑，这对算法优化和自定义扩展（如实现特殊约束的矩阵运算）至关重要。

结论

通过本文的讲解，我们完成了以下目标：

1. 掌握 Python 类的封装和运算符重载机制；
2. 理解矩阵乘法的数学原理与实现逻辑；
3. 通过案例验证代码的正确性与功能完整性；
4. 分析手动实现与库函数的优缺点，明确实际应用场景。

对于编程初学者，建议从简单案例入手，逐步增加矩阵维度和运算复杂度；对于中级开发者，可尝试将本文代码扩展为支持加法、转置等运算的完整矩阵类。通过实践，不仅能提升 Python 编程能力，还能为后续学习机器学习、图像处理等进阶领域奠定扎实基础。

最后，我们鼓励读者将本文的代码作为起点，尝试以下扩展任务：

• 添加矩阵加法、转置方法；
• 实现基于向量化操作的优化版本；
• 设计单元测试用例，验证代码的鲁棒性。

通过持续实践，您将更深刻地理解如何通过 Python 类实现复杂运算，并为未来的技术挑战做好准备。