numpy介绍——矩阵处理(8)

本次篇幅内容较大,我们会将numpy剩下的大部分的常见操作全部列举出来。

首先照例我们先生成一个简单的矩阵

# 选取0到10(不包括10)的数,结果乘2
a=np.arange(10)*2
a

输出:

array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

我们可以像python里的list一样,直接提取array里面的元素

a[5]

输出:

10

当然类似切片的操作也是完全没问题的

a[2:5]

输出:

array([4, 6, 8])

我们也可以对array里面的元素进行赋值操作

比如这样子

# 将前三个数赋值为100
a[0:3]=100
a

输出:

array([100, 100, 100,   6,   8,  10,  12,  14,  16,  18])

利用copy函数可以对我们已有的array进行复制操作

a_slice=a[0:5].copy()

a_slice

输出:

array([100, 100, 100,   6,   8])

接下来来介绍一下多维矩阵

def f(x,y):
    return 4*x+y
b=np.fromfunction(f,(3,2),dtype=int)
b

定义函数 f()

np.fromfunction()意思是,通过定义的f函数,来生成矩阵。

生成的矩阵基础模型为

[[00],[01],

[10],[11],

[20],[21]]

通过x*4以及y得到如下结果

array([[0, 1],
       [4, 5],
       [8, 9]])

在这里我们得到的是一个二维矩阵

那么现在再来一次读取矩阵元素的操作

b[0]

输出:

array([0, 1])

我们可以看到b这个array的第一个元素也是一个array

那么如果我们要读取该矩阵第一个元素的第二个元素怎么办呢?

b[0][1]

可以输出得到:

1

ok,那我们继续练习操作,来生成一个5*5的,元素皆为0的array

c=np.zeros([5,5])
c
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

将该矩阵的列数赋值为length

# length 即为这个矩阵的列数
length=c.shape[1]
length

输出:

5

利用一个简单的for循环可以做到:

for i in range(length):
    c[i]=i
    print(c[i])

输出:

[0. 0. 0. 0. 0.]
[1. 1. 1. 1. 1.]
[2. 2. 2. 2. 2.]
[3. 3. 3. 3. 3.]
[4. 4. 4. 4. 4.]

掌握了以上操作后,我们来做一个非常简单的小例子

假如我们需要一个array来处理25个工人在一周(五天)的工作时数

# 建立array,从周一到周五
# np.random.randn(5,5)生成的是一个5*5的矩阵,矩阵的值范围约从-1到1,是波动的
# np.random.randn (5,5) +8 的意思为,一天工作八小时,但是存在工作时间的合理波动,为8小时左右
# np.round 以及最后的 2 的意思是,结果取小数点2位

week_days=np.array(['Monday','Tuesday','Wednesday','Thursday','Friday'])
work_time=np.round(np.random.randn(5,5)+8,2)
work_time

输出为:

array([[ 7.61,  8.31,  9.14,  8.52,  7.49],
       [ 7.46,  8.71,  9.95,  8.34,  7.2 ],
       [ 8.26,  8.43,  8.47,  7.93,  6.51],
       [ 7.78,  7.31,  6.83,  8.1 ,  8.34],
       [ 7.39, 10.81,  7.91,  7.22,  7.46]])

首先判断一下,工作日里,是否有Tuesday存在

week_days=='Tuesday'

输出:

array([False,  True, False, False, False])
可以看到,当week_day这个array的元素为Tuesday时,输出为TRUE,其余情况输出为FALSE。

当输出为TRUE的时候

work_time[week_days=='Tuesday']

即可以输出work_time这个array第二行的元素

array([[7.46, 8.71, 9.95, 8.34, 7.2 ]])


在举例说明一下翻转矩阵

首先创建一个普通array

a=np.array([[1,2,3],[4,5,6]],dtype='float')
a

输出:

array([[1., 2., 3.],
       [4., 5., 6.]])
# 翻转矩阵
a.T

输出:

array([[1., 4.],
       [2., 5.],
       [3., 6.]])


最基本的操作已经介绍完了,让我们继续进阶一下,介绍一下三维矩阵

# 此处np.array里面多了一个中括号
a=np.array([[[1,2,3,0],[3,4,5,2]]])
a

输出:

array([[[1, 2, 3, 0],
        [3, 4, 5, 2]]])

此时查看它的shape

# 1,2,4 意思是,一堆,两行,四列,也就是三维矩阵
a.shape

输出:

(1, 2, 4)

我们也可以在这里用a.T来转化矩阵

# 此处用a.T 可以将其转化为 四堆,两行,一列
a.T

输出:

array([[[1],
        [3]],

       [[2],
        [4]],

       [[3],
        [5]],

       [[0],
        [2]]])

如果此时,我们想要转换矩阵,但是不是直接用a.T来转换,我们想把矩阵从1,2,4转化成1,4,2的话,就要用到

a.transpose()

a.transpose()可以指定转变方式[0,2,1]

[0,2,1]的意思是,第一个维度不变,后两个维度交换,

这样形状就从(1,2,4)变成了(1,4,2)


a.transpose(0,2,1)

输出:

array([[[1, 3],
        [2, 4],
        [3, 5],
        [0, 2]]])


我们当然还可以利用numpy来求一个矩阵的逆矩阵

# 求逆矩阵
m = np.array([[1,2,4],[3,4,5],[2,6,4]])
i = np.linalg.inv(m)
m

输出:

array([[1, 2, 4],
       [3, 4, 5],
       [2, 6, 4]])
i

输出得到:

array([[-0.63636364,  0.72727273, -0.27272727],
       [-0.09090909, -0.18181818,  0.31818182],
       [ 0.45454545, -0.09090909, -0.09090909]])

