python数组列表操作简记

weixin_46846685

于 2024-06-20 23:32:51 发布

阅读量1.2k

点赞数 31

分类专栏： python 文章标签： python 数据结构数组排序维度转换 lambda 行列变换

本文链接：https://blog.csdn.net/weixin_46846685/article/details/139755490

版权

python 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、python列表、数组增删元素

1.1列表增删元素

列表是Python内置的数据结构，可以存储不同类型的元素，列表是动态的，支持增加或删除元素操作，示例代码如下：

代码	说明
list01 = [1, 2.0, ‘c’, 5, 9, ‘t’]	列表初始定义
list01.extend([7,‘a’])	将列表[7,‘a’]添加至list01的末尾
list01.append(‘a’)	增加元素至末尾
list01.insert(1,6)	插入元素6至索引为1处，之前索引为1及之后的元素移动到6之后
list01.remove(‘a’)	删除元素’a’，输入参数为元素值而非元素索引，若存在多个相同的指定值，只删除第一个指定值
list01.pop()	删除最后一个元素
list01.pop(1)	删除索引为1的元素，输入参数为元素索引
del list01[1:3]	删除索引为从1到2的元素，注意索引为3的元素不删除
del list01[1]	删除索引为1的元素，输入参数为元素索引
list01.clear()	清空列表

列表在存储不同类型的元素时效率较低，因为每个元素都需要额外的内存来保存类型信息和指向实际数据的引用。
对于需要频繁修改大小的情况，列表更灵活。

1.2数组增删元素

1.2.1array数组

array模块为python自带的模块，用于定义数组类型，定义的数组只能存储同一类型的元素，通常是数值类型。数组为动态数组，支持增加或删除元素操作，示例代码如下：

代码	说明
import array	导入array模块
arr01=array.array(‘f’,[1.1,2,3.1])	数组初始定义，‘f’指定数组存储float类型元素
arr02=array.array(‘f’,[3.2,4.6,3.1,2.8])	数组初始定义，‘f’指定数组存储float类型元素
arr01.extend(arr02)	将数组arr02添加至arr01的末尾，只能添加相同类型的数组
arr01.append(2.3)	增加元素至末尾
arr01.insert(1,10.0)	插入元素10.0至索引为1处，之前索引为1及之后的元素移动到10.0之后
arr01.remove(10.0)	删除元素10.0，输入参数为元素值而非元素索引，若存在多个相同的指定值，只删除第一个指定值
arr01.pop()	删除最后一个元素
arr01.pop(1)	删除索引为1的元素，输入参数为元素索引
del arr01[1:3]	删除索引为从1到2的元素，注意索引为3的元素不删除
del arr01[1]	删除索引为1的元素，输入参数为元素索引

数组初始定义存储float类型的时候需要注意，实际存储的元素值与初始定义的元素值可能不是完全一致，例如初始定义的元素为3.1，而存储在数组的元素实际为3.0999999046325684。

数组由于存储相同类型的数据，因此内存使用更紧凑，性能通常比列表高效，特别是在数值运算中。
当需要高效地处理大量同类型的数值数据时，数组会更合适。

1.2.2numpy数组

在数值计算中，使用numpy库定义数组更为常用。numpy定义的数组可以存储不同类型的元素，但通常存储数值类型，定义的数组为静态数组，其大小和维度是固定的无法直接修改，只能通过创建新数组的方法间接修改，增加或删除元素示例代码如下：

代码	说明
import numpy as np	导入numpy模块
n01=np.array([1, 2, 3, 4])	数组初始定义
n02=np.array([5, 6])	数组初始定义
n03=np.append(n01, [5, 6])	将5, 6元素添加至n01的末尾返回一个新的数组，但n01的大小并没有变
n03 = np.concatenate((n01, n02))	将数组n02拼接至n01的末尾返回一个新的数组，但n01与n02的大小并没有变
n04 = np.delete(n03, [1, 3])	删除索引为1和3的元素返回一个新的数组，但n03的大小并没有变
del n01	删除n01数组，是注销了n01变量而不是清空了n01

