【numpy笔记_6】数组增删改查和遍历操作

lichengxin • • 杂文

在认识了numpy、创建数组对象和运算的机制后，我们看看如何操作一个数组。

增：

  • 追加末尾：np.append()
  • 在某个索引前插入：np.insert()

与list不同，append和insert方法并非直接在原数组上直接修改，而是返回一个新的数组。

import numpy as np
arr_1 = np.arange(10)
print(f'原始的arr_1: {arr_1}')
res_append = np.append(arr=arr_1, values=[12], axis=0)
res_insert = np.insert(arr=arr_1, obj=0, values=[13], axis=0)
'''append方法【参数】             insert方法【参数】
   arr: 原数组                   arr: 原数组
   （追加末尾）                   obj: 索引位置，在该索引前插入
   values: 插入内容              values: 插入内容
   axis: 插入方向                axis: 插入方向
'''
print(f'操作过append、insert方法后的arr_1: {arr_1}')   # append和insert并未在原数组上修改
print(f'append新赋值的数组：{res_append}')
print(f'insert新赋值的数组：{res_insert}')
# 运行结果：
原始的arr_1: [0 1 2 3 4 5 6 7 8 9]
操作过append、insert方法后的arr_1: [0 1 2 3 4 5 6 7 8 9]
append新赋值的数组：[ 0  1  2  3  4  5  6  7  8  9 12]
insert新赋值的数组：[13  0  1  2  3  4  5  6  7  8  9]
插入方向axis：
arr_1 = np.arange(9).reshape(3,3)
res_append1 = np.append(arr=arr_1, values=[[12,13,14],[15,16,17]],axis=0)  # 插入2行
res_append2 = np.append(arr=arr_1, values=[[12],[13],[14]],axis=1)   # 插入1列
'''
我们知道了shape是(行,列)
axis=0 ———— 沿0轴插入，即插入行（插入完整的一或多行。即插入的数组，其列数要与原数组一致）
axis=1 ———— 沿1轴插入，即插入列（插入完整的一或多列。即插入的数组，其行数要与原数组一致）
'''
print(f'原数组: /n{arr_1}')   # append和insert并未在原数组上修改
print(f'axis=0插入新数组：/n{res_append1}')
print(f'axis=1插入新数组：/n{res_append2}')
# 运行结果：
原数组: 
[[0 1 2]
 [3 4 5]
 [6 7 8]]
axis=0插入新数组：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [12 13 14]
 [15 16 17]]
axis=1插入新数组：
[[ 0  1  2 12]
 [ 3  4  5 13]
 [ 6  7  8 14]]

那多维呢？像之前讲的一样，我们理解了shape(x,y,z)和axis参数的关系就像这样：

axis参数的含义.png

插入的值必须按照 axis参数的选择，跟原数组结构保持一致。
来看个多维数组选择axis参数的例子，请仔细观察插入值的数组结构：

arr_1 = np.arange(12).reshape(2,2,3)
res_append1 = np.append(arr=arr_1, values=[[[12,13,14],[15,16,17]]],axis=0)  # 插入1块
res_append2 = np.append(arr=arr_1, values=[[[12,13,14]],[[15,16,17]]],axis=1)   # 插入2行
res_append3 = np.append(arr=arr_1, values=[[[12],[13]],[[14],[15]]],axis=2)   # 插入1列

print(f'原数组: /n{arr_1}')   # append和insert并未在原数组上修改
print(f'axis=0插入新数组：/n{res_append1}')
print(f'axis=1插入新数组：/n{res_append2}')
print(f'axis=2插入新数组：/n{res_append3}')
# 运行结果：
原数组: 
[[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]]
axis=0插入新数组：
[[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]

 [[12 13 14]
  [15 16 17]]]
axis=1插入新数组：
[[[ 0  1  2]
  [ 3  4  5]
  [12 13 14]]

 [[ 6  7  8]
  [ 9 10 11]
  [15 16 17]]]
axis=2插入新数组：
[[[ 0  1  2 12]
  [ 3  4  5 13]]

 [[ 6  7  8 14]
  [ 9 10 11 15]]]

再提一点：
axis参数不写默认为None，此时无论数组是什么结构，都会展成一条线将值插入。

arr_1 = np.arange(12).reshape(2,2,3)
res_append1 = np.append(arr=arr_1, values=[12,13,14],axis=None)  # axis参数为None

print(f'原数组: /n{arr_1}')
print(f'axis=0插入新数组：/n{res_append1}')
# 运行结果：
原数组: 
[[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]]
axis=None插入新数组：
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]   # 展成一条线

