Numpy部分常见操作汇总——数组的增、删、改、变及列表映射

np.delete()——删除指定行、列

1. 假设我们的数组是 $x$，我们要删除第 $i$ 行：

x = numpy.delete(x，i, axis = 0)

2. 假设我们的数组是 $x$，我们要删除第 $i$ 列：

x = numpy.delete(x，i, axis = 1)

arr.ravel()、arr.shape=()、arr.reshape()——数组维度转换

核心功能：实现原数组（array_base）的多维转一维，一维转多维，多维转多维的操作。

1. array_base.ravel() ：多维转一维；
2. array_base.shape=(转换为x行，转换为y列) ：一维/多维 转 多维/一维；（使用.shape时必须后边跟=，否则报错。并且，不需要变量接收也能打印出来）
3. array_base.reshape(转换为x行，转换为y列) ：一维/多维 转 多维/一维；（使用.reshape()需要有变量接收，否则打印出来）

典型范例：

import numpy as np
print("----------------np.floor()向下取整-------------------------")
a = np.floor(10*np.random.random((3,4)))   # np.random.random((3,4)表示在-1和1之间随机取值，构建3行4列的数组
print(a)
>>>
array([[6., 3., 2., 8.],
       [8., 8., 3., 4.],
       [5., 3., 5., 7.]])
print(a.shape)
>>>
(3, 4)
#### Numpy——数组维度转换
print("-----------原数组.ravel()：将数组拉平为一维数组-------------")
print (a.ravel())    # 将a数组拉平为一维数组
>>>
[6. 3. 2. 8. 8. 8. 3. 4. 5. 3. 5. 7.]

print("-----a.shape = (6, 2)------")
a.shape = (6, 2)     # 将a数组从一维转换成6行2列的数组
print (a) 
>>>
array([[6., 3.],
       [2., 8.],
       [8., 8.],
       [3., 4.],
       [5., 3.],
       [5., 7.]])

print("------a.reshape(2,6)-------")
b= a.reshape(2,6)   # 使用a.reshape()需要有变量接收，否则打印不出来,a.shape=(),不需要变量接收也能打印出来
print("b=","\n",b)
>>>
b= 
 [[6. 3. 2. 8. 8. 8.]
 [3. 4. 5. 3. 5. 7.]]

print("---------a.T---------")
print (a.T)          # 对数组a进行转置
>>>
array([[6., 2., 8., 3., 5., 5.],
       [3., 8., 8., 4., 3., 7.]])

print("---------a.reshape(3,-1)---------")
d = a.reshape(3,-1)   # 这里列的位置写-1表示：将数组a转变为3行，列的个数根据总元素个数自动转换,因为a总元素有12个，所以此处会转为4列
print("d=","\n",d)
>>>
array([[6., 3., 2., 8.],
       [8., 8., 3., 4.],
       [5., 3., 5., 7.]])

np.tile()——宽高变形（以原数组为单位，宽高方向各扩展n倍）

核心语法：

矩阵变形（宽高变形）：np.tile( 原数组 , ( 转换为x行，转换为y列 ) )

import numpy as np

print("---------------------一维数组变形---------------------------")
a = np.arange(0, 40, 10)  # 构建一个从0开始，40结束，步长为10的一维矩阵
print("a=",a)
>>>
a= array([ 0, 10, 20, 30])

# 将原来矩阵视作一个整体单元，构建shape为（3,5）以这个整体单元为"单一元素"的3行，5列的矩阵
b = np.tile(a, (3, 5))   
print (b)
>>>
array([[ 0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,
         0, 10, 20, 30],
       [ 0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,
         0, 10, 20, 30],
       [ 0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,
         0, 10, 20, 30]])

print("---------------------二维数组变形-------------------------------")
a = np.array([[1,2,3],[4,5,6]])
print("a=","\n",a)
>>>
a= array([[1, 2, 3],
       [4, 5, 6]])

b=np.tile(a,(3,4))   # 将原来矩阵视作一个整体单元，构建shape为（3,4）,以这个整体单元为"单一元素"的3行，4列的矩阵
print(b)
>>>
array([[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6],
       [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6],
       [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6]])

np.array中shape ( ,)与( ,1)的区别

python里：