对比array与numpy定义的数组，

array适用于需要动态调整大小、存储相同类型数据且不需要高级数值计算的简单场景；
numpy数组针对大规模数值运算进行了优化，内存布局更加高效，对于科学计算更合适。

二、python列表、数组排序

2.1列表排序

2.1.1数值类型或无数字字符串类型

当列表内元素为数值类型或不包含数字字符的字符串类型时，可以使用列表自带的sort函数进行正序排序，sort函数只能在列表内元素是同一类型时才能正常调用。sort作用于列表本身，不产生新列表，示例代码如下：

list01=['b','c','a','h']
list01.sort()
list01=[5,6,9,4]
list01.sort()

想要实现逆序排序，可以先使用sort，再使用reverse函数逆转列表，示例代码如下：

list01=[5,6,9,4]
list01.sort()
list01.reverse()

注意reverse函数是将列表元素直接逆转，不进行逆序排序，所以必须先使用sort函数进行正序排序。

2.1.2数字和字母组成的字符串类型

当列表内的元素为数字和字母组成的字符串时，sort函数不能够进行自然排序（natural sorting），想要实现自然排序需要使用sorted函数配合lambda表达式，sorted函数返回一个排序后的新列表，原列表顺序不变，示例代码如下：

list01=['1.txt', '10.txt', '3.txt', '20.txt', '2.txt']
list02=sorted(list01, key=lambda x: (x[:-5],x[:-4]))
list03=sorted(list01, key=lambda x: int(x[:-4]))

x[:-5]含义为取字符串x的第1个到倒数第6个字符，字符串长度小于6时返回空字符串。

代码中两种lambda表达式都能够实现自然排序，其中(x[:-5],x[:-4])指定了两个key作为排序的依据，函数先按照x[:-5]即元素数字部分的十位数排序，对于没有十位数的元素会返回空值，对于x[:-5]相同的元素再按照x[:-4]即元素数字部分的个位数排序。

int(x[:-4])是指定了元素数字部分转换而成的整数作为排序的依据，这种lambda表达式更为直观易解。

当元素字符串构成更加复杂时，需要配合正则表达式进行排序或使用额外的软件包进行排序。

想要实现逆序排序时，向sorted函数的输入参数中添加reverse=True即可，示例代码如下：

list03=sorted(list01, key=lambda x: int(x[:-4]), reverse=True)

2.1.3多字段类型

当列表内元素为多字段构成时，也可以使用sorted函数配合lambda表达式进行正序排序，同样也是返回一个排序后的新列表，示例代码如下：

list01=[('b',8),('a',7),('c',5),('a',2)]
list02=sorted(list01, key=lambda x: (x[0],x[1]))

代码中(x[0],x[1])指定了先根据元素的第一个字段排序，如果第一个字段相同再根据第二个字段排序，如果第二个字段也相同，那么元素保持在列表中的相对顺序不变，即sorted函数属于稳定排序。

实现逆序排序的方法与上一小节相同。

2.2数组排序

2.2.1array数组

array定义的数组不具有sort函数方法，但可以使用sorted函数进行正序排序，同样地，sorted函数返回一个排序后的新列表，原列表顺序不变，示例代码如下：

import array
arr02=array.array('f',[3.2,4.6,3.1,2.8])
sorted(arr02)

实现逆序排序的方法与2.1.2小节相同。

2.2.2numpy数组

numpy定义的数组，自带sort函数实现正序排序，该sort函数与列表自带的sort函数类似，作用于数组本身，不产生新数组，示例代码如下：

import numpy as np
n01=np.array([10, 2, 7, 4])
n01.sort()

sort函数不仅可对一维数组排序，也可对二维数组排序，对二维数组排序时，对每行的元素排序，行与行的顺序不变，示例代码如下：

import numpy as np
n01=np.array([[10, 8, 7, 4],[6, 3, 10, 9]])
n01.sort()

numpy定义的数组没有reverse函数，要想实现逆序排序，可先使用sort函数，然后通过数组索引，返回一个新数组实现，一维、二维数组的逆序排序示例代码如下：

