Python矩阵转置的几种实现方法

def transpose_nested_loop(matrix):
    """
    使用嵌套循环实现矩阵转置。
    参数:
        matrix: 二维列表（列表的列表）。
    返回:
        转置后的二维列表。
    """
    # 获取原矩阵的行数和列数
    rows = len(matrix)
    cols = len(matrix[0]) if rows > 0 else 0

    # 初始化一个全零的转置矩阵（行数=原列数，列数=原行数）
    result = [[0 for _ in range(rows)] for _ in range(cols)]

    # 双层循环，进行元素搬运
    for i in range(rows):
        for j in range(cols):
            result[j][i] = matrix[i][j]
    return result

# 示例
original = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = transpose_nested_loop(original)
print(transposed)  # 输出：[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

def transpose_list_comprehension(matrix):
    """
    使用列表推导式实现矩阵转置。
    参数:
        matrix: 二维列表。
    返回:
        转置后的二维列表。
    """
    # 核心的一行代码
    return [[row[i] for row in matrix] for i in range(len(matrix[0]))]

# 示例
original = [[1, 2, 3], [4, 5, 6]]
transposed = transpose_list_comprehension(original)
print(transposed)  # 输出：[[1, 4], [2, 5], [3, 6]]

def transpose_zip(matrix):
    """
    使用zip函数和*操作符实现矩阵转置。
    参数:
        matrix: 二维列表。
    返回:
        转置后的二维列表（列表的列表）。
    """
    return list(map(list, zip(*matrix)))

# 示例
original = [[1, 2, 3], [4, 5, 6]]
transposed = transpose_zip(original)
print(transposed)  # 输出：[[1, 4], [2, 5], [3, 6]]

import numpy as np

# 创建一个NumPy二维数组
matrix_np = np.array([[1, 2, 3],
                      [4, 5, 6],
                      [7, 8, 9]])

# 方法1：使用 .T 属性
transposed_T = matrix_np.T
print("使用 .T 属性：")
print(transposed_T)

# 方法2：使用 transpose() 方法
transposed_method = matrix_np.transpose()
print("\n使用 transpose() 方法：")
print(transposed_method)

# 验证两者结果相同
print(f"\n两者结果是否相同：{np.array_equal(transposed_T, transposed_method)}")

matrix_np = np.array([[1, 2], [3, 4]])
view_T = matrix_np.T  # 这是一个视图
view_T[0, 0] = 99    # 修改视图的第一个元素

print("原矩阵：")
print(matrix_np)  # 输出：[[99  2] [ 3  4]]
print("\n转置视图：")
print(view_T)     # 输出：[[99  3] [ 2  4]]

copy_T = matrix_np.T.copy()
copy_T[0, 0] = -99
print(matrix_np)  # 输出：[[99  2] [ 3  4]]，原矩阵未变
print(copy_T)     # 输出：[[-99   3] [  2   4]]

# 创建一个3x2x4的三维数组，可以理解为3个2行4列的矩阵
tensor_3d = np.arange(24).reshape(3, 2, 4)
print("原始三维数组形状：", tensor_3d.shape)  # (3, 2, 4)
print("原始数据：\n", tensor_3d)

# 目标：将轴顺序从 (0, 1, 2) 变为 (1, 0, 2)
# 即原来的“第0维（3个块）”和“第1维（2行）”交换
transposed_3d = tensor_3d.transpose(1, 0, 2)
print("\n转置后形状：", transposed_3d.shape)  # (2, 3, 4)
print("转置后数据：\n", transposed_3d)

matrix_np = np.array([[1, 2, 3], [4, 5, 6]])
print("原数组：\n", matrix_np)
print("形状：", matrix_np.shape)  # (2, 3)

# 交换轴0和轴1，对于二维数组，这就是转置
swapped = matrix_np.swapaxes(0, 1)
print("\nswapaxes(0, 1)后：\n", swapped)
print("形状：", swapped.shape)  # (3, 2)

# 对于三维数组，交换特定轴
tensor_3d = np.ones((2, 3, 4))
print("\n三维数组交换轴0和轴2前形状：", tensor_3d.shape) # (2,3,4)
swapped_3d = tensor_3d.swapaxes(0, 2)
print("三维数组交换轴0和轴2后形状：", swapped_3d.shape) # (4,3,2)

import numpy as np
import timeit

def setup_data(n):
    """生成一个n x n的测试矩阵（列表和NumPy数组）"""
    py_list = [[i * n + j for j in range(n)] for i in range(n)]
    np_array = np.array(py_list)
    return py_list, np_array

def test_py_loop(matrix):
    transpose_nested_loop(matrix)