• np.array 的shape (n,)是一维数组，里面有n个元素；
• np.array 的shape(n,1)是二维数组，n行1列；

import numpy as np
x = np.array([1, 2])  # 通过单列表创建的数组，shape为（2，）
print(x)
>>>
array([1, 2])
print(x.shape)  # 欲将其shape变为（2，1）,可以使用x.shape=(2,1)来实现维度转变
>>>
(2,)

y = np.array([[1],[2]])  # 复合列表创建多重数组
print(y)
>>>
array([[1],
       [2]])
print(y.shape)
>>>
(2, 1)

z = np.array([[1,2]])
print(z)
>>>
array([[1, 2]])
print(z.shape)
>>>
(1, 2)

np.concatenate()、np.hstack()、np.vstack()——Python中List、Array数组的拼接、合并

Python中Numpy数组的合并有很多方法，Array常用的方法如下：

（1）np.concatenate() ，实现array的水平、垂直组合
（2）np.hstack() ，实现array的水平组合，扩展用法在array右侧增加一列
（3）np.vstack() ，实现array的垂直组合，扩展用法在array尾部增加一行

典型范例：

import numpy as np
a = np.array([[1, 1, 2],
       [9, 4, 5],
       [5, 7, 8]])

b = np.array([[3, 2, 4],
       [6, 8, 6],
       [3, 5, 16]])

#水平组合
c = np.hstack((a, b))
c1 = np.concatenate((a,b),axis=1)
>>>
array([[ 1,  1,  2,  3,  2,  4],
       [ 9,  4,  5,  6,  8,  6],
       [ 5,  7,  8,  3,  5, 16]])

#垂直组合
d = np.vstack((a, b))
d1 = np.concatenate((a,b),axis=0)
>>>
array([[ 1,  1,  2],
       [ 9,  4,  5],
       [ 5,  7,  8],
       [ 3,  2,  4],
       [ 6,  8,  6],
       [ 3,  5, 16]])
# 在数组的末尾增加一行
a = np.array(([1,2,3],[4,5,6],[7,8,9]))
print(a)
>>>
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
new_row = [1, 5, 9]
b = np.vstack([a,new_row])  # 数组a的末尾增加一行
print(b)
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9],
       [1, 5, 9]])

Python中List列表用的最多的是使用list_x.append()，为列表list_x添加子元素。

append参数类型是任意的，可以追加一个list，还可以追加一个元组，也可以追加一个单独的元素。

典型范例：

import numpy as np
a = [[1,2,3],[4,5,6],[9,8,7]]
b = [10,87,90]
g = 'jkj'

a.append(b)   # 添加列表b后，a的值即发生变化，不需要变量接收
print(a)
>>>
[[1, 2, 3], [4, 5, 6], [9, 8, 7], [10, 87, 90]]

a.append(g) # 添加单一元素g后，a的值即发生变化，不需要变量接收
>>>
[[1, 2, 3], [4, 5, 6], [9, 8, 7], [10, 87, 90], 'jkj']

Python中List列表的其他常见操作：

1. 添加元素，使用 .insert或者.append。

# list_x.insert(index,'strwords') 在指定位置index处,添加的内容'strwords'
list_x.insert(0,'bu')
#  list_x.append('strwords') 在列表list_x的末尾添加内容'strwords'
list_x.append('bu')

2. 修改元素，使用=直接赋值即可。

# 修改列表list_x的第二个位置为'pei'
list_x[2]='pei' 

3. 删除元素，使用 .pop()

# 使用list_x.pop()删除末尾；使用list_x.pop(index)删除指定位置index处的内容
list_x.pop(2) //删除指定位置2处的内容 

list1到list2的映射

lb_list = []   # 存放真实id标签
# 定义标注框ID值得映射关系————————已知算法输出VS真实ID值
id_list = ['id12', 'id13', 'id14', 'id15', 'id18', 'id19', 'id26']  # 目标病灶ID值
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# enumerate(sequence, [start=0])
index = { i:k for i,k in enumerate(id_list, 0) }  # 调换i:k的顺序可以改变映射关系
print("基于原始ID值定义的映射关系：",index)
rd_id_list = [2,4,6]
[i for i,x in enumerate(rd_id_list) if x in index]
print("算法输出mun值：",rd_id_list)
lb_list = list(map(index.get, rd_id_list))
print("对应于ID值的映射结果:",lb_list) ## list(filter(None, map(index.get, random_list)))  # 会过滤掉0

