Python中列表的应用（实现C语言中的数组，矩阵的转置，跟随排序，动态规划法TSP问题代码）

1 列表应用

1.1 初始化一个用列表构成的二维数组(矩阵)

（1）基础构成

[[1,2,3,4],[5,6,7,8]]
$$\begin{array}{cccc}1& 2& 3& 4\\ 5& 6& 7& 8\end{array}$$
用列表嵌套列表的方式，内嵌列表为每一行的元素

（2）如何用列表实现C语言中的数组

问题:用python中的列表实现初始化一个n*m的数组,初始化之后可以直接通过array[0][1] =1索引来更改某位置的元素

类似C语言中 int array[4][5]

int main(){
    int array[4][5];
    array[0][1] = 5;
    printf("array[0][1]");
}

最常见遇到的问题：

array = []
array[0] = 1
print(array[0])
# 会报错 IndexError: list assignment index out of range

首先分析一下C语言的代码逻辑

int array[4][5] 干了两件事

​ 一是创建了array数组

​ 而是像内存中分配了对应的内存单元

​ 分配了内存单元但是初值并不一定为0

​ 所以说在一些需求中：

​ 例如创建一个4*5的整数类型数组，然后再将第一行和第一列初始化为0，还是要进行初始化的

然后再看常遇到的问题

array 只干了一件事情

​ 创建了array这个列表对象，并没有分配内存

​ 所以不能具备array[0] = 1，直接将0位置处元素初始化为1

总结：

要让python中的列表实现C语言中的数组，并完成通过索引直接修改列表中元素的值，需要对列表进行初始化

1 python中用列表生成一维数组array[n]

# python中用列表生成一维数组array[n]
n = 5 
array = [0 for _ in range(n)]
array[1] = 10

2 用python用列表生成二维数组array [n] [m]

方法一：初步想的丑陋

# 用python用列表生成二维数组array[n][m]
array = [[]for _ in range(n)]
for i in array:
    for j in range(m):
        i.append(0)

方法二:用列表生成式

列表生成式

lst = [列表元素,for i in range(n) if condition]

生成n个元素为符合条件condition的列表元素

# 3行2列
n = 3
m = 2
array = [[0]*m for _ in range(n)]

先执行[0]*m [0,0] 然后生成n个元素为[0,0]的列表

方法三:用for循环替代列表生成式

3 用python生成一个n维数组

方法一：嵌套列表生成式

n = 3
array = [[[0 for _ in range(n)] for _ in range(n)] for _ in range(n)]

[0 for _ in range(n)] 生成一个n*1的一维数组，初始值为0

[[0 for _ in range(n)] for _ in range(n)] 生成n个元素为[0 for _ in range(n)]的列表，生成一个n*n的二维数组数组，初始值为0

[[[0 for _ in range(n)] for _ in range(n)] for _ in range(n)] 生成n个元素为[[0 for _ in range(n)] for _ in range(n)]

方法二：用for循环替代嵌套列表生成式

n = 3
array = []
for _ in range(n):
    inner_array = []
    for _ in range(n):
        inner_array.append([0] * n)
    array.append(inner_array)

4 通用函数

def generate_n_dimensional_array(n, *dimensions):
    if n <= 0:
        raise ValueError("Dimension must be a positive integer")

    if len(dimensions) != n:
        raise ValueError("Number of dimensions must match the length of provided dimensions")

    def generate_array(dims):
        if len(dims) == 1:
            return [0] * dims[0]
        else:
            return [generate_array(dims[1:]) for _ in range(dims[0])]

    return generate_array(dimensions)

# Example usage:
n = 1
dimensions = (5,)
result = generate_n_dimensional_array(n, *dimensions)
print(result)

5 使用Numpy的ndarray对象

6 总结

一维二维数组使用列表生成式，且比较常用

二维以上就老老实实用ndarray

1.2 实现二维列表数组按行按列打印

已知：lst = [[1,2,3],[4,5,6],[7,8,9]]如何按行或者按列输出

（1）按列打印

才能有限只会用两个for循环去控制打印

（2）按行打印

方式一：一个for循环

方式二：用列表生成式替代

列表生成式本质上就是简单的for循环和条件语句的结合

所以列表生成式和for循环能够相互替代的

（3）程序示例

lst = [[1,2,3],[4,5,6],[7,8,9]]

print("---按列打印---")
# 按列打印
for row in range(len(lst)):
    for col in range(len(lst[0])):
        print(lst[col][row],end=' ')
    print()

# 按行打印
print("---按行打印方式1---")
for row in lst:
    print(row)
print("---按行打印方式2---")
[print(row) for row in lst]

（4）输出结果

---按列打印---
1 4 7 
2 5 8 
3 6 9 
---按行打印方式1---
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
---按行打印方式2---
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

1.3 实现二维列表数组（矩阵）的转置

方式一:for循环方式