删：

  • np.delete() 删除指定元素
  • np.unique() 删除重复元素

两个方法仍然并非直接在原数组上直接修改，而是返回一个新的数组。
delete()参数也有arr，obj，axis：

arr_1 = np.arange(40).reshape(2,4,5)
res1 = np.delete(arr=arr_1, obj=5)   # axis参数不选，默认为None，数组会被展开，删除元素5
res2 = np.delete(arr=arr_1, obj=1, axis=2)   # shape(x,y,z)时，axis=2指的是列。即删除第2列
res3 = np.delete(arr=arr_1, obj=[1,3], axis=1)   # shape(x,y,z)时，axis=1指的是行。即删除第2行、第4行
print(f'原数组: /n{arr_1}')
print(f'操作删除 5后的数组：/n{res1}')
print(f'操作删除 第2列后的数组：/n{res2}')
print(f'操作删除 第2行，第4行后的数组：/n{res3}')
# 运行结果：
原数组: 
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]
  [10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]
  [30 31 32 33 34]
  [35 36 37 38 39]]]
操作删除 5后的数组：
[ 0  1  2  3  4  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39]
操作删除 第2列后的数组：
[[[ 0  2  3  4]
  [ 5  7  8  9]
  [10 12 13 14]
  [15 17 18 19]]

 [[20 22 23 24]
  [25 27 28 29]
  [30 32 33 34]
  [35 37 38 39]]]
操作删除 第2行，第4行后的数组：
[[[ 0  1  2  3  4]
  [10 11 12 13 14]]

 [[20 21 22 23 24]
  [30 31 32 33 34]]]

unique()会将一个数组展开，去重后从小到大排序成一组数。参数主要有：

  • return_index（None、True、False）：True则返回新数据元素在原数组中的位置（索引）；
  • return_inverse（None、True、False）：True则返回原数据元素在新数组中的位置（索引）；
  • return_counts（None、True、False）：True则返回去重后的数组元素 在原数组中出现的次数。

参数不写，均默认为None。
参数就不再演示了，也好理解。且个人感觉参数用的并不多。

li = [9,4,6,4,5,1,1,9]
arr = np.array(li).reshape(2,4)
arr_1 = np.unique(li)
print(f'原数组: /n{arr}')
print(f'去重后的数组: /n{arr_1}')
# 运行结果：
原数组: 
[[9 4 6 4]
 [5 1 1 9]]
去重后的数组: 
[1 4 5 6 9]

改：

numpy改数据的方法与常规list基本一致，都是通过索引赋值的方式更改。
看几个例子：

arr1 = np.arange(8)
print(f'原数组: /n{arr1}')
arr1[2] = 66   # 列索引，数组为线时代表列
print(f'arr1[2]改后的值: /n{arr1}')

arr1 = np.arange(12).reshape(3,4)
print(f'原数组: /n{arr1}')
arr1[0] = 66   # 行索引，数组为面时代表行
print(f'arr1[0]改后的值: /n{arr1}')
# 上面两个例子看的出，改值索引仍然遵循shape的概念

arr1 = np.arange(12).reshape(3,4)
print(f'原数组: /n{arr1}')
arr1[0:3] = 66   # 行切片索引，左闭右开
print(f'arr1[0:3]改后的值: /n{arr1}')

arr1 = np.arange(12).reshape(3,4)
print(f'原数组: /n{arr1}')
arr1[0,3] = 66   # 坐标索引，数组为面时输入坐标才能定位行、列
print(f'arr1[0,3]改后的值: /n{arr1}')
# 运行结果：
原数组: 
[0 1 2 3 4 5 6 7]
arr1[2]改后的值: 
[ 0  1 66  3  4  5  6  7]
原数组: 
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr1[0]改后的值: 
[[66 66 66 66]
 [ 4  5  6  7]
 [ 8  9 10 11]]
原数组: 
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr1[0:3]改后的值: 
[[66 66 66 66]
 [66 66 66 66]
 [66 66 66 66]]
原数组: 
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
arr1[0,3]改后的值: 
[[ 0  1  2 66]
 [ 4  5  6  7]
 [ 8  9 10 11]]

查：

上篇《索引、高级索引和切片》中讲过了numpy的索引和切片，根本便是查数据的动作。
这里再介绍几个有意思的方法，在实际场景中使用非常方便。
np.argwhere()方法：加个判断条件，返回数组中某些元素的索引。默认为判断非零元素。