>>>
基于原始ID值定义的映射关系： {0: 'id12', 1: 'id13', 2: 'id14', 3: 'id15', 4: 'id18', 5: 'id19', 6: 'id26'}
算法输出mun值： [2, 4, 6]
对应于ID值的映射结果: ['id14', 'id18', 'id26']

映射相关参考：Python map() 函数

np.c_[] | np.r_[]、np.insert()、np.row_stack()|np.cloum_stack()——数组添加一行或一列

核心语法：

np.r_[arr_a, arr_b] :将将数组arr_a和arr_b进行行拼接；
np.c_[arr_a, arr_b] :将将数组arr_a和arr_b进行列拼接。

a = np.array([1,2,3])
print(a)
>>>
array([1, 2, 3])
b = np.array([4,5,6])
print(b)
>>>
array([4, 5, 6])
# 进行行拼接
c = np.r_[a,b]
print(c)
>>>
array([1, 2, 3, 4, 5, 6])
# 进行列拼接
d = np.c_[a,b]
print(d)
>>>
array([[1, 4],
       [2, 5],
       [3, 6]])

核心语法：

numpy.insert(arr, obj, values, axis)——此函数沿给定轴和给定索引之前在输入数组中插入值。

参数说明：

• arr：是欲操作的目标数组（即：在arr的基础上插入元素），它可以是一维的也可以是多维的；
• obj：是元素插入的位置；
• values：是需要插入的数值/数组；
• axis：是指示在哪一个轴上对应的插入位置进行插入；

备注： 如果第四个参数axis没有给出，那么就默认为先对arr进行flatten操作，变为一维数组，然后再在对应的位置上插入对应的值。

import numpy as np
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
>>>
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
b = np.array([[0,0,0]])
print(b)
>>>
array([[0, 0, 0]])
# 利用insert()进行行插入——默认向前插入
c = np.insert(a, 0, values=b, axis=0)
print(c)
>>>
array([[0, 0, 0],
       [1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
# 利用insert()进行列插入——默认向前插入
d = np.insert(a, 0, values=b, axis=1)
print(d)
>>>
[[0 1 2 3]
 [0 4 5 6]
 [0 7 8 9]]
# 如果第四个参数axis没有给出，那么就==默认为先对arr进行flatten操作，变为一维数组，然后再在对应的位置上插入对应的值。 
e = np.insert(a, 2, [11,12])
print(e)
>>>
array([ 1,  2, 11, 12,  3,  4,  5,  6,  7,  8,  9])

np.argwhere(array)——获取array中数组元素的索引位置

核心语法：

np.argwhere(array)：找到非空数组array在满足某些条件下的索引，返回索引数组。

• array为一维数组时：返回一个一维数组，代表当前满足条件的元素出现的位置。
• array为二维数组时：返回二维数组，代表当前满足条件的元素出现的位置。

典型范例：

arr = np.random.randint(0,10,(5,)) # 生成一个shape为(5,)的一维数组
print(arr)
>>>
array([7, 0, 1, 3, 2])
print(arr.shape)
>>>
(5,)
# np.argwhere(arr<5)找到满足值小于5的元素的位置索引
index = np.argwhere(arr<5)
print(index)
>>>
array([[1],
       [2],
       [3],
       [4]])
# 示例二
arr = np.random.randint(0,10,(1,5))
print(arr)
>>>
array([[3, 3, 6, 7, 4]])
print(arr.shape)
>>>
(1, 5)
# 找到二维数组中满足指定条件的元素值
index = np.argwhere(arr<5)
print(index)
>>>
array([[0, 0],
       [0, 1],
       [0, 4]])
# 示例三
a = np.array(([3,2,1],[2,5,7],[4,7,8]))
print(a)
>>>
array([[3, 2, 1],
       [2, 5, 7],
       [4, 7, 8]])
# 寻找数组中元素7所在的位置
itemindex = np.argwhere(a == 7)
print(itemindex)
>>>
array([[1, 2],
       [2, 1]])