NumPy学习5

今天学习了
11, NumPy数组元素增删改查
NumPy 数组元素的增删改查操作，主要有以下方法：

数组元素操作方法
函数名称   描述说明
resize 返回指定形状的新数组。
append 将元素值添加到数组的末尾。
insert 沿规定的轴将元素值插入到指定的元素前。
delete 删掉某个轴上的子数组，并返回删除后的新数组。
argwhere   返回数组内符合条件的元素的索引值。
unique 用于删除数组中重复的元素，并按元素值由大到小返回一个新数组。

numpy_test5.py ：

import numpy as np

'''
11, NumPy数组元素增删改查
NumPy 数组元素的增删改查操作，主要有以下方法：

数组元素操作方法
函数名称    描述说明
resize    返回指定形状的新数组。
append    将元素值添加到数组的末尾。
insert    沿规定的轴将元素值插入到指定的元素前。
delete    删掉某个轴上的子数组，并返回删除后的新数组。
argwhere    返回数组内符合条件的元素的索引值。
unique    用于删除数组中重复的元素，并按元素值由大到小返回一个新数组。
'''

'''
(1). numpy.resize()
numpy.resize() 返回指定形状的新数组。
numpy.resize(arr, shape)
'''
print("----(1). numpy.resize()----")
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
print("arr1：", arr1)
# arr1数组的形状
print("arr1数组的形状：", arr1.shape)
arr2 = np.resize(arr1, (3, 2))
# arr2数组
print("arr2：", arr2)
# arr2数组的形状
print("arr2数组的形状：", arr2.shape)
# 修改 arr3 数组使其形状大于原始数组
arr3 = np.resize(arr1, (3, 3))
print("arr3：", arr3)
'''
arr1： [[1 2 3]
 [4 5 6]]
arr1数组的形状： (2, 3)
arr2： [[1 2]
 [3 4]
 [5 6]]
arr2数组的形状： (3, 2)
arr3： [[1 2 3]
 [4 5 6]
 [1 2 3]]
 
区别 resize() 和 reshape() 的使用方法，它们看起来相似，实则不同。
resize 仅对原数组进行修改，没有返回值.
而 reshape 不仅对原数组进行修改，同时返回修改后的结果。
'''
arr4 = np.arange(12)
print("arr4：", arr4)
# 调用resize方法
arr4_resize = arr4.resize(2, 3, 2)
print("调用resize方法后，arr4：", arr4)
# 返回None使用print打印
print("arr4_resize：", arr4_resize)

# 调用reshape方法
arr4_shape = arr4.reshape(2, 3, 2)
print("调用reshape方法后，arr4：", arr4)
# 返回修改后的数组
print("arr4_shape：", arr4_shape)
'''
arr4： [ 0  1  2  3  4  5  6  7  8  9 10 11]
调用resize方法后，arr4： [[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]
arr4_resize： None
调用reshape方法后，arr4： [[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]
arr4_shape： [[[ 0  1]
  [ 2  3]
  [ 4  5]]

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

'''
(2). numpy.append()
在数组的末尾添加值，它返回一个一维数组。
numpy.append(arr, values, axis=None)

参数说明：
arr：输入的数组；
values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致；
axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，
    若 axis=1 则与其恰好相反，追加的值会被添加到列，而行数保持不变。
'''
print("----(2). numpy.append()----")
arr5 = np.array([[1, 2, 3], [4, 5, 6]])
print("arr5：", arr5)
# 向数组 arr5 添加元素
arr6 = np.append(arr5, [7, 8, 9])
print("arr6：", arr6)
# 沿轴 0 添加元素
arr7 = np.append(arr5, [[7, 8, 9]], axis=0)
print("arr7：", arr7)
# 沿轴 1 添加元素
arr8 = np.append(arr5, [[4, 5, 6], [7, 8, 9]], axis=1)
print("arr8：", arr8)
'''
arr5： [ [1 2 3]
         [4 5 6] ]
arr6： [1 2 3 4 5 6 7 8 9]
arr7： [ [1 2 3]
         [4 5 6]
         [7 8 9] ]
arr8： [ [1 2 3 4 5 6]
         [4 5 6 7 8 9] ]
'''

'''
(3). numpy.insert()
表示沿指定的轴，在给定索引值的前一个位置插入相应的值，如果没有提供轴，则输入数组被展开为一维数组。
numpy.insert(arr, obj, values, axis)

