numpy包常见用法总结

目录

一、创建矩阵

1.直接创建

2.用arange创建

3.用linspace创建

4.用random创建

5.创建特殊矩阵

二、查看矩阵的属性

三、矩阵的基本运算

1.加减乘、乘方、三角函数

2.矩阵的乘法与转置

3.处理矩阵元素

四、矩阵的索引

五、矩阵的合并

1.用vstack和hsatck合并

2.用concatenate合并

六、矩阵的分割

1.用split分割

2.用vsplit和hsplit分割

3.不均匀分割

七、矩阵的遍历

八、其它内容

1.矩阵的平展

2.矩阵的拷贝

3.矩阵的增维

---

一、创建矩阵

1.直接创建

import numpy as np
#一维
a = np.array([1,2,3,4])
#多维
b = np.array([[1,2],
              [3,4]])
print(a)
print(b)

#结果
[1 2 3 4]

[[1 2]
[3 4]]

2.用arange创建

import numpy as np
#取值为0-3，默认1步长间距
a = np.arange(4)

#取值2-13为，2步长间距
b = np.arange(2,14,2)

#使用 reshape 改变矩阵的维度，变为二维，2x2
c = np.arange(4).reshape((2,2))

#使用 reshape 改变矩阵的维度，变为三维，2x2x2
d = np.arange(8).reshape((2,2,2))
print(a)
print(b)
print(c)

#结果
[0 1 2 3]

[ 2  4  6  8 10 12]

[[0 1]
 [2 3]]

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

3.用linspace创建

import numpy as np

#1为起点，10为终点，分割成10个数据，数据的间距相等
a = np.linspace(1,10,10)

print(a)

#结果
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

4.用random创建

import numpy as np
#在 [0, 1) 的均匀分布中产生随机数，接收单独的元组
a=np.random.random((2,2))
#在 [0, 1) 的均匀分布中产生随机数，接收分开的参数
b = np.random.rand(2, 2)
#返回一组具有标准正态分布的样本，接收分开的参数
c = np.random.rand(2,2)
print(a)
print(b)
print(c)
#结果
[[0.37953701 0.81445613]
 [0.18403819 0.50277074]]

[[0.96288514 0.55263579]
 [0.48501624 0.15401219]]

[[0.53442185 0.39539796]
 [0.10731071 0.07000282]]

5.创建特殊矩阵

import numpy as np
a = np.zeros((2,2)) # 创建2行2列的全0矩阵
print(a)

b = np.ones((2,2)) # 创建2行2列的全1矩阵
print(b)

#结果
[[0. 0.]
 [0. 0.]]

[[1. 1.]
 [1. 1.]]

二、查看矩阵的属性

import numpy as np
a = np.zeros((2,2)) # 创建2行2列的全0矩阵

print(a.ndim)  # 查看矩阵维度

print(a.shape)    # 查看矩阵行数和列数

print(a.size)   # 查看矩阵元素个数

#结果
2

(2, 2)

4

三、矩阵的基本运算

1.加减乘、乘方、三角函数

import numpy as np
a = np.array([[5,6],
              [7,8]])   
b=np.arange(4).reshape(2,2)    

c=a+b   #加法
print('加法：',c)

c=a-b  #减法
print('减法：',c)

c=a*b   #对应坐标相乘，与矩阵的乘法区分
print('乘法：',c)

c=b**2  # 乘方
print('平方：',c)

c=np.sin(a)  # 三角
print('正弦：',c)


#结果
加法： [[ 5  7]
        [ 9 11]]

减法： [[5 5]
        [5 5]]

乘法： [[ 0  6]
        [14 24]]

平方： [[0 1]
        [4 9]]

正弦： [[-0.95892427 -0.2794155 ]
        [ 0.6569866   0.98935825]]

2.矩阵的乘法与转置

import numpy as np
a = np.array([[5,6],
              [7,8]])   
b=np.arange(4).reshape(2,2) 

c = np.dot(a,b) #线性代数内容,与对应坐标相乘区分
print(c) 

c1 = c.T #线性代数内容,矩阵的转置
print(c1)
#结果
[[12 23]
 [16 31]]

[[12 16]
 [23 31]]

3.处理矩阵元素

import numpy as np
a = np.array([[5,6],
              [7,8]]) 
b = np.arange(4,0, -1).reshape((2,2)) 
#元素求和
print('总和：',np.sum(a))
#元素最大值
print('元素最大值：',np.max(a))
#元素最小值
print('元素最小值：',np.min(a))
#当axis的值为0的时候，将会以列作为单元， 当axis的值为1的时候，将会以行作为单元
print("sum =",np.sum(a,axis=1))

