python三大库之-- numpy（三）

python三大库之-- numpy（三）

---

九，数组操作

9.1数组变维

函数名称	函数介绍
reshape	在不改变数组元素的条件下，修改数组的形状
flat属性	返回是一个迭代器，可以用 for 循环遍历其中的每一个元素
flatten	以一维数组的形式返回一份数组的副本，对副本的操作不会影响到原数组
ravel	返回一个连续的扁平数组（即展开的一维数组），与 flatten不同，它返回的是数组视图（修改视图会影响原数组）

9.1.1 reshape

reshape() 函数允许你在不改变数组数据的情况下，改变数组的维度。

reshape() 返回的是一个新的数组，原数组的形状不会被修改。reshape() 可以用于多维数组，例如将一个一维数组重塑为二维数组。

但是，reshape后产生的新数组是原数组的一个视图，即它与原数组共享相同的数据，但可以有不同的形状或维度，且对视图的修改会直接影响原数组。

元素总数必须匹配：新形状中的元素总数必须与原数组中的元素总数相同。

例如，一个长度为6的一维数组可以被重塑为 (2, 3) 或 (3, 2)，表示原数组被重塑为2行3列或3行2列的数组，但不能被重塑为 (2, 2)。

案例：

将数组改变为二维数组：

a= np.array([1,2,3,4,5,6])
a1 = a.reshape(3,2)
print(a1)

a2 = a.reshape(2,-1)
print(a2)

[[1 2]
 [3 4]
 [5 6]]
[[1 2 3]
 [4 5 6]]

9.1.2 flat

返回一个一维迭代器，用于遍历数组中的所有元素。无论数组的维度如何，ndarray.flat属性都会将数组视为一个扁平化的一维数组，按行优先的顺序遍历所有元素。

#flat属性：返回一个迭代器
a= np.arange(1,10).reshape(3,3)
for i in a.flat:
    print(i,end=' ')
print()

1 2 3 4 5 6 7 8 9 

9.1.3 flatten()

用于将多维数组转换为一维数组。flatten() 返回的是原数组的一个拷贝，因此对返回的数组进行修改不会影响原数组。

#flatten()：返回一个新数组，修改不会改变原数组
a= np.arange(1,10).reshape(3,3)
a1 = a.flatten()
print(a1)
a1[0]= 100
print(a1)
print(a)

[1 2 3 4 5 6 7 8 9]
[100   2   3   4   5   6   7   8   9]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

9.1.4 ravel()

用于将多维数组转换为一维数组。与 flatten() 不同，ravel() 返回的是原数组的一个视图（view），而不是副本。因此，对返回的数组进行修改会影响原数组。

#ravel()：返回一个新数组，修改会改变原数组
a= np.arange(1,10).reshape(3,3)
a1 = a.ravel()
print(a1)
a1[0]= 100
print(a1)
print(a)

[1 2 3 4 5 6 7 8 9]
[100   2   3   4   5   6   7   8   9]
[[100   2   3]
 [  4   5   6]
 [  7   8   9]]

9.2 数组转置

函数名称	说明
transpose	将数组的维度值进行对换，比如二维数组维度(2,4)使用该方法后为(4,2)
ndarray.T	与 transpose 方法相同

#数组转置
#T 属性：返回转置后的数组
#transpose()：返回转置后的数组
a= np.array([[1,2,3],[4,5,6]])
print(a)
print(a.T)
print(a.transpose())

[[1 2 3]
 [4 5 6]]
[[1 4]
 [2 5]
 [3 6]]
[[1 4]
 [2 5]
 [3 6]]

9.3 升维和降维

多维数组（也称为 ndarray）的维度（或轴）是从外向内编号的。这意味着最外层的维度是轴0，然后是轴1，依此类推。