参数说明：
arr：要输入的数组
obj：表示索引值，在该索引值之前插入 values 值；
values：要插入的值；
axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，
    若 axis=1 则与其恰好相反，追加的值会被添加到列，而行数保持不变。
'''
print("----(3). numpy.insert()----")
arr9 = np.array([[1, 2], [3, 4], [5, 6]])
print("arr9：", arr9)
# 不提供axis的情况，会将数组展开
arr10 = np.insert(arr9, 3, [7, 8])
print("arr10：", arr10)
# 沿轴 0 垂直方向
arr11 = np.insert(arr9, 1, [7], axis=0)
print("arr11：", arr11)
# 沿轴 1 水平方向
arr12 = np.insert(arr9, 1, 7, axis=1)
print("arr12：", arr12)
'''
arr9： [ [1 2]
         [3 4]
         [5 6] ]
arr10： [1 2 3 7 8 4 5 6]
arr11： [[1 2]
         [7 7]
         [3 4]
         [5 6]]
arr12： [[1 7 2]
         [3 7 4]
         [5 7 6]]
'''

'''
(4). numpy.delete()
该方法表示从输入数组中删除指定的子数组，并返回一个新数组。
它与 insert() 函数相似，若不提供 axis 参数，则输入数组被展开为一维数组。
numpy.delete(arr, obj, axis)

参数说明：
arr：要输入的数组；
obj：整数或者整数数组，表示要被删除数组元素或者子数组；
axis：沿着哪条轴删除子数组。
'''
print("----(4). numpy.delete()----")
arr13 = np.arange(12).reshape(3, 4)
print("arr13：", arr13)
# 不提供axis参数情况
arr14 = np.delete(arr13, 5)
print("arr14：", arr14)
# 删除第2列
arr15 = np.delete(arr13, 1, axis=1)
print("arr15：", arr15)
# 删除经切片后的数组
arr16 = np.arange(10)
print("arr16：", arr16)
# np.s_[::2]，保留数组的偶数位置元素
arr17 = np.delete(arr16, np.s_[::2])
print("arr17：", arr17)
'''
arr13： [[ 0  1  2  3]
         [ 4  5  6  7]
         [ 8  9 10 11]]
arr14： [ 0  1  2  3  4  6  7  8  9 10 11]
arr15： [[ 0  2  3]
         [ 4  6  7]
         [ 8 10 11]]
arr16： [0 1 2 3 4 5 6 7 8 9]
arr17： [1 3 5 7 9]
'''

'''
(5). numpy.argwhere()
该函数返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标。
'''
print("----(5). numpy.argwhere()----")
arr18 = np.arange(9).reshape(3, 3)
print("arr18：", arr18)
# 返回所有大于 3 的元素索引,返回行列索引坐标
arr19 = np.argwhere(arr18 > 3)
print("arr19：", arr19)
'''
arr18： [[0 1 2]
 [3 4 5]
 [6 7 8]]
arr19： [[1 1]
 [1 2]
 [2 0]
 [2 1]
 [2 2]]
'''

'''
(6). numpy.unique()
用于删除数组中重复的元素，其语法格式如下：
numpy.unique(arr, return_index, return_inverse, return_counts)

参数说明：
arr：输入数组，若是多维数组则以一维数组形式展开；
return_index：如果为 True，则返回新数组元素在原数组中的位置（索引）；
return_inverse：如果为 True，则返回原数组元素在新数组中的位置（索引）；
return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数。
'''
print("----(6). numpy.unique()----")
arr20 = np.array([3, 2, 3, 2, 7, 5, 6, 8, 5, 9])
print("arr20：", arr20)
# 对arr20数组的去重
arr20_unique = np.unique(arr20)
print("arr20_unique：", arr20_unique)
# 数组去重后的索引数组
arr20_unique, indices = np.unique(arr20, return_index=True)
# 返回新数组元素在原数组中的位置（索引）
print("indices：", indices)
# 去重数组的下标
arr20_unique, inverse = np.unique(arr20, return_inverse=True)
# 返回原数组元素在新数组中的位置（索引）
print("inverse：", inverse)
# 返回去重元素的重复数量
arr20_unique, counts = np.unique(arr20, return_counts=True)
# 返回去重后的数组元素在原数组中出现的次数
print("counts：", counts)
'''
arr20： [3 2 3 2 7 5 6 8 5 9]
arr20_unique： [2 3 5 6 7 8 9]
indices： [1 0 5 6 4 7 9]
inverse： [1 0 1 0 4 2 3 5 2 6]
counts： [2 2 2 1 1 1 1]
'''