print("min =",np.min(a,axis=0))

print("max =",np.max(a,axis=1))

#求矩阵a的平均值
print("average =",np.average(a)) 

#求矩阵a的中位数
print("median =",np.median(a))

#cumsum()累加函数,就是原矩阵首项累加到对应项的元素之和
print("cumsum =",np.cumsum(a))

#diff()累差函数，计算每一行中后一项与前一项的差
print("diff =",np.diff(a))

#sort（）排序函数，针对每一行进行从小到大的排序操作
print("原矩阵b：",b)
print("排序后：",np.sort(b))    

#clip()修剪函数，这个函数的格式是clip(Array,Array_min,Array_max)
#Array指的是将要被执行用的矩阵，
#后面的最小值和最大值用于让函数判断矩阵中元素是否有比最小值小的或者比最大值大的元素，
#并将这些相应的元素转换为最小值或者最大值
print("修剪后：",np.clip(b,2,3)) 

#结果
总和： 26

元素最大值： 8

元素最小值： 5

sum = [11 15]

min = [5 6]

max = [6 8]

average = 6.5

median = 6.5

cumsum = [ 5 11 18 26]

diff = [[1]
        [1]]

原矩阵b： [[4 3]
          [2 1]]

排序后： [[3 4]
          [1 2]]

修剪后： [[3 3]
          [2 2]]

四、矩阵的索引

import numpy as np
a = np.arange(2,11).reshape((3,3)) 

print("原矩阵a：",a)
print("最大值序号：",np.argmin(a))    
print("最小值序号：",np.argmax(a))   

print("（1,1）处的元素值：",a[1][1]) #从0开始
print("第二行的元素值：",a[1]) 

#利用:对一定范围内的元素进行切片操作
print("第二行序号1-3的元素值：",A[1, 1:3]) 

#结果
原矩阵a： [[ 2  3  4]
          [ 5  6  7]
          [ 8  9 10]]
最大值序号： 0
最小值序号： 8

（1,1）处的元素值： 6
第二行的元素值： [5 6 7]
第二行序号1-3的元素值： [6 7]

​

五、矩阵的合并

1.用vstack和hsatck合并

import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
#vstack即vertical stack，表示垂直合并
c = np.vstack((a,b))
#hsatck即horizontal stack，表示水平合并
d = np.hstack((a,b))
print("垂直合并后的矩阵:",c)
print("水平合并后的矩阵:",d)

#结果
垂直合并后的矩阵: [[1 2 3]
                  [4 5 6]]

水平合并后的矩阵: [1 2 3 4 5 6]

2.用concatenate合并

import numpy as np
a = np.array([[1,2,3]])
b = np.array([[4,5,6]])
#concatenate((a1, a2, …), axis=)  数组拼接函数  
#a1,a2……为要拼接的数组 
#axis为在哪个维度上进行拼接，默认为0

#axios=0,在垂直方向合并
e = np.concatenate((a,a,b,b),axis = 0)
#axios=1,在水平方向合并
f = np.concatenate((a,a,b,b),axis = 1)
print("垂直合并后的矩阵:",e)
print("水平合并后的矩阵:",f)

#结果
垂直合并后的矩阵: [[1 2 3]
                  [1 2 3]
                  [4 5 6]
                  [4 5 6]]

水平合并后的矩阵: [[1 2 3 1 2 3 4 5 6 4 5 6]]

六、矩阵的分割

1.用split分割

import numpy as np
a = np.arange(12).reshape((3, 4))

print("原矩阵:",a)

#split参数分别为（矩阵，份数，axis）
#垂直方向分为3份，必须是整数等量分割
print("垂直分割后的矩阵:",np.split(a, 3, axis=0))

#水平方向分为2份，必须是整数等量分割
print("水平分割后的矩阵:",np.split(a, 2, axis=1))

#结果
原矩阵: [[ 0  1  2  3]
         [ 4  5  6  7]
         [ 8  9 10 11]]

