内容目录
继续numpy的基础使用
包含矩阵的拼接、分割、转置和算术运算等
# 数组的拼接
# 数组的水平拼接/数组的水平拼接
# 通过hstack函数可以将两个或多个数组水平组合起来形成一个数组，如果拼接的行和列数目不同，则会报错
# 通过vstack函数可以将两个或多个数组垂直组合起来形成一个数组，如果拼接的行和列数目不同，则会报错
# 而concatenate可以实现：连接沿现有的轴的数组序列，格式np.concatenate((a1,a2,...),axis),a1,a2...为相同类型的数组，axis指沿着他连接数组的轴，默认为0
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
print(a)
b=np.array([['a','b','c'],['d','e','f']])
print(b)
print('x 轴方向及垂直堆叠')
print(np.vstack([a,b]))
print('y 轴方向及水平堆叠')
print(np.hstack([a,b]))
a=np.array([[1,2,3],[4,5,6]])
print(a)
b=np.array([['a','b','c'],['d','e','f']])
print(b)
print(np.concatenate([a,b]))
print('垂直方向拼接 相当于 vstack')
print(np.concatenate([a,b],axis=0))
print('水平方向拼接 相当于 hstack')
print(np.concatenate([a,b],axis=1))[[1 2 3]
[4 5 6]]
[['a' 'b' 'c']
['d' 'e' 'f']]
x 轴方向及垂直堆叠
[['1' '2' '3']
['4' '5' '6']
['a' 'b' 'c']
['d' 'e' 'f']]
y 轴方向及水平堆叠
[['1' '2' '3' 'a' 'b' 'c']
['4' '5' '6' 'd' 'e' 'f']]
[[1 2 3]
[4 5 6]]
[['a' 'b' 'c']
['d' 'e' 'f']]
[['1' '2' '3']
['4' '5' '6']
['a' 'b' 'c']
['d' 'e' 'f']]
垂直方向拼接 相当于 vstack
[['1' '2' '3']
['4' '5' '6']
['a' 'b' 'c']
['d' 'e' 'f']]
水平方向拼接 相当于 hstack
[['1' '2' '3' 'a' 'b' 'c']
['4' '5' '6' 'd' 'e' 'f']]# 数组的分割
# numpy.split方法沿特定的轴将数组分割为子数组，格式：numpy.split(ary,indicess_or_sections,axis)
# arry：被分割的数组。
# indices_or_sections： 如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置。
# axis： 沿着哪个维度进行切分，默认为 0，横向切分。为 1 时，纵向切分。
import numpy as np
x=np.arange(1,9)
a=np.split(x,4)
print(a)
print(a[0])
print(a[1])
print(a[2])
print(a[3])
#传递数组进行分隔
print(x)
b=np.split(x,[3,5]) # 若这里是数组的话，比如这里的的[3.5]，则表示切割成[:3],[3,5],[5:]三份
print(b)
print(help(np.split)) # 刚刚不理解用数组分割的使用，在jupyter notebook中这样看帮助[array([1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]
[1 2]
[3 4]
[5 6]
[7 8]
[1 2 3 4 5 6 7 8]
[array([1, 2, 3]), array([4, 5]), array([6, 7, 8])]
Help on _ArrayFunctionDispatcher in module numpy:
split(ary, indices_or_sections, axis=0)
Split an array into multiple sub-arrays as views into ary.
Parameters
----------
ary : ndarray
Array to be divided into sub-arrays.
indices_or_sections : int or 1-D array
If indices_or_sections is an integer, N, the array will be divided
into N equal arrays along axis. If such a split is not possible,
an error is raised.
If indices_or_sections is a 1-D array of sorted integers, the entries
indicate where along axis the array is split. For example,
`[2, 3] would, for axis=0`, result in
- ary[:2]
- ary[2:3]
- ary[3:]
If an index exceeds the dimension of the array along axis,
an empty sub-array is returned correspondingly.
axis : int, optional
The axis along which to split, default is 0.
Returns
-------
sub-arrays : list of ndarrays
A list of sub-arrays as views into ary.
Raises
------
ValueError
If indices_or_sections is given as an integer, but
a split does not result in equal division.
See Also
--------
array_split : Split an array into multiple sub-arrays of equal or
near-equal size. Does not raise an exception if
an equal division cannot be made.
hsplit : Split array into multiple sub-arrays horizontally (column-wise).
vsplit : Split array into multiple sub-arrays vertically (row wise).
dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
concatenate : Join a sequence of arrays along an existing axis.
stack : Join a sequence of arrays along a new axis.
hstack : Stack arrays in sequence horizontally (column wise).
vstack : Stack arrays in sequence vertically (row wise).
dstack : Stack arrays in sequence depth wise (along third dimension).
Examples
--------
>>> x = np.arange(9.0)
>>> np.split(x, 3)
[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])]
>>> x = np.arange(8.0)
>>> np.split(x, [3, 5, 6, 10])
[array([0., 1., 2.]),
array([3., 4.]),
array([5.]),
array([6., 7.]),
array([], dtype=float64)]
None# 使用hsplit函数水平分隔数组
# 使用vsplit函数垂直分隔数组
import numpy as np
grid=np.arange(16).reshape(4,4)
print('原数组：\n',grid,'\n-----------')
a,b=np.hsplit(grid,2)
print(a)
print(b)
arr=np.arange(16).reshape(4,4)
a,b=np.vsplit(arr,[3])
print('vsplit(arr,[3])的结果： ')
print(a)
print(b)
print('vsplit(arr,[1,3])的结果： ')
a,b,c=np.vsplit(arr,[1,3])
print(a)
print(b)
print(c)原数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
-----------
[[ 0 1]
[ 4 5]
[ 8 9]
[12 13]]
[[ 2 3]
[ 6 7]
[10 11]
[14 15]]
vsplit(arr,[3])的结果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]]
vsplit(arr,[1,3])的结果：
[[0 1 2 3]]
[[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]]# split()函数分隔二维数组
import numpy as np
#创建两个数组
a=np.array([[1,2,3],[4,5,6],[11,12,13],[14,15,16]])
print('原数组:\n',a)
print('axis=0 垂直方向 平均分隔')
r=np.split(a,2,axis=0)
print('r[0]:\n',r[0])
print('r[1]:\n',r[1])
print('axis=1 水平方向 按位置分隔')
r=np.split(a,[2],axis=1)
print(r)原数组:
[[ 1 2 3]
[ 4 5 6]
[11 12 13]
[14 15 16]]
axis=0 垂直方向 平均分隔
r[0]:
[[1 2 3]
[4 5 6]]
r[1]:
[[11 12 13]
[14 15 16]]
axis=1 水平方向 按位置分隔
[array([[ 1, 2],
[ 4, 5],
[11, 12],
[14, 15]]), array([[ 3],
[ 6],
[13],
[16]])]# 数组/矩阵的转置
#二维转置
import numpy as np
a=np.arange(1,13).reshape(2,6)
print('原数组 a')
print(a)
print('转置后的数组')
print(a.transpose())
#多维数组转置
aaa=np.arange(1,37).reshape(1,3,3,4)
#将 1,3,3,4 转换为 3,3,4,1
print(np.transpose(aaa,[1,2,3,0]).shape)原数组 a
[[ 1 2 3 4 5 6]
[ 7 8 9 10 11 12]]
转置后的数组
[[ 1 7]
[ 2 8]
[ 3 9]
[ 4 10]
[ 5 11]
[ 6 12]]
(3, 3, 4, 1)# 算数函数
#如果参与运算的两个对象都是 ndarray，并且形状相同，那么会对位彼此之间进行（+-*/）运算。NumPy算术函数包含简单的加减乘除:add()，subtract()，multiply()和divide()
import numpy as np
a=np.arange(9,dtype=float).reshape(3,3)
b=np.array([10,10,10])
print('a是：\n',a)
print('b是：\n',b)
print('两数组进行加法运算 add 或+的结果： ')
print(np.add(a,b))
print('两数组进行减法运算 substract 或-的结果： ')
print(a-b)
print('两数组进行乘法运算 multiply 或*的结果： ')
print(np.multiply(a,b))
print('两数组进行除法运算 divide 或/的结果： ')
print(np.divide(a,b))
a是：
[[0. 1. 2.]
[3. 4. 5.]
[6. 7. 8.]]
b是：
[10 10 10]
两数组进行加法运算 add 或+的结果：
[[10. 11. 12.]
[13. 14. 15.]
[16. 17. 18.]]
两数组进行减法运算 substract 或-的结果：
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
两数组进行乘法运算 multiply 或*的结果：
[[ 0. 10. 20.]
[30. 40. 50.]
[60. 70. 80.]]
两数组进行除法运算 divide 或/的结果：
[[0. 0.1 0.2]
[0.3 0.4 0.5]
[0.6 0.7 0.8]]# 通用函数指定输出结果的用法
import numpy as np
x = np.arange(5)
y = np.empty(5)
print('x:\n',x)
print('y:\n',y)
np.multiply(x, 10, out=y)
print(y)x:
[0 1 2 3 4]
y:
[0.e+000 1.e-323 2.e-323 3.e-323 4.e-323]
[ 0. 10. 20. 30. 40.]# NumPy 提供了标准的三角函数：sin()、cos()、tan()。
a = np.array([0,30,45,60,90])
print ('不同角度的正弦值： ')
# 通过乘 pi/180 转化为弧度
print (np.sin(a*np.pi/180))
print ('数组中角度的余弦值： ')
print (np.cos(a*np.pi/180))
print ('数组中角度的正切值： ')
print (np.tan(a*np.pi/180))不同角度的正弦值：
[0. 0.5 0.70710678 0.8660254 1. ]
数组中角度的余弦值：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
数组中角度的正切值：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]# numpy.around() 函数返回指定数字的四舍五入值。
# 语法：numpy.around(a,decimals)
# 参数说明：
# a: 数组。
# decimals: 舍入的小数位数。 默认值为 0。 如果为负， 整数将四舍五入到小数点左侧的位置。
# numpy.floor() 返回数字的下舍整数。
# numpy.ceil() 返回数字的上入整数。
import numpy as np
a = np.array([1.0,4.55, 123, 0.567, 25.532])
print ('原数组： ')
print (a)
print ('round 舍入后： ')
print (np.around(a))
print (np.around(a, decimals = 1))
print (np.around(a, decimals = -1))
print('floor 向下取整： ')
print(np.floor(a))
print('ceil 向上取整： ')
print(np.ceil(a))原数组：
[ 1. 4.55 123. 0.567 25.532]
round 舍入后：
[ 1. 5. 123. 1. 26.]
[ 1. 4.6 123. 0.6 25.5]
[ 0. 0. 120. 0. 30.]
floor 向下取整：
[ 1. 4. 123. 0. 25.]
ceil 向上取整：
[ 1. 5. 123. 1. 26.]# 聚合函数
# NumPy 提供了很多统计函数， 用于从数组中查找最小元素， 最大元素， 百分位标准差和方差等。| 函数名 | 说明 |
|---|---|
| np.sum() | 求和 |
| np.prod() | 所有元素相乘 |
| np.mean() | 平均值 |
| np.std() | 标准差 |
| np.var() | 方差 |
| np.median() | 中数 |
| np.power() | 幂运算 |
| np.sqrt() | 开方 |
| np.min() | 最小值 |
| np.max() | 最大值 |
| np.argmin() | 最小值的下标 |
| np.argmax() | 最大值的下标 |
| np.inf | 无穷大 |
| np.exp(10) | 以 e 为底的指数 |
| np.log(10) | 对数 |
# power()函数的使用
import numpy as np
a=np.arange(12).reshape(3,4)
print('原来的数组')
print(a)
print('power(a,2)的结果： ')
print(np.power(a,2))
原来的数组
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
power(a,2)的结果：
[[ 0 1 4 9]
[ 16 25 36 49]
[ 64 81 100 121]]# median ()函数的使用
a=np.array([4,2,1,5])
#计算偶数的中位数
print('偶数的中位数： ',np.median(a))
a=np.array([4,2,1])
print('奇数个的中位数： ',np.median(a))
a=np.arange(1,16).reshape(3,5)
print('原来的数组')
print(a)
print('调用 median 函数')
print(np.median(a))
print('调用 median 函数， axis=1 行的中值')
print(np.median(a,axis=1))
print('调用 median 函数， axis=0 列的中值')
print(np.median(a,axis=0))
偶数的中位数： 3.0
奇数个的中位数： 2.0
原来的数组
[[ 1 2 3 4 5]
[ 6 7 8 9 10]
[11 12 13 14 15]]
调用 median 函数
8.0
调用 median 函数， axis=1 行的中值
[ 3. 8. 13.]
调用 median 函数， axis=0 列的中值
[ 6. 7. 8. 9. 10.]# numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴， 则沿其计算。算术平均值是沿轴的元素的总和除以元素的数量
a=np.arange(1,11).reshape(2,5)
print('原来的数组')
print(a)
print('调用 mean 函数')
print(np.mean(a))
print('调用 mean 函数 axis=0 列')
print(np.mean(a,axis=0))
print('调用 mean 函数 axis=1 行')
print(np.mean(a,axis=1))
原来的数组
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
调用 mean 函数
5.5
调用 mean 函数 axis=0 列
[3.5 4.5 5.5 6.5 7.5]
调用 mean 函数 axis=1 行
[3. 8.]# 矩阵的秩
import numpy as np
E = np.eye(4) # 四阶单位矩阵
display(E)
print("单位矩阵E的秩：",np.linalg.matrix_rank(E))
A = [[1,-4,0,2],[-1,2,-1,-1],[1,-2,3,5],[2,-6,1,3]]
B = np.array(A)
print("B的秩：",np.linalg.matrix_rank(B))array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
单位矩阵E的秩： 4
B的秩： 3# 行列式的计算
import numpy as np
B = [[1,-2,3],[-1,2,1],[-3,-4,-2]]
A = np.array(B)
C = np.linalg.det(A)
print("A的行列式的值：\n",C)
print("C的-1次方：\n",C**(-1))
print("1/C:\n",1/C)A的行列式的值：
40.000000000000014
C的-1次方：
0.02499999999999999
1/C:
0.02499999999999999-
正交矩阵
有同型向量x和y,我们称\([\mathbf{x} ,\mathbf{y} ]=x_{1}y_{1}+x_{2}y_{2}+...+x_{n}y_{n}\)
为向量x和y的内积，也做\(x\cdot y\)，若\(\begin{bmatrix}x,y\end{bmatrix}\)=0，则称x和y正交 -
向量的长度
import numpy as np
A = np.array([0,3,4])
B = np.linalg.norm(A)
print("向量A的长度为：\n",B)
C = A/B
print("A对应的单位向量是：\n",C)
D = np.linalg.norm(C)
print("单位向量C的长度是：\n",D)向量A的长度为：
5.0
A对应的单位向量是：
[0. 0.6 0.8]
单位向量C的长度是：
1.0利用两个向量的内积和长度可以求出两个向量夹角的余弦值：\([x,y]=\left \| x \right \| \ast \left \| y \right \| \ast \cos \theta \)
\(\cos \theta =\frac{[x,y]}{\left \| x \right \| \ast \left \| y \right \| } \)
这个公式及其变形常用在机器学习向量的投影中，一个向量在另一个向量上的投影长度~
- 向量空间
设V为向量空间，设V中有下个向量\(\alpha _{1},\alpha _{2},...,\alpha _{r}\)，若\(\alpha _{1},\alpha _{2},...,\alpha _{r}\)线性无关，而且V中任一向量都可由这r个向量线性表示,则称这r个向量构成的向量组\(\alpha _{1},\alpha _{2},...,\alpha _{r}\)为向量空间V的基。这些向量的个数r称为向量空间V的维数，称V为r维向量空间。
一个向量空间有很多基，但应用比较多的是标准正交基。
若\(\alpha _{1},\alpha _{2},...,\alpha _{r}\)是向量空间 V中的基\(\alpha _{1},\alpha _{2},...,\alpha _{r}\),均是单位向量，而且两两正交，则称\(\alpha _{1},\alpha _{2},...,\alpha _{r}\), 是的标准正交基。
标准正交基一定线性无关，且向量两两垂直。
若n阶方阵A满足\(A^TA=E或AA^T=E\)，则称A为正交矩阵，简称正交阵。
在复数范围内满足\(A^TA=AA^T=E\)，则称A为酉矩阵。酉矩阵常用于奇异值分解 (SVD)中，正交矩阵是实数特殊化的酉矩阵。
正交矩阵具有如下的性质
若A是正交矩阵，则\(A^{-1}=A^T\)也是正交矩阵;若A和B是正交矩阵，则AB也是正交矩阵。