什么是矩阵？

在深入研究之前，让我们了解一下矩阵是什么：它是一个按行和列排列的数字的矩形数组。在 Python 中，我们通常使用嵌套列表来表示矩阵，其中每个内部列表代表一行。

使用列表创建基本矩阵

让我们从创建矩阵的最简单方法开始：

# Method 1: Using list comprehension to create a 3x3 matrix of zeros
matrix = [[0 for _ in range(3)] for _ in range(3)]
print(matrix)  # Output: [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

让我们一步一步地分解一下：
1. 外部的 'for _ in range（3）' 创建三行
2. 内部的 'for _ in range（3）' 在每行中创建三列
3. “0”是我们在每个单元格中输入的值
4. 我们使用 '_' 作为变量名称，因为我们没有使用 loop 变量 — 我们只希望循环重复

以下是创建具有特定值的矩阵的另一种方法：

# Method 2: Creating a matrix by explicitly listing values
matrix = [
    [1, 2, 3],  # First row
    [4, 5, 6],  # Second row
    [7, 8, 9]   # Third row
]

# Accessing elements
print(matrix[0][1])  # Output: 2 (row 0, column 1)

当我们访问 'matrix[0][1]' 时：
1. 'matrix[0]' 获取第一行 '[1， 2， 3]' （记住 Python 使用从 0 开始的索引）
2. '[1]' 然后从该行获取第二个元素
3. 所以 'matrix[0][1]' 得到值 2

创建专用矩阵

让我们看看如何创建具有特定模式的矩阵：

def create_identity_matrix(size):
    """
    Create an identity matrix of given size.
    An identity matrix has 1s on the diagonal and 0s everywhere else.
    """
    # This creates a size x size matrix
    return [[1 if i == j else 0 for j in range(size)] 
            for i in range(size)]

def create_triangular_matrix(size, upper=True):
    """
    Create an upper or lower triangular matrix of given size.
    Upper triangular: elements below diagonal are False
    Lower triangular: elements above diagonal are False
    """
    if upper:
        # For upper triangular, we set True when column >= row
        return [[j >= i for j in range(size)] 
                for i in range(size)]
    # For lower triangular, we set True when column <= row
    return [[j <= i for j in range(size)] 
            for i in range(size)]

# Let's see how these work
identity = create_identity_matrix(3)
print("Identity Matrix:")
for row in identity:
    print(row)
# Output:
# [1, 0, 0]
# [0, 1, 0]
# [0, 0, 1]

让我们详细研究一下 'create_identity_matrix'：
1. 外部循环 'for i in range（size）' 创建每一行
2. 内部循环 'for j in range（size）' 创建每一列
3. '1 if i == j else 0' 表示：
- 当行号等于列号（对角线）时输入 1
— 将 0 放在其他任何地方
4. 这为我们提供了独特的单位矩阵模式，对角线上有 1

对于三角矩阵：
1. 上三角形中的 'j >= i' 表示：
— 当列号大于或等于行号时，将 True
— 这将创建上三角形模式，其中对角线上方（包括对角线）的所有内容均为 True
2. 'j <= i' 在下三角形中的意思是：
— 当列号小于或等于行号时，将 True
— 这将创建下三角形模式，其中低于对角线（包括对角线）的所有内容均为 True

矩阵运算

以下是执行基本矩阵运算的方法：

def matrix_addition(matrix1, matrix2):
    """
    Add two matrices of the same size.
    Returns a new matrix where each element is the sum of 
    corresponding elements from the input matrices.
    """
    # First, verify matrices have the same dimensions
    if len(matrix1) != len(matrix2) or len(matrix1[0]) != len(matrix2[0]):
        raise ValueError("Matrices must have the same dimensions")
    
    # Get dimensions
    rows = len(matrix1)
    cols = len(matrix1[0])
    
    # Create empty result matrix
    result = [[0 for _ in range(cols)] for _ in range(rows)]
    
    # Add corresponding elements
    for i in range(rows):
        for j in range(cols):
            result[i][j] = matrix1[i][j] + matrix2[i][j]
    
    return result

# Let's break down what happens with an example:
matrix1 = [[1, 2], [3, 4]]
matrix2 = [[5, 6], [7, 8]]

sum_matrix = matrix_addition(matrix1, matrix2)
print("Matrix Addition Result:")
for row in sum_matrix:
    print(row)
# Output:
# [6, 8]    # (1+5, 2+6)
# [10, 12]  # (3+7, 4+8)

让我们一步一步地研究 'matrix_addition'：
1. 首先，我们检查矩阵的大小是否相同：
— 'len（matrix1）' 获取行数
— 'len（matrix1[0]）' 获取列数
— 如果其中任何一个与 matrix2 不匹配，则无法添加它们

2. 我们创建一个相同大小的结果矩阵：
— '[[0 for _ in range（cols）] for _ in range（rows）]' 创建一个填充为零的矩阵
— 这为我们提供了一个存储结果的地方

3. 嵌套循环：
— 外部循环 'for i in range（rows）' 遍历每一行
— 内部循环 'for j in range（cols）' 遍历每一列
— 在每个位置 '[i][j]' 处，我们添加两个矩阵中的相应元素

4. 当我们添加 [[1， 2]， [3， 4]] 和 [[5， 6]， [7， 8]] 时：
— 位置 [0][0]： 1 + 5 = 6
— 位置 [0][1]： 2 + 6 = 8
— 位置 [1][0]：3 + 7 = 10
— 位置 [1][1]：4 + 8 = 12