lst = [[1,2,3],[4,5,6],[7,8,9]]
n_col = len(lst[0]) # 列数
n_row = len(lst) # 行数
# 初始化lst转置矩阵 原3*3 转置3*3;原3*4 转置4*3
transposed = [[0]*n_row for _ in range(n_col)]
for row in range(n_row):
    for col in range(n_col):
        transposed[col][row] = lst[row][col]
print(f'原列表{lst}')
print(f'转置列表矩阵{transposed}')

方式二：列表生成式方式

可以用列表生成式知识点去简化5-8代码

lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[col] for row in lst] for col in range(len(lst[0]))]
print(f'原列表: {lst}')
print(f'转置列表矩阵: {transposed}')

首先看看for row in lst获取原矩阵的每行，for col in range(len(lst[0])) 从0-原矩阵的列数

当col=0 时，原列表的每行第[0]元素（即第1列元素），作为转置矩阵中第一行中的元素

二者均可以

for循环的方式更为直接，但是代码量多，效率差

列表生成式比较抽象，但是代码简介，效率较好，比for循环方式少用了一个for循环初始化列表

1.4 如何实现列表的跟随排序

0 参考资料

python 两个list元素一一对应，一个list进行排序，另一个list上的元素也跟着排序，保持一一对应关系_python两个列表元素一一对应-CSDN博客

1 引例

现在有三个列表，三个列表含义具有对应性

name = ['zhangsan','lisi','wangwu']

math_grade = [82,90,81]

Engilish_grade = [100,89,99]

需求1：我想对math_grade进行排序，然后对应的name列表中也对应变化（即name列表跟随math_grade变化）

需求2：先对于math_grade进行排序，如果成绩相等则根据English_grade进行排序，然后对应的name列表页对应变化（未解决）

2 需求1—解决办法

（1）解决办法一:通过python内置的zip和sorted函数

step1: 将两个列表通过zip函数联和联和两个列表

name = ['zhangsan','lisi','wangwu']
math_grade = [82,90,81]
name_math_grade = list(zip(name,math_grade))
print(name_math_grade)

输出结果

[('zhangsan', 82), ('lisi', 90), ('wangwu', 81)]

step2:然后通过sorted函数指定key=参数 其参数为某个函数（匿名函数）

常用的有

（1）根据某个元素位置进行排序（即根据某一个列表进行排序，然后另一个列表跟随变化）

sorted(lst,key=lambda x:x[0])

（2）根据某个列表的长度进行排序

sorted(lst,key=lambda x:len(x[0]))

sorted_name_math_grade = sorted(name_math_grade,key=lambda x:x[1])

输出结果

[('wangwu', 81), ('zhangsan', 82), ('lisi', 90)]

step3:将排序好的列表进行拆分

result = zip(*sorted_name_math_grade)
sorted_name, sorted_math_grade = [list(x) for x in result]
print(sorted_name)
print(sorted_math_grade)

输出结果

['wangwu', 'zhangsan', 'lisi']
[81, 82, 90]

（2）纯算法—归根到底还是排序算法

根据排序算法,先对一个列表math_grade进行排序，然后记录各个元素的最终位置，然后在将另一个列表name根据上述的各个元素最终位置也进行调整

基于冒泡排序

name = ['zhangsan', 'lisi', 'wangwu']
math_grade = [82, 90, 81]

# 冒泡排序函数
def bubble_sort(arr1,arr2):
    """
    根据arr1，arr2跟随变化
    """
    n = len(arr1)
    # 遍历所有元素
    for i in range(n):
        # 对未排序部分进行比较并交换
        for j in range(0, n-i-1):
            if arr1[j] > arr1[j+1]:
                # 交换arr1
                arr1[j], arr1[j+1] = arr1[j+1], arr1[j]
                # 交换arr2
                arr2[j], arr2[j+1] = arr2[j+1], arr2[j]

# 对数学成绩进行交换排序
bubble_sort(math_grade,name)

# 输出排序后的结果
print("排序后的名字列表:", name)
print("对应的数学成绩列表:", math_grade)

输出结果

排序后的名字列表: ['wangwu', 'zhangsan', 'lisi']
对应的数学成绩列表: [81, 82, 90]

基于选择排序

# 初始列表
name = ['zhangsan', 'lisi', 'wangwu']
math_grade = [82, 90, 81]

# 选择排序函数
def selection_sort(arr1,arr2):
    """
    根据arr1，arr2跟随变化
    """
    n = len(arr1)
    # 遍历所有元素
    for i in range(n):
        min_index = i
        # 在未排序部分找到最小值的索引
        for j in range(i+1, n):
            if arr1[j] < arr1[min_index]:
                min_index = j
        # 将最小值交换至未排序部分的开头
        arr1[i], arr1[min_index] = arr1[min_index], arr1[i]
        # 同时将对应的姓名也进行交换
        arr2[i], arr2[min_index] = arr2[min_index], arr2[i]

