代码收藏家 Python numpy库学习第2天
续接第1天的内容
10.数组操作
10.1数组变维
4种函数：reshape，flat，flatten，ravel
| 函数名称 | 函数介绍 |
|---|---|
| reshape | 在不改变数组元素的条件下，修改数组的形状 |
| flat属性 | 返回是一个迭代器，可以用 for 循环遍历其中的每一个元素 |
| flatten | 以一维数组的形式返回一份数组的副本，对副本的操作不会影响到原数组 |
| ravel | 返回一个连续的扁平数组（即展开的一维数组），与 flatten不同，它返回的是数组视图（修改视图会影响原数组） |
示例代码如下：
import numpy as np
arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).reshape(2,5)
print(arr1)
arr2 = arr1.flat
for i in arr2:
print(i,end=' ')
print( )
arr3 = arr1.flatten()
arr3[0]=100
print(arr3)
arr4 = arr1.ravel()
arr4[0]=100
print(arr4)
print(arr1)
#结果展示：
"""
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
1
2
3
4
5
6
7
8
9
10
[100 2 3 4 5 6 7 8 9 10]
[100 2 3 4 5 6 7 8 9 10]
[[100 2 3 4 5]
[ 6 7 8 9 10]]
"""
#结果展示：
"""
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
1
2
3
4
5
6
7
8
9
10
[100 2 3 4 5 6 7 8 9 10]
[100 2 3 4 5 6 7 8 9 10]
[[100 2 3 4 5]
[ 6 7 8 9 10]]
"""对于flatten()和ravel()，可以设置order参数指定数组的展开顺序，
C'：按行优先顺序展开（默认）。
'F'：按列优先顺序展开。
'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。
'K'：按元素在内存中的顺序展开。
10.2 数组转置
| 函数名称 | 说明 |
|---|---|
| transpose | 将数组的维度值进行对换，比如二维数组维度(2,4)使用该方法后为(4,2) |
| ndarray.T | 与 transpose 方法相同 |
示例代码如下：
import numpy as np
arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).reshape(2,5)
print(arr1)
print("---------------------------")
arr2 = arr1.T
print(arr2)
print("---------------------------")
arr3 = np.transpose(arr1)
print(arr3)
"""
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
---------------------------
[[ 1 6]
[ 2 7]
[ 3 8]
[ 4 9]
[ 5 10]]
---------------------------
[[ 1 6]
[ 2 7]
[ 3 8]
[ 4 9]
[ 5 10]]
"""10.3 修改数组维度
多维数组（也称为 ndarray）的维度（或轴）是从外向内编号的。这意味着最外层的维度是轴0，然后是轴1，依此类推。
| 函数名称 | 参数 | 说明 |
|---|---|---|
| expand_dims(arr, axis) | arr：输入数组 axis：新轴插入的位置 | 在指定位置插入新的轴(相对于结果数组而言)，从而扩展数组的维度 |
| squeeze(arr, axis) | arr：输入数的组 axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，若为 None，则删除数组维度中所有为 1 的项 | 删除数组中维度为 1 的项 |
expand_dims()代码示例：
import numpy as np
arr1 = np.array([1,2,3])
print(arr1.shape)
arr2 = np.expand_dims(arr1, axis=0)
print(arr2)
print(arr2.shape)
arr3 = np.expand_dims(arr1, axis=1)
print(arr3)
print(arr3.shape)
"""
(3,)
[[1 2 3]]
(1, 3)
[[1]
[2]
[3]]
(3, 1)
"""squeeze()代码示例，这里需要分情况以帮助理解squeeze()：
import numpy as np
arr1 = np.array([[1,2,3],[4,5,6]]).reshape(1,6)
print(arr1.shape)
arr2 = np.squeeze(arr1, axis=0)
print(arr2)
print(arr2.shape)
arr3 = np.squeeze(arr1, axis=1)
print(arr3)
print(arr3.shape)
"""
File "E:\code\python-demo\Dec 25th\demo 1.py", line 9, in <module>
arr3 = np.squeeze(arr1, axis=1)
File "C:\Users\DELL\.conda\envs\python-basic\lib\site-packages\numpy\_core\fromnumeric.py", line 1632, in squeeze
return squeeze(axis=axis)
ValueError: cannot select an axis to squeeze out which has size not equal to one
(1, 6)
[1 2 3 4 5 6]
(6,)
"""这里报错是因为squeeze函数要求axis指定的维度值必须为1，而列的维度值为6。
import numpy as np
arr1 = np.array([[1,2,3],[4,5,6]]).reshape(6,1)
print(arr1.shape)
arr2 = np.squeeze(arr1, axis=1)
print(arr2)
print(arr2.shape)
arr3 = np.squeeze(arr1, axis=0)
print(arr3)
print(arr3.shape)
"""
(6, 1)
[1 2 3 4 5 6]
(6,)
Traceback (most recent call last):
File "E:\code\python-demo\Dec 25th\demo 1.py", line 9, in <module>
arr3 = np.squeeze(arr1, axis=0)
File "C:\Users\DELL\.conda\envs\python-basic\lib\site-packages\numpy\_core\fromnumeric.py", line 1632, in squeeze
return squeeze(axis=axis)
ValueError: cannot select an axis to squeeze out which has size not equal to one
"""这里报错同上，即arr1数组的行维度值为6，不能满足squeeze中axis=1的条件
10.4 连接数组
| 函数名称 | 参数 | 说明 |
|---|---|---|
| hstack(tup) | tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组 | 按水平顺序堆叠序列中数组（列方向） |
| vstack(tup) | tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组 | 按垂直方向堆叠序列中数组（行方向） |
hstack函数要求堆叠的数组在水平方向（行）上具有相同的形状。如果行数不一致，hstack() 将无法执行，并会抛出 ValueError 异常。
vstack() 要求堆叠的数组在垂直方向（列）上具有相同的形状。如果列数不一致，将无法执行堆叠操作。
vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致，将无法执行堆叠操作。
这里h指horizontal，v指vertical，我猜。
代码示例如下：
import numpy as np
arr1 = np.array([1,2,3]).reshape(1,3)
arr2 = np.array([1,2,3,4,5,6,7,8,9]).reshape(3,3)
arr3 = np.vstack((arr1,arr2))
print(arr3)
print("-----------------------------")
arr1 = np.array([1,2,3]).reshape(3,1)
arr2 = np.array([1,2,3,4,5,6,7,8,9]).reshape(3,3)
arr3 = np.hstack((arr1,arr2))
print(arr3)
"""
[[1 2 3]
[1 2 3]
[4 5 6]
[7 8 9]]
-----------------------------
[[1 1 2 3]
[2 4 5 6]
[3 7 8 9]]
"""10.5 分割数组
| 函数名称 | 参数 | 说明 |
|---|---|---|
| hsplit(ary, indices_or_sections) | ary：原数组 indices_or_sections：按列分割的索引位置 | 将一个数组水平分割为多个子数组（按列） |
| vsplit(ary, indices_or_sections) | ary：原数组 indices_or_sections：按行分割的索引位置 | 将一个数组垂直分割为多个子数组（按行） |
hsplit，取到每一行的部分内容
vsplit，取到每一列的部分内容
书上的代码示例：
import numpy as np
'''
hsplit 函数：
1、将一个数组水平分割为多个子数组（按列）
2、ary：原数组
3、indices_or_sections：按列分割的索引位置
'''
# 创建一个二维数组
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
# 使用 np.hsplit 将数组分割成三个子数组
# 分割点在索引1和3处，这意味着：
# 第一个子数组将包含从第0列到索引1（不包括索引1）的列，即第0列。
# 第二个子数组将包含从索引1（包括索引1）到索引3（不包括索引3）的列，即第1列到第2列。
# 第三个子数组将包含从索引3（包括索引3）到末尾的列，即第3列。
result = np.hsplit(arr, [1, 3])
# 查看结果
print("第一个子数组:\n", result[0]) # 输出包含第0列的子数组
print("第二个子数组:\n", result[1]) # 输出包含第1列和第2列的子数组
print("第三个子数组:\n", result[2]) # 输出包含第3列的子数组
"""
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
第一个子数组:
[[1]
[5]
[9]]
第二个子数组:
[[ 2 3]
[ 6 7]
[10 11]]
第三个子数组:
[[ 4]
[ 8]
[12]]
"""10.6 矩阵运算
1.np.dot
是一个通用的点积函数，适用于多种维度的数组。
对于二维数组（矩阵），
np.dot等价于矩阵乘法。对于一维数组（向量），
np.dot计算的是向量的点积（内积）。
2.np.matmul
是专门用于矩阵乘法的函数，适用于二维及更高维度的数组。
mat指matrix（矩阵），mul指multiple（乘法）
代码示例：
import numpy as np
a = np.array([[1, 2],
[3, 4]])
b = np.array([[5, 6],
[7, 8]])
result = np.matmul(a, b)
print(result)
"""
[[19 22]
[43 50]]
"""3.np.linalg.det
计算一个方阵（行数和列数相等的矩阵）的行列式。
det指determinant(行列式)
代码示例：
import numpy as np
arr1 = np.array([1, 0, 0, 4, 5, 0, 7, 8, 9]).reshape(3, 3)
print(arr1)
det_arr1 = np.linalg.det(arr1)
print(det_arr1)
"""
[[1 0 0]
[4 5 0]
[7 8 9]]
44.99999999999999
"""结果为44.999……是由于浮点数运算的精度限制，计算结果可能会出现非常小的误差。
11.数组元素的增删改查
11.1 resize
| 函数名称 | 参数 | 说明 |
|---|---|---|
| resize(a, new_shape) | a：操作的数组 new_shape：返回的数组的形状，如果元素数量不够，重复数组元素来填充新的形状 | 返回指定形状的新数组 |
代码示例：
import numpy as np
array_one = np.arange(6).reshape(2, 3)
print(array_one)
print('resize 后数组：\n', np.resize(array_one, (3, 4)))
# 输出：
# [[0 1 2 3]
# [4 5 0 1]
# [2 3 4 5]]11.2 append
| 函数名称 | 参数 | 说明 |
|---|---|---|
| append(arr, values, axis=None) | arr：输入的数组 values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反 | 在数组的末尾添加值，返回一个一维数组 |
示例代码：
import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([7,8,9]).reshape(1,3)
arr3 = np.append(arr1, arr2,axis=0)
print(arr3)
print("----------------------")
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([7,8,9,10]).reshape(2,2)
arr3 = np.append(arr1, arr2,axis=1)
print(arr3)
"""
[[1 2 3]
[4 5 6]
[7 8 9]]
----------------------
[[ 1 2 3 7 8]
[ 4 5 6 9 10]]
"""11.3 insert
| 函数名称 | 参数 | 说明 |
|---|---|---|
| insert(arr, obj, values, axis) | arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 values：要插入的值 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反 | 沿规定的轴将元素值插入到指定的元素前 |
如果obj为-1，表示插入在倒数第一个元素之前，不是在最后一列。
代码示例：
import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([7,8,9]).reshape(1,3)
arr3 = np.insert(arr1,[0,-1] ,arr2,axis=0)
print(arr3)
print("----------------------")
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([7,8]).reshape(2,1)
arr3 = np.insert(arr1,[0,-1] ,arr2,axis=1)
print(arr3)
print("----------------------")
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([7,8]) #等同于np.array([7,8]).reshape(1,2)
arr3 = np.insert(arr1,[0,-1] ,arr2,axis=1)
print(arr3)
"""
[[7 8 9]
[1 2 3]
[7 8 9]
[4 5 6]]
----------------------
[[7 1 2 7 3]
[8 4 5 8 6]]
----------------------
[[7 1 2 8 3]
[7 4 5 8 6]]
"""注意到：第二种写法和第三种写法的区别，写法2是直接让2*1的数组插入了arr1索引为0和-2的位置；写法3是让1*2的数组分列广播到对应索引的位置。
11.4 delete
| 函数名称 | 参数 | 说明 |
|---|---|---|
| delete(arr, obj, axis) | arr：输入的数组 obj：表示索引值，要删除数据的索引 axis：默认为 None，返回的是一维数组；当 axis =0 时，删除指定的行，若 axis=1 则与其恰好相反 | 删掉某个轴上的子数组，并返回删除后的新数组 |
一维数组：
import numpy as np
# 创建一个 NumPy 数组
arr = np.array([1, 2, 3, 4, 5, 6])
# 删除索引为 2 和 4 的元素
new_arr = np.delete(arr, [2, 4])
print(new_arr)
"""
[1 2 4 6]
"""二维数组：
import numpy as np
def delete_test():
array_one = np.arange(6).reshape(2,3)
print('原数组：\n', array_one)
array_two = np.delete(array_one,1,axis=None)
print('delete 后数组 axis=None：\n', array_two)
array_three = np.delete(array_one,1, axis=0)
print('delete 后数组 axis=0：\n', array_three)
array_three = np.delete(array_one, 1, axis=1)
print('delete 后数组 axis=1：\n', array_three)
delete_test()
"""
原数组：
[[0 1 2]
[3 4 5]]
delete 后数组 axis=None：
[0 2 3 4 5]
delete 后数组 axis=0：
[[0 1 2]]
delete 后数组 axis=1：
[[0 2]
[3 5]]
"""11.5 unique
| 函数名称 | 参数 | 说明 |
|---|---|---|
| unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None) | ar：输入的数组 return_index：如果为 True，则返回新数组元素在原数组中的位置（索引） return_inverse：如果为 True，则返回原数组元素在新数组中的位置（逆索引） return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数 | 删掉某个轴上的子数组，并返回删除后的新数组 |
代码示例：
import numpy as np
# 创建一个一维数组
arr = np.array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4])
# 使用 np.unique 查找唯一元素及其计数
unique_elements, counts = np.unique(arr, return_counts=True)
print(unique_elements)
# 输出:
# [1 2 3 4]
print(counts)
# 输出:
# [3 3 3 4]12.统计函数
12.1 amin() 和 amax()
计算数组沿指定轴的最小值与最大值，并以数组形式返回
对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向
'''
numpy.amin() 和 numpy.amax() 函数：
1、计算数组沿指定轴的最小值与最大值，并以数组形式返回
2、对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向
'''
import numpy as np
def amin_amax_test():
array_one = np.array([[1, 23, 4, 5, 6], [1, 2, 333, 4, 5]])
print('原数组元素：\n', array_one)
print('原数组水平方向最小值：\n', np.amin(array_one, axis=1))
print('原数组水平方向最大值：\n', np.amax(array_one, axis=1))
print('原数组垂直方向最小值：\n', np.amin(array_one, axis=0))
print('原数组垂直方向最大值：\n', np.amax(array_one, axis=0))
amin_amax_test()
"""
原数组元素：
[[ 1 23 4 5 6]
[ 1 2 333 4 5]]
原数组水平方向最小值：
[1 1]
原数组水平方向最大值：
[ 23 333]
原数组垂直方向最小值：
[1 2 4 4 5]
原数组垂直方向最大值：
[ 1 23 333 5 6]
"""水平方向是列与列之间的关系，垂直方向是行与行之间的关系
12.2 ptp()
计算数组元素中最值之差值，即最大值 – 最小值
对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向
import numpy as np
# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 使用 np.ptp 计算峰峰值
ptp_value = np.ptp(arr)
print(ptp_value)
# 输出:
# 5
# 使用 np.ptp 按行计算峰峰值
ptp_values_row = np.ptp(arr, axis=1)
# 使用 np.ptp 按列计算峰峰值
ptp_values_col = np.ptp(arr, axis=0)
print(ptp_values_row)
# 输出:
# [2 2]
print(ptp_values_col)
# 输出:
# [3 3 3]
12.3 median()
用于计算中位数，中位数是指将数组中的数据按从小到大的顺序排列后，位于中间位置的值。如果数组的长度是偶数，则中位数是中间两个数的平均值。
import numpy as np
# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 使用 np.median 计算中位数
median_value = np.median(arr,axis=None)
print(median_value)
# 输出:
# 3.5
# 使用 np.median 按行计算中位数
median_values_row = np.median(arr, axis=1)
# 使用 np.median 按列计算中位数
median_values_col = np.median(arr, axis=0)
print(median_values_row)
# 输出:
# [2. 5.]
print(median_values_col)
# 输出:
# [2.5 3.5 4.5]12.4 mean()
沿指定的轴，计算数组中元素的算术平均值（即元素之总和除以元素数量）
import numpy as np
# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5])
# 使用 np.mean 计算平均值
mean_value = np.mean(arr)
print(mean_value)
# 输出:
# 3.0
# 创建一个二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
# 使用 np.mean 计算平均值
mean_value = np.mean(arr)
print(mean_value)
# 输出:
# 3.5
# 使用 np.mean 按行计算平均值
mean_values_row = np.mean(arr, axis=1)
# 使用 np.mean 按列计算平均值
mean_values_col = np.mean(arr, axis=0)
print(mean_values_row)
# 输出:
# [2. 5.]
print(mean_values_col)
# 输出:
# [2.5 3.5 4.5]
12.5、average()
加权平均值是将数组中各数值乘以相应的权数，然后再对权重值求总和，最后以权重的总和除以总的单位数（即因子个数）；根据在数组中给出的权重，计算数组元素的加权平均值。该函数可以接受一个轴参数 axis，如果未指定，则数组被展开为一维数组。
其中 xi是数组中的元素，wi是对应的权重。
如果所有元素的权重之和等于1，则表示为数学中的期望值。
import numpy as np
def np_average():
# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5])
# 创建权重数组
weights = np.array([0.1, 0.2, 0.3, 0.2, 0.2])
# 使用 np.average 计算加权平均值
average_value = np.average(arr, weights=weights)
print(average_value)
# 输出:
# 3.2
np_average()作者：X天地不仁