函数名称	参数	说明
expand_dims(arr, axis)	arr：输入数组 axis：新轴插入的位置	在指定位置插入新的轴(相对于结果数组而言)，从而扩展数组的维度
squeeze(arr, axis)	arr：输入数的组 axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，若为 None，则删除数组维度中所有为 1 的项	删除数组中维度为 1 的项

9.3.1降维

a = np.array([1,2,3])
print(a.shape)

b= np.expand_dims(a,axis=0)
print(b.shape)

print(b)

b= np.expand_dims(a,axis=1)
print(b.shape)
print(b)

(3,)
(1, 3)
[[1 2 3]]
(3, 1)
[[1]
 [2]
 [3]]

9.3.2升维降维适应广播操作

#升维降维适应广播操作
a = np.array([1,2,3])
b = np.array([4,5,6])

c=np.expand_dims(a,axis=0)
print(c)

d=c+b
print(d)

[[1 2 3]]
[[5 7 9]]

9.3.3删除数组维度

#squeeze()：删除数组的某一维，如果某一维长度为1，则删除该维'
#axis：按照轴方向降维，0-按最外层降维，1-按次外层降维
#假设二维数组，axis=0，则按行降维，axis=1，则按列降维

a = np.array([[[1,2,3]]])
print(a.shape)
a1 = np.squeeze(a,axis=0)
print(a1)
a1 = np.squeeze(a,axis=1)
print(a1)
#该层的轴不存在，则报错
# a1 = np.squeeze(a,axis=2)
# print(a1)

代码/数组操作.py
(1, 1, 3)
[[1 2 3]]
[[1 2 3]]

9.4连接数组

函数名称	参数	说明
hstack(tup)	tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组	按水平顺序堆叠序列中数组（列方向）
vstack(tup)	tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组	按垂直方向堆叠序列中数组（行方向）

• hstack函数要求堆叠的数组在垂直方向（行）上具有相同的形状。如果行数不一致，hstack() 将无法执行，并会抛出 ValueError 异常。

• vstack() 要求堆叠的数组在水平方向（列）上具有相同的形状。如果列数不一致，将无法执行堆叠操作。

• vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致，将无法执行堆叠操作。

#数组拼接
#按轴方向拼接
a = np.array([[1,2],[3,4]])
b = np.array([[5],[6]])

c=np.hstack((a,b))
print(c)
#按行方向拼接
a= np.array([[1,2],[3,4]])
b= np.array([[5,6]])

c=np.vstack((a,b))
print(c)

[[1 2 5]
 [3 4 6]]
[[1 2]
 [3 4]
 [5 6]]

9.5 数组切割

函数名称	参数	说明
hsplit(ary, indices_or_sections)	ary：原数组 indices_or_sections：按列分割的索引位置	将一个数组水平分割为多个子数组（按列）
vsplit(ary, indices_or_sections)	ary：原数组 indices_or_sections：按行分割的索引位置	将一个数组垂直分割为多个子数组（按行）

#切割数组
#水平方向
a = np.array([[1,2,3],[4,5,6]])
a1=np.hsplit(a,[1,2])
print(a1[0])
print(a1[1])
print(a1[2])

#竖直方向
a = np.array([[1,2,3],[4,5,6]])
a1=np.vsplit(a,[1])
print(a1[0])
print(a1[1])

[[1]
 [4]]
[[2]
 [5]]
[[3]
 [6]]
[[1 2 3]]
[[4 5 6]]

9.6 矩阵运算

np.dot

是一个通用的点积函数，适用于多种维度的数组。

• 对于二维数组（矩阵），np.dot 等价于矩阵乘法。
• 对于一维数组（向量），np.dot 计算的是向量的点积（内积）。

#矩阵乘法
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])

c=np.dot(a,b)
print(c)

[[19 22]
 [43 50]]

十，数组元素的增删查改

10.1 resize

函数名称	参数	说明
resize(a, new_shape)	a：操作的数组 new_shape：返回的数组的形状，如果元素数量不够，重复数组元素来填充新的形状	返回指定形状的新数组

