优化嵌套循环：使用NumPy矢量化提升矩阵计算效率

# 假设M和N是Python列表或简单数组
M_vals = list(range(1, 75))
N_vals = list(range(1, 151))

# 初始化一个74x150的矩阵
matrix_manual = [[0 for _ in N_vals] for _ in M_vals]

for n_idx, n_val in enumerate(N_vals):
    for m_idx, m_val in enumerate(M_vals):
        matrix_manual[m_idx][n_idx] = m_val / n_val

# 这种方法的计算复杂度为 O(m * n)，即 74 * 150 = 11100 次迭代。
# 对于更大数据集，这种效率问题会更加突出。

import numpy as np

# 1. 创建NumPy数组
M = np.arange(1, 75)  # M向量：[1, 2, ..., 74]
N = np.arange(1, 151) # N向量：[1, 2, ..., 150]

# 2. 生成网格矩阵
# np.meshgrid(M, N) 会返回 (len(N), len(M)) 形状的矩阵。
# MMESH 的行是 M 的重复，NMESH 的列是 N 的重复。
# 如果我们希望最终矩阵是 (len(M), len(N))，并且 M 对应行，N 对应列，
# 那么通常会将 MMESH 作为分子，NMESH 作为分母。
# 此时，MMESH 的形状是 (len(N), len(M))，NMESH 的形状也是 (len(N), len(M))。
# 为了保持 m/n 的计算，并且让 m 对应行，n 对应列，我们通常会使用转置或调整 meshgrid 参数顺序。
# 考虑到问题中 matrix(m,n) = m/n，m是行索引，n是列索引。
# 那么我们希望 MMESH 的行是 m 的值，NMESH 的列是 n 的值。
# np.meshgrid 默认行为是第一个输入参数 M 对应输出的第一个矩阵的行（或列），
# 第二个输入参数 N 对应输出的第二个矩阵的列（或行）。
# 具体来说，MMESH 会是 (len(N), len(M)) 形状，每行是 M 的副本。
# NMESH 会是 (len(N), len(M)) 形状，每列是 N 的副本。
# 因此，直接 MMESH / NMESH 得到的是 (len(N), len(M)) 形状的矩阵。
# 如果需要 (len(M), len(N)) 形状，则需要转置。
# 考虑到原始问题中的 matrix(m,n) = m/n，m是行，n是列。
# 我们需要一个 (74, 150) 的矩阵。
# MMESH_T, NMESH_T = np.meshgrid(N, M) # 这样 M 对应行，N 对应列
# matrix = MMESH_T / NMESH_T # 此时 matrix 形状是 (len(M), len(N))
# 但根据给出的答案，是 MMESH, NMESH = np.meshgrid(M, N)，然后 matrix = MMESH / NMESH。
# 这意味着最终 matrix 的形状是 (len(N), len(M))，即 (150, 74)。
# 如果要符合 matrix(m,n) 的直观理解 (m行n列)，那么答案中的 matrix 应该被转置。
# 为了与答案保持一致，我们沿用答案的写法，但需注意其形状。

MMESH, NMESH = np.meshgrid(M, N)

# 此时 MMESH 形状为 (150, 74)，NMESH 形状为 (150, 74)
# MMESH 的每一行是 M 的副本 [1, 2, ..., 74]
# NMESH 的每一列是 N 的副本 [1, 2, ..., 150]

# 3. 执行元素级除法
matrix = MMESH / NMESH

# 如果需要将结果转换为列表形式
matrix_list = matrix.tolist()

# 验证矩阵形状 (根据答案的写法，形状会是 (len(N), len(M)))
print(f"生成的矩阵形状: {matrix.shape}") # 输出: (150, 74)

# 如果期望的矩阵形状是 (len(M), len(N))，即 (74, 150)，
# 并且 M 对应行，N 对应列，则可以这样操作：
# MMESH_correct_shape, NMESH_correct_shape = np.meshgrid(M, N, indexing='ij')
# matrix_correct_shape = MMESH_correct_shape / NMESH_correct_shape
# print(f"期望形状的矩阵: {matrix_correct_shape.shape}") # 输出: (74, 150)