import numpy as np
n01=np.array([10, 2, 7, 4])
n01.sort()
n02=n01[::-1]
n03=np.array([[10, 8, 7, 4],[6, 3, 10, 9]])
n03.sort()
n04=n03[:,::-1]

三、python列表、数组转换维度

3.1列表维度转换

3.1.1获取维度

对于一维列表，一维列表的维度即是列表的长度。
对于高维列表以二维列表为例，二维列表的每个元素都是一个列表，而每个元素列表的长度可能不相同，即二维列表的每一行的列数可能不相同，这是与numpy数组不同的地方，下面内容都假设二维列表的每一行的列数都相同。
列表没有内置的方法获取维度，要获取维度只能进行遍历，示例代码如下：

def get_2d_list_dimensions(list2D):
    if not list2D or not isinstance(list2D, list):
        return 0, 0
    rows = len(list2D)
    cols = len(list2D[0]) if rows > 0 and isinstance(list2D[0], list) else 0
    return rows, cols

3.1.2二维列表展开为一维列表

二维列表按行展开为一维列表，示例代码如下：

list01=[[10, 8, 7, 4],[6, 3, 10, 9]]
list02 = [element for row in list01 for element in row]
#list02的值为[10, 8, 7, 4, 6, 3, 10, 9]

二维列表按列展开为一维列表，示例代码如下：

list01=[[10, 8, 7, 4],[6, 3, 10, 9]]
list02 = [list01[row][col] for col in range(len(list01[0])) for row in range(len(list01))]
#list02的值为[10, 6, 8, 3, 7, 10, 4, 9]

3.1.3一维列表转换为二维列表

一维列表转换为二维列表，需要设定行数和列数，示例代码如下：

list01 = [10, 8, 7, 4, 6, 3, 10, 9]
rows, cols = 2, 4
list02 = [list01[i * cols:(i + 1) * cols] for i in range(rows)]
#list02的值为[[10, 8], [7, 4], [6, 3], [10, 9]]

3.1.4二维列表改变维度

二维列表没有内置的方法实现维度即行列数的改变，只能先将二维列表展平为一维列表，然后按照新的行列数转换为二维列表。

注意，上述列表维度转换都是产生了一个新的列表，且新列表与原列表不共用一个内存，所以新旧列表元素值的更改互不影响。

3.2numpy数组维度转换

3.2.1获取维度

对于numpy定义的数组，可通过内置属性shape方便地获取数组维度，示例代码如下：

n01=np.array([[10, 8, 7, 4],[6, 3, 10, 9]])
n01.shape

shape属性返回一个tuple类型变量，以二维数组为例，第一个元素是行数，第二个元素是列数。

3.2.2数组维度转换

数组具有内置函数reshape进行维度转换，reshape返回一个转换后的数组，原始数组不变。转换维度需要按照一定的顺序排列原数组的元素，默认按照行顺序，可通过order参数更改，order='C’按行，order='F’按列。
默认按行排列，示例代码如下：

n01=np.array([[10, 8, 7, 4],[6, 3, 10, 9]])
n02=n01.reshape((4,2))
#n02的值为
#array([[10,  8],
#       [ 7,  4],
#       [ 6,  3],
#       [10,  9]])

按列排列，示例代码如下：

n01=np.array([[10, 8, 7, 4],[6, 3, 10, 9]])
n03=n01.reshape((4,2), order='F')
#n03的值为
#array([[10,  7],
#       [ 6, 10],
#       [ 8,  4],
#       [ 3,  9]])

按列排列的结果可能出乎预料，比较难以理解，实际上按列排列是指既按列读取原数组，也按列排列在重构后的新数组。
将数组转换为一维数组，有多种方法，示例代码如下：

n01=np.array([[10, 8, 7, 4],[6, 3, 10, 9]])
n04=n01.reshape((8))
n04=n01.reshape((8,))
n04=n01.reshape((-1))
n04=n01.reshape((-1,))
n04=n01.flatten()

#n04的值都为array([10,  8,  7,  4,  6,  3, 10,  9])