a= np.array([[1,2,3],[4,5,6]])
b= np.resize(a,(2,2))
print(b)    
c= np.resize(a,(4,2))
print(c)
d= np.resize(a,(3,4))
print(d)

[[1 2]
 [3 4]]
[[1 2]
 [3 4]
 [5 6]
 [1 2]]
[[1 2 3 4]
 [5 6 1 2]
 [3 4 5 6]]

10.2 append

函数名称	参数	说明
append(arr, values, axis=None)	arr：输入的数组 values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反	在数组的末尾添加值，返回一个一维数组

a= np.array([1,2,3])
b= np.append(a,4)
print(b)

c= np.array([[1,2,3],[4,5,6]])
d= np.append(c,[7,8,9])
print(d)
d= np.append(c,[[7,8,9]],axis=0)
print(d)
e = np.append(c,[[7,8,9],[10,11,12]],axis=1)
print(e)

[1 2 3 4]
[1 2 3 4 5 6 7 8 9]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

10.3 insert

函数名称	参数	说明
insert(arr, obj, values, axis)	arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 values：要插入的值 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反	沿规定的轴将元素值插入到指定的元素前

#insert(),在数组指定位置插入元素
a= np.array([1,2,3])
b= np.insert(a,1,4)
print(b)
c= np.array([[1,2,3],[4,5,6]])
d= np.insert(c,1,[7,8,9],axis=0)
print(d)
#行方向自动广播
e= np.insert(c,1,[[7]],axis=0)
print(e)
#列方自动广播
f= np.insert(c,1,[[7]],axis=1)
print(f)

[1 4 2 3]
[[1 2 3]
 [7 8 9]
 [4 5 6]]
[[1 2 3]
 [7 7 7]
 [4 5 6]]
[[1 7 2 3]
 [4 7 5 6]]

10.4 delete

函数名称	参数	说明
delete(arr, obj, axis)	arr：输入的数组 obj：表示索引值，要删除数据的索引 axis：默认为 None，返回的是一维数组；当 axis =0 时，删除指定的行，若 axis=1 则与其恰好相反	删掉某个轴上的子数组，并返回删除后的新数组

#delete(),删除数组指定位置的元素
a= np.array([1,2,3,4,5,6,7,8,9])
b= np.delete(a,[1,5])
print(b)

c= np.array([[1,2,3],[4,5,6],[7,8,9]])
d= np.delete(c,[1,2],axis=0)
print(d)

e= np.delete(c,[1,2],axis=1)
print(e)

[1 3 4 5 7 8 9]
[[1 2 3]]
[[1]
 [4]
 [7]]

10.5 argwhere

返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标

#argwhere(),默认返回非0的索引
a= np.arange(9).reshape(3,3)
b= np.argwhere(a)
print(b)

c= np.argwhere(a>5)
print(c)

#argmax(),返回最大值的索引
a= np.arange(9).reshape(3,3)
b= np.argmax(a)
print(b)

#where
a= np.arange(9).reshape(3,3)
b= np.where(a>5)
print(b)

[[0 1]
 [0 2]
 [1 0]
 [1 1]
 [1 2]
 [2 0]
 [2 1]
 [2 2]]
[[2 0]
 [2 1]
 [2 2]]
8

10.6 unique

函数名称	参数	说明
unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)	ar：输入的数组 return_index：如果为 True，则返回新数组元素在原数组中的位置（索引） return_inverse：如果为 True，则返回原数组元素在新数组中的位置（逆索引） return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数	删掉某个轴上的子数组，并返回删除后的新数组

#unique(),返回不重复的元素
a= np.array([1,2,3,4,5,6,1,2,3,4,5,6])
b= np.unique(a)
print(b)

[1 2 3 4 5 6]

十一，统计函数

11.1 amin() 和 amax()

• 计算数组沿指定轴的最小值与最大值，并以数组形式返回
• 对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向