垂直分割后的矩阵: [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

水平分割后的矩阵: [array([[0, 1],
                         [4, 5],
                         [8, 9]]), 
                  array([[ 2,  3],
                         [ 6,  7],
                         [10, 11]])]

2.用vsplit和hsplit分割

import numpy as np
a = np.arange(12).reshape((3, 4))

print("原矩阵:",a)

#vsplit和hsplit可以不用axis指定维度
#垂直方向分为3份，必须是整数等量分割
print("vstack分割后的矩阵:",np.vsplit(a, 3)) #等价于 print(np.split(A, 3, axis=0))

#水平方向分为2份，必须是整数等量分割
print("hstack分割后的矩阵:",np.hsplit(a, 2)) #等价于 print(np.split(A, 2, axis=1))

#结果
原矩阵: [[ 0  1  2  3]
         [ 4  5  6  7]
         [ 8  9 10 11]]
vstack分割后的矩阵: 
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
hstack分割后的矩阵: [array([[0, 1],
                           [4, 5],
                           [8, 9]]), 
                    array([[ 2,  3],
                           [ 6,  7],
                           [10, 11]])]

3.不均匀分割

import numpy as np
a = np.arange(12).reshape((3, 4))
print("原矩阵:",a)

#array_split()可以用于不均等划分
#对于长度为t的数组，分割成n个部分，
#它返回t % n个大小为(t / n) + 1的子数组，以及其他大小为(t / n)的子数组

#垂直方向分为2份，不均等分割
print("不均等分割后的矩阵:",np.array_split(a, 2, axis=0))

#结果
原矩阵: [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

不均等分割后的矩阵: [array([[0, 1, 2, 3],
                          [4, 5, 6, 7]]), 
                    array([[ 8,  9, 10, 11]])]

七、矩阵的遍历

import numpy as np
a = np.arange(12).reshape((3, 4))

print("原矩阵:",a)

for row in a:
    print(row)
print("-------行遍历结束-------")

for column in a.T:#利用转置矩阵完成列遍历
    print(column)
print("-------列遍历结束-------")

for item in a.flat:#flat是一个迭代器
    print(item)
print("-------元素遍历结束-------")

#结果
原矩阵: [[ 0  1  2  3]
         [ 4  5  6  7]
         [ 8  9 10 11]]

[0 1 2 3]
[4 5 6 7]
[ 8  9 10 11]
-------行遍历结束-------

[0 4 8]
[1 5 9]
[ 2  6 10]
[ 3  7 11]
-------列遍历结束-------

0
1
2
3
4
5
6
7
8
9
10
11
-------元素遍历结束-------

八、其它内容

1.矩阵的平展

import numpy as np
a = np.arange(12).reshape((3, 4))

print("原矩阵a:",a)

#flatten()将多维的矩阵进行展开成1行的数列
print("平展后:",a.flatten())

#结果
原矩阵a: [[ 0  1  2  3]
          [ 4  5  6  7]
          [ 8  9 10 11]]
平展后: [ 0  1  2  3  4  5  6  7  8  9 10 11]

2.矩阵的拷贝

import numpy as np
a = np.arange(12).reshape((3, 4))

print("原矩阵a:",a)

#利用 = 赋值默认为浅拷贝
b = a
#改变b矩阵中元素值，发现a矩阵的元素值也改变
b[1][1] = 666
print("我是a:",a)

#发现两个矩阵其实相同，这就是浅拷贝
print(b is a)

print("---------------------------")

#利用copy进行深拷贝
b = a.copy()     
b[2][2] = 444

#改变b矩阵中元素值，发现a矩阵的元素值不发生改变
print("我是b:",b)       
print("我是a:",a) 

#发现两个矩阵不相同，这就是深拷贝
print(b is a)

#结果
原矩阵a: [[ 0  1  2  3]
          [ 4  5  6  7]
          [ 8  9 10 11]]

我是a: [[  0   1   2   3]
        [  4 666   6   7]
        [  8   9  10  11]]

True

---------------------------

我是b: [[  0   1   2   3]
        [  4 666   6   7]
        [  8   9 444  11]]

我是a: [[  0   1   2   3]
        [  4 666   6   7]
        [  8   9  10  11]]

False

3.矩阵的增维

import numpy as np
a = np.array([1,2,3])
print("原矩阵:",a) 
print('维度 :',a.shape) #一维

#newaxis的作用就是在指定位置增加一个一维
a1 = a[np.newaxis,:] 
a2 = a[:,np.newaxis] 

print("1 x 3的矩阵:",a1) #变为二维

print("3 x 1的矩阵:",a2) #变为二维

#结果
原矩阵: [1 2 3]

维度 : (3,)

1 x 3的矩阵: [[1 2 3]]

3 x 1的矩阵: [[1]
              [2]
              [3]]