# 对数学成绩进行选择排序
selection_sort(math_grade,name)

# 输出排序后的结果
print("排序后的名字列表:", name)
print("对应的数学成绩列表:", math_grade)

（3）通过pandas库来解决(降维打击)

step1:根据两个列表创建DataFrame对象

step2:通过pandas库中DataFrame对象中sort_values方法中by=参数可以指定多个

import pandas as pd

# 初始列表
name = ['zhangsan', 'lisi', 'wangwu']
math_grade = [82, 90, 81]

# 创建DataFrame
df = pd.DataFrame({'Name': name, 'Math Grade': math_grade})

# 根据数学成绩进行排序
df_sorted = df.sort_values(by='Math Grade')

# 输出排序后的结果
print(df_sorted)

       Name  Math Grade
2    wangwu          81
0  zhangsan          82
1      lisi          90

1.5 总结

以上学习内容的总结都是在面对

动态规划法求解TSP问题时根据二进制算法生成子集顺序是根据二进制顺序来的

但是要求根据子集长度来排序

最终要求

所以就用到了上面内容

最后分享一下写的动态规划法求解TSP问题代码

from typing import List

def find_subsets(nums: List[int]) -> List[List[int]]:
    '''
    寻找全部的子集
    Args:
        nums:待寻找子集列表 例如[1,2,3]
    Return:
        subsets:其中全部子，[[子集]]
    '''
    n = len(nums)
    subsets = []
    for i in range(1, 2**n):  # 从1开始以排除空集
        subset = []
        for j in range(n):
            if (i >> j) & 1:
                subset.append(nums[j])
        subsets.append(subset)
    return subsets

def solution_TSP_dynamic(arc: List[List[int]]) -> List[List[int]]:
    """
    动态规划法求解TSP问题,计算从0出发,经过所有顶点,再回到0的代价
    Args:
        arc: 代价矩阵
    Returns:
        List[List[int]]: 动态规划的代价表
    """
    n = len(arc)
    m = 2 ** (n - 1)
    cost = [[float('inf')] * m for _ in range(n)]
    cost[0][0] = 0

    for i in range(1, n):
        cost[i][0] = arc[i][0]

    for j in range(1, m):
        for i in range(1, n):
            if (1 << (i - 1)) & j:
                continue

            for k in range(1, n):
                if (1 << (k - 1)) & j:
                    temp = arc[i][k] + cost[k][j - (1 << (k - 1))]
                    cost[i][j] = min(cost[i][j], temp)

    # 找到从终点回到起点的最小代价，并更新cost[0][m]
    min_cost = float('inf')
    for k in range(1, n):
        temp_cost = arc[0][k] + cost[k][m - 1 - (1 << (k - 1))]
        min_cost = min(min_cost, temp_cost)

    cost[0][m - 1] = min_cost

    return cost



def print_result(V, cost):
    """
    以表格形式打印结果
    """
    V.insert(0,[])
    n_col = len(cost[0])
    n_row = len(cost)
    transposed_cost = [[0]*n_row for _ in range(n_col)]
    for row in range(n_row):
        for col in range(n_col):
            transposed_cost[col][row] = cost[row][col] 
    # 将两个通过zip数据融合,然后用sorted方法中指定排序方式进行排序
    V_transposed_cost = list(zip(V,transposed_cost))
    sorted_V_transposed_cost = sorted(V_transposed_cost,key=lambda x:len(x[0]))
    # 将排序好的列表分离出来
    result = zip(*sorted_V_transposed_cost)
    sorted_V,sorted_transposed_cost = [list(x) for x in result]
    # 将跟随排序好的cost转置回去
    sorted_cost = [[0]*n_col for _ in range(n_row)]
    for row in range(n_row):
        for col in range(n_col):
            sorted_cost[row][col] = sorted_transposed_cost[col][row]
    
    # 打印子集索引
    print("子集:", end="\t")
    max_subset_length = max(len(str(subset)) for subset in sorted_V)
    for subset in sorted_V:
        subset_str = "{" + ", ".join(str(item) for item in subset) + "}"
        print("{:<{}}".format(subset_str, max_subset_length + 2), end=" ")
    print("\n" + "-" * (max_subset_length * len(sorted_V) + 7 * len(sorted_V)))

    # 打印成本表
    for i in range(len(sorted_cost)):
        print("顶点 {}:".format(i), end="\t")
        for j in range(len(sorted_cost[i])):
            if sorted_cost[i][j] == float('inf'):
                print("{:<{}}".format("inf", max_subset_length + 2), end=" ")
            else:
                print("{:<{}}".format(sorted_cost[i][j], max_subset_length + 2), end=" ")
        print()


n = 4
points = [i for i in range(1,n)]
V = find_subsets(points)


inf = float('inf')
arc = [[inf,4,5,8],[5,inf,2,3],[6,4,inf,2],[3,7,5,inf]]
cost = solution_TSP_dynamic(arc)
print_result(V, cost)