def test_py_comprehension(matrix):
    [[row[i] for row in matrix] for i in range(len(matrix[0]))]

def test_py_zip(matrix):
    list(map(list, zip(*matrix)))

def test_np_T(arr):
    arr.T

def test_np_transpose(arr):
    arr.transpose()

def test_np_copy(arr):
    arr.T.copy()

# 测试规模
size = 500  # 500x500的矩阵
py_mat, np_arr = setup_data(size)

# 运行测试，每个函数执行10次，取平均时间
number = 10
print(f"测试 {size}x{size} 矩阵的转置操作（运行{number}次取平均）")
print("-" * 60)

t_loop = timeit.timeit(lambda: test_py_loop(py_mat), number=number) / number
t_comp = timeit.timeit(lambda: test_py_comprehension(py_mat), number=number) / number
t_zip = timeit.timeit(lambda: test_py_zip(py_mat), number=number) / number
t_npT = timeit.timeit(lambda: test_np_T(np_arr), number=number) / number
t_npTrans = timeit.timeit(lambda: test_np_transpose(np_arr), number=number) / number
t_npCopy = timeit.timeit(lambda: test_np_copy(np_arr), number=number) / number

print(f"纯Python嵌套循环: {t_loop:.6f} 秒")
print(f"纯Python列表推导: {t_comp:.6f} 秒")
print(f"纯Python zip(*):   {t_zip:.6f} 秒")
print(f"NumPy .T (视图):   {t_npT:.6f} 秒")
print(f"NumPy transpose(): {t_npTrans:.6f} 秒")
print(f"NumPy .T.copy():   {t_npCopy:.6f} 秒")

import sys

large_array = np.random.rand(10000, 10000)  # 一个巨大的矩阵
print(f"原始数组大小: {large_array.nbytes / 1024**2:.2f} MB")  # 约800 MB (假设float64)

# 创建视图（转置）
transposed_view = large_array.T
print(f"转置视图大小（通过sys.getsizeof估算对象本身，不包含数据）: {sys.getsizeof(transposed_view) / 1024:.2f} KB")
# 注意：sys.getsizeof只计算Python对象开销，不计算底层数据。
# 实际上，transposed_view与large_array共享底层数据，几乎没有额外内存消耗。

# 创建拷贝
transposed_copy = large_array.T.copy()
print(f"转置拷贝大小: {transposed_copy.nbytes / 1024**2:.2f} MB")  # 同样约800 MB

def safe_transpose_irregular(matrix):
    """
    安全地转置可能非规整的二维列表。
    参数:
        matrix: 二维列表，允许各行长度不同。
    返回:
        转置后的二维列表。缺失位置用None填充。
    """
    if not matrix:
        return []

    # 找出最长的一行有多长
    max_len = max(len(row) for row in matrix)

    # 初始化转置后的矩阵，行数=max_len，列数=原行数
    transposed = [[] for _ in range(max_len)]

    for i, row in enumerate(matrix):
        for j in range(max_len):
            # 如果当前行有第j个元素，则取出；否则填充None
            value = row[j] if j < len(row) else None
            transposed[j].append(value)
    return transposed

# 示例
irregular = [[1, 2], [3, 4, 5, 6], [7]]
result = safe_transpose_irregular(irregular)
print(result)
# 输出：[[1, 3, 7], [2, 4, None], [None, 5, None], [None, 6, None]]

def transpose_inplace_square(matrix):
    """
    原地转置方阵（直接修改传入的列表）。
    警告：仅适用于方阵，且会修改输入参数。
    参数:
        matrix: 二维列表（方阵）。
    """
    n = len(matrix)
    for i in range(n):
        # 只需遍历上三角（或下三角），避免交换两次
        for j in range(i + 1, n):
            matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

# 示例
square_matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print("转置前:", square_matrix)
transpose_inplace_square(square_matrix)
print("原地转置后:", square_matrix)
# 输出：转置前: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#      原地转置后: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

arr = np.arange(12).reshape(3, 4)
print("原数组是否C连续:", arr.flags['C_CONTIGUOUS'])  # True
print("原数组是否F连续:", arr.flags['F_CONTIGUOUS'])  # False

arr_T = arr.T
print("\n转置后数组是否C连续:", arr_T.flags['C_CONTIGUOUS'])  # False
print("转置后数组是否F连续:", arr_T.flags['F_CONTIGUOUS'])  # True

# 不连续的数组在某些运算中可能较慢
# 如果需要连续的副本，可以使用 `.copy(order='C')` 或 `.copy(order='F')`
arr_T_contiguous = arr.T.copy(order='C')
print("\n拷贝后（C连续）数组是否C连续:", arr_T_contiguous.flags['C_CONTIGUOUS'])  # True