可以通过矩阵乘法,判断逆矩阵是否正确(当然是正确的···)

原矩阵和它的逆矩阵相乘,结果是斜边为1的矩阵

所以只要判断,两个矩阵相乘,是否可以得到斜边为1的矩阵,即可判断

np.allclose()意思是,判断两个矩阵是否相当,返回值为boolean类型


from numpy.linalg import inv
a=np.array([[1,2],[3,4]])
ainv=inv(a)
ainv

输出:

array([[-2. ,  1. ],
       [ 1.5, -0.5]])

输入:

np.allclose(np.dot(a,ainv),np.eye(2))
np.allclose(np.dot(ainv,a),np.eye(2))

输出:

True

矩阵当然也是可以求特征值的,虽然相对来说复杂了很多······用的地方不多

# 求特征值 eigenvalues
np.linalg.eig(m)

输出:

(array([11.+0.j, -1.+1.j, -1.-1.j]),
 array([[ 3.92274066e-01+0.j        ,  7.55928946e-01+0.j        ,
          7.55928946e-01-0.j        ],
        [ 6.40026108e-01+0.j        , -5.55111512e-17-0.37796447j,
         -5.55111512e-17+0.37796447j],
        [ 6.60672111e-01+0.j        , -3.77964473e-01+0.37796447j,
         -3.77964473e-01-0.37796447j]]))

继续继续~难度越来越大,越来越复杂!

我们继续来说说多维矩阵,生成一个三维矩阵

# 五堆,五行,两列
a3d=np.arange(50).reshape(5,5,2)
a3d

输出:

array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5],
        [ 6,  7],
        [ 8,  9]],

       [[10, 11],
        [12, 13],
        [14, 15],
        [16, 17],
        [18, 19]],

       [[20, 21],
        [22, 23],
        [24, 25],
        [26, 27],
        [28, 29]],

       [[30, 31],
        [32, 33],
        [34, 35],
        [36, 37],
        [38, 39]],

       [[40, 41],
        [42, 43],
        [44, 45],
        [46, 47],
        [48, 49]]])

利用transpose也可以来改变三维矩阵的形状

# 两堆,0行,一列
a3d.transpose(2,0,1)

输出:

array([[[ 0,  2,  4,  6,  8],
        [10, 12, 14, 16, 18],
        [20, 22, 24, 26, 28],
        [30, 32, 34, 36, 38],
        [40, 42, 44, 46, 48]],

       [[ 1,  3,  5,  7,  9],
        [11, 13, 15, 17, 19],
        [21, 23, 25, 27, 29],
        [31, 33, 35, 37, 39],
        [41, 43, 45, 47, 49]]])


bincount函数相对来说更复杂了一点

# np.bincount 意思解释如下
# np.array出的一个数列,其中的数字包括0,1,2,3,7,其中的一些数字是可以被重复的,顺序无所谓
# 其中生成的 bincount 数列实际上是一种计数
# bincount 中,第一个1代表的是,np.array中,数字0的个数,是1个
#              第二个3代表的是,np.array中,数字1的个数,是3个
#              第三个1代表的是,np.array中,数字2的个数,是1个
# 以此类推···
np.bincount(np.array([0,1,1,3,2,1,7]))

输出:

array([1, 3, 1, 1, 0, 0, 0, 1], dtype=int64)

在举例试试

np.bincount(np.array([1,1,2,10,2,4,7]))

输出:

array([0, 2, 2, 0, 1, 0, 0, 1, 0, 0, 1], dtype=int64)


下一个介绍一下 where()函数,这一节就快结束啦,坚持一下!

# where function 的意思是
# np.where(C,A,B) 意思为,如满足 True,则输出A,如满足False,则输出B
# 所以np.where 输出的结果为 1,6,7,8

A=np.array([1,2,3,4])
B=np.array([5,6,7,8])
C=np.array([True,False,False,False])
np.where(C,A,B)

输出:

array([1, 6, 7, 8])

那么where函数的其他用法呢?先生成一个5*5的array,数字从-1到1随机分布

# where function 的其他用法
b=np.random.randn(5,5)
b

先输出:

Out[22]:
array([[ 0.22675817, -0.32968475,  0.97355875,  1.25403444, -0.71749803],
       [-0.13194902, -0.63450846,  0.2376501 ,  1.17265272,  0.09408381],
       [-0.32555452,  1.60505397,  0.22411285,  0.96071262,  0.18240879],
       [-0.70484547,  0.11088696, -0.44609117, -1.05065555,  2.04582062],
       [-1.46425472,  1.3190111 , -1.16085506,  0.06465522, -0.48600749]])

然后利用where函数来判断

# 意思是,将b<0的值全部赋值为0,b>0的值,仍然为b
np.where(b<0,0,b)

输出:

array([[0.22675817, 0.        , 0.97355875, 1.25403444, 0.        ],
       [0.        , 0.        , 0.2376501 , 1.17265272, 0.09408381],
       [0.        , 1.60505397, 0.22411285, 0.96071262, 0.18240879],
       [0.        , 0.11088696, 0.        , 0.        , 2.04582062],
       [0.        , 1.3190111 , 0.        , 0.06465522, 0.        ]])


最后是 in1d函数

# np.in1d (注意in1d这里第三个是数字1,不是字母l)
# np.in1d 的意思是,判断第一个array的元素,是否存在于第二个array中
# 返回值为 boolean型
e=np.array([1,2,3,3,4,4,5])
np.in1d([2,4,7],e)

输出:

array([ True,  True, False])

终于大部分的numpy函数已经介绍完毕了

在之后的学习中,关于nump用到的函数应该就是上面列举的这些了~

是有点多啊···不过学习呢,没办法呀

下一节将会介绍python的下一个包,pandas的用法。

谢谢~












  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值