li = [0,4,0,2,0,1,9,0]
arr = np.array(li).reshape(2,4)
arr_1 = np.argwhere(arr != 0)   # argwhere()不写也是判断非零的意思
arr_2 = np.argwhere(arr > 4/2)   # argwhere()加其他任何判断条件
print(f'原数组: /n{arr}')
print(f'非零元素的索引: /n{arr_1}')
print(f'大于4/2元素的索引: /n{arr_2}')
# 运行结果：
原数组: 
[[0 4 0 2]
 [0 1 9 0]]
非零元素的索引: 
[[0 1]
 [0 3]
 [1 1]
 [1 2]]
大于4/2元素的索引: 
[[0 1]
 [1 2]]

遍历一个数组：

  • 可以通过for循环遍历；一个for循环只剥离一层，取的是元素块而非最小元素 ；针对多维数组，可以嵌套for循环将元素层层剥离；
  • obj.nditer()方法，将数组转成迭代器。取的是数组里的最小元素，每个元素是array对象的形式（该方法直接构建了array对象的迭代器）；
  • obj.flat方法（没有括号），将数组转成迭代器。取的是数组里的最小元素，每个元素仅仅只是一个标量（flat把array对象的值取出来，再构建迭代器）。

听着很迷茫，看个例子：

arr1 = np.arange(8).reshape(2,4)

for i in arr1:    # for循环
    print(i)
    print('*'*5)
# 运行结果：
[0 1 2 3]
*****
[4 5 6 7]
*****

arr1 = np.arange(8).reshape(2,4)
arr1 = np.nditer(arr1)   # nditer() 转成迭代器
print(f'nditer迭代器的arr1: {arr1}')
print(f'将arr1转成列表看看里面的元素：{list(arr1)}')
while len(arr1) != 0:
    print(next(arr1))
# 运行结果：
nditer迭代器的arr1: 
将arr1转成列表看看里面的元素：[array(0), array(1), array(2), array(3), array(4), array(5), array(6), array(7)]
0
1
2
3
4
5
6
7

arr1 = np.arange(8).reshape(2,4)
arr1 = arr1.flat   # flat 转成迭代器
print(f'flat迭代器的arr1: {arr1}')
print(f'将arr1转成列表看看里面的元素：{list(arr1)}')
while len(arr1) != 0:
    print(next(arr1))
# 运行结果：
flat迭代器的arr1: 
将arr1转成列表看看里面的元素：[0, 1, 2, 3, 4, 5, 6, 7]
0
1
2
3
4
5
6
7

看到这你可能明白了刚才说的，obj.nditer()方法，迭代器的每个元素是array对象的形式（该方法直接构建了array对象的迭代器）；obj.flat方法，迭代器的每个元素仅仅只是一个标量（flat把array对象的值取出来，再构建迭代器）。

如果flat取的仅仅是值，该迭代器中便是一个个十分纯粹的标量，不能控制读取顺序，更改其元素内容也不能实现原数组的修改。而nditer() 方法恰恰能实现这些：

所以，nditer()可以控制迭代器对象读取元素的顺序，也可以在迭代过程中操作元素的修改。
nditer() 方法参数：

  • order='C' （大小写均可）

--- 'C':按行读；
--- 'F':按列读；

  • op_flags=['readwirte']

--- ['readonly']：只读，不能修改
--- ['readwirte']：读写，可读可写

arr = np.arange(8).reshape(2,4)
arr1 = np.nditer(arr, order='c')   # 按行读
try:
    while True:
        print(f'每次提取的元素：{next(arr1)}')   # next()取值遍历
except StopIteration:
    pass
print('* '*20)

arr = np.arange(8).reshape(2,4)
arr2 = np.nditer(arr, order='f', op_flags=['readwrite'])   # 按列读，读写模式，可读可修改
for i in arr2:   # for循环遍历
    if i % 2 == 0:
        i[...] = 9   # [...]是固定写法，指的是改写array对象当前的元素
print(f'修改后的arr: /n{arr}')
# 运行结果：
每次提取的元素：0
每次提取的元素：1
每次提取的元素：2
每次提取的元素：3
每次提取的元素：4
每次提取的元素：5
每次提取的元素：6
每次提取的元素：7
* * * * * * * * * * * * * * * * * * * * 
修改后的arr: 
[[9 1 9 3]
 [9 5 9 7]]

最后总结一下遍历：

推荐使用nditer()方法，能控制遍历的顺序，以及遍历时对元素进行操作。

版权声明：
作者：lichengxin
链接：https://www.techfm.club/p/42811.html
来源：TechFM
文章版权归作者所有，未经允许请勿转载。

THE END
分享
二维码
< <上一篇
下一篇>>