a=np.array([[1,36,2,54,6],[1,7,66,4,5]])
b=np.amin(a,axis=0)
print(b)
c=np.amax(a,axis=0)
print(c)
d=np.amax(a,axis=1)
print(d)
e=np.amin(a,axis=1)
print(e)

[1 7 2 4 5]
[ 1 36 66 54  6]
[54 66]
[1 1]

11.2 ptp()

• 计算数组元素中最值之差值，即最大值 - 最小值
• 对于二维数组来说，axis=1 表示沿着水平方向，axis=0 表示沿着垂直方向

a=np.array([[1,36,2,54,6],[1,7,66,4,5]])
b= np.ptp(a,axis=0)
print(b)
c= np.ptp(a,axis=1)
print(c)
d= np.ptp(a)

[ 0 29 64 50  1]
[53 65]

11.3 median()

用于计算中位数，中位数是指将数组中的数据按从小到大的顺序排列后，位于中间位置的值。如果数组的长度是偶数，则中位数是中间两个数的平均值。

#中位数
a=np.array([1,36,2,54,6])
b=np.median(a,axis=0)
print(b)

6.0

11.4 mean()

沿指定的轴，计算数组中元素的算术平均值（即元素之总和除以元素数量）

#mean()算数平均值
a= np.array([[1,2,3],[4,5,6]])
b=np.mean(a,axis=0)


print(b)
b=np.mean(a,axis=1)
print(b)

[2.5 3.5 4.5]
[2. 5.]

11.5 average()

加权平均值是将数组中各数值乘以相应的权数，然后再对权重值求总和，最后以权重的总和除以总的单位数（即因子个数）；根据在数组中给出的权重，计算数组元素的加权平均值。该函数可以接受一个轴参数 axis，如果未指定，则数组被展开为一维数组。
$$加权平均值=\frac{{\sum }_{i=1}^n(x_i\cdot w_i)}{{\sum }_{i=1}^n{w}_i}$$
其中 xi是数组中的元素，wi是对应的权重。

如果所有元素的权重之和等于1，则表示为数学中的期望值。

a= np.array([[1,2,3],[4,5,6]])
b=np.average(a,axis=0)
print(b)

[2.5 3.5 4.5]

11.6 var()

在 NumPy 中，计算方差时使用的是统计学中的方差公式，而不是概率论中的方差公式，主要是因为 NumPy 的设计目标是处理实际数据集，而不是概率分布。

np.var 函数默认计算的是总体方差（Population Variance），而不是样本方差（Sample Variance）。

总体方差：

对于一个总体数据集 X={x1,x2,…,xN}，总体方差的计算公式为：
$${\sigma }^2=\frac{1}{N}\sum _{i=1}^N(x_i-\mu {)}^2$$
其中：

• N是总体数据点的总数。
• μ是总体的均值。

a= np.array([[1,2,3],[4,5,6]])
b=np.var(a,axis=0)
print(b)

[2.25 2.25 2.25]

样本方差：

对于一个样本数据集 X={x1,x2,…,xn}，样本方差 的计算公式为：
$$s^2=\frac{1}{n-1}\sum _{i=1}^n(x_i-\overline{x}{)}^2$$
其中：

• n是样本数据点的总数。
• xˉ是样本的均值。

在样本数据中，样本均值的估计会引入一定的偏差。通过使用 n−1作为分母，可以校正这种偏差，得到更准确的总体方差估计。

#样本方差
a= np.array([[1,2,3],[4,5,6]])
b= np.var(a,axis=0,ddof=1)
print(b)

[4.5 4.5 4.5]

11.7 std()

标准差是方差的算术平方根，用来描述一组数据平均值的分散程度。若一组数据的标准差较大，说明大部分的数值和其平均值之间差异较大；若标准差较小，则代表这组数值比较接近平均值

#std()标准差
a= np.array([[1,2,3],[4,5,6]])
b=np.std(a,axis=0)
print(b)

[1.5 1.5 1.5]