在认识了numpy、创建数组对象和运算的机制后，我们看看怎样利用一个数组。
增：
- 追加末尾：np.append()
- 在某个索引前插入：np.insert()
与list差别，append和insert方法并非直接在原数组上直接修改，而是返回一个新的数组。
import numpy as nparr_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参数的选择，跟原数组布局保持划一。
来看个多维数组选择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参数为Noneprint(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，数组会被睁开，删除元素5res2 = 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: <numpy.nditer object at 0x000002A0D2163710>将arr1转成列表看看里面的元素：[array(0), array(1), array(2), array(3), array(4), array(5), array(6), array(7)]01234567arr1 = 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: <numpy.flatiter object at 0x0000020C1B3D85B0>将arr1转成列表看看里面的元素：[0, 1, 2, 3, 4, 5, 6, 7]01234567看到这你大概明白了刚才说的，obj.nditer()方法，迭代器的每个元素是array对象的情势（该方法直接构建了array对象的迭代器）；obj.flat方法，迭代器的每个元素仅仅只是一个标量（flat把array对象的值取出来，再构建迭代器）。
如果flat取的仅仅是值，该迭代器中便是一个个非常纯粹的标量，不能控制读取次序，更改其元素内容也不能实现原数组的修改。而nditer() 方法恰好能实现这些：
以是，nditer()可以控制迭代器对象读取元素的次序，也可以在迭代过程中利用元素的修改。
nditer() 方法参数：
--- 'C':按行读；
--- 'F':按列读；
--- ['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: passprint('* '*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()方法，能控制遍历的次序，以及遍历时对元素举行利用。 |
