By

文章目录
  1. 1. array
    1. 1.1. np.array
    2. 1.2. np.arange
    3. 1.3. np.linspace
    4. 1.4. np.ones
    5. 1.5. np.zeros
    6. 1.6. np.eye
    7. 1.7. np.diag
    8. 1.8. 矩阵的四则运算
    9. 1.9. summary
  2. 2. random
    1. 2.1. np.random.rand
    2. 2.2. np.random.randn
  3. 3. 参考

numpy这个科学计算工具大法好，但是里面的东西不用老是会忘，所以在此记录常用的一些语法，以备之后查询之用（也叫懒人模式）^_^,不过详细的使用方法还是得看scipy api

使用之前首先得引入包

1
import numpy as np

array

np.array实现了真正的数组，在numpy中其实就是矩阵啦，同时提供了丰富的矩阵计算方法

np.array

1
2
np.array([0, 1, 2, 3])  #一维数组
np.array([[0, 1, 2], [3, 4, 5]])  #二维数组

np.arange

1
2
np.arange(10) #使用指定range来创建数组 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(1, 9, 2)  #开始，终止(不包含)，步长  array([1, 3, 5, 7])

np.linspace

1
2
np.linspace(0, 1, 6) #开始，终止，创建元素个数   array([ 0.    0.25  0.5   0.75  1.  ])
np.linspace(0, 1, 6,endpoint=False) #endpoint这个参数控制最后一个终止值是否被包含，默认Ture，array([ 0.   0.2  0.4  0.6  0.8])

arange与linspace都是在指定范围内生成均匀的变量，只是前者是按步长进行生成，后者是按指定的数量进行生成

np.ones

快速生成值为1的矩阵

1
2
3
4
5
6
np.ones(5)  #array([ 1.,  1.,  1.,  1.,  1.])
np.ones((2,2)) #生成一个2x2的值为1的矩阵
"""
array([[ 1.,  1.],
       [ 1.,  1.]])
"""

np.zeros

快速生成值为1的矩阵

1
2
3
4
5
6
np.zeros(5) #array([ 0.,  0.,  0.,  0.,  0.])
np.zeros((2,2)) #生成一个2x2的值为0的矩阵
"""
array([[ 0.,  0.],
       [ 0.,  0.]])
"""

np.eye

快速生成值为1的对角矩阵

1
2
3
4
5
6
7
8
9
10
11
12
13
np.eye(3)
"""
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
"""

np.eye(3,k=1)  #这里的k可以指定对角的索引位置 默认是0，也就是真正的对角
"""
[[ 0.  1.  0.]
 [ 0.  0.  1.]
 [ 0.  0.  0.]]
"""

np.diag

提取普通矩阵的对角

  • 若普通矩阵是1维矩阵，则直接将该1维矩阵转为对角矩阵
  • 若普通矩阵是2维矩阵，则提取该对角线(k)的矩阵并返回一个1维矩阵
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
np.diag(np.array([1,2,3,4]))  #将4x1的矩阵转为只有对角线上有值的方正
"""
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]
"""

np.diag(np.ones((3,3))) #提取对角线上的元素 转为了1维矩阵 [ 1.  1.  1.]
#若继续想要对角方正，则需呀再一次转换
np.diag(np.diag(np.ones((3,3))))
"""
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
"""

矩阵的四则运算

1
2
3
4
5
6
7
8
9
10
11
12
13
a=np.arange(9).reshape(3,3)  ##0~8的3x3矩阵
"""
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
"""

b=np.array(range(9)[::-1]).reshape(3,3)  ##8~0的3x3矩阵
"""
array([[8, 7, 6],
       [5, 4, 3],
       [2, 1, 0]])
"""

加减乘除都可以按这个走

1
2
3
4
5
6
7
8
9
10
11
12
a+1 #在每个元素上+1
"""
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
"""
a+b #两个矩阵相加
"""
array([[8, 8, 8],
       [8, 8, 8],
       [8, 8, 8]])
"""

还可以做幂次方

1
2
3
4
5
6
a**2
"""
array([[ 0,  1,  4],
       [ 9, 16, 25],
       [36, 49, 64]])
"""

还可以倒着运算

1
2
3
4
2**a
array([[  1,   2,   4],
       [  8,  16,  32],
       [ 64, 128, 256]])

summary

  1. 关于取值，还是按[index]的方式即可取
  2. 还有很方便的函数：
    • 求和:sum
    • 转置：T
    • 最大最小：max,min
    • 方差：var,标准差：std
    • 均值：mean

random

用于产生强大的随机数呀,并且可以指定具体的矩阵形状

np.random.rand

产生均匀的0~1之间的随机数

1
2
3
4
5
6
np.random.rand(4) #生成1x4的随机矩阵 array([ 0.78374518,  0.64304815,  0.01667375,  0.50154654])
np.random.rand(2,3)  #生成2x3的随机矩阵
"""
array([[ 0.20500983,  0.66468726,  0.55619774],
       [ 0.37256962,  0.86550713,  0.05781776]])
"""

np.random.randn

生成服从高斯分布的随机矩阵

1
2
3
4
5
6
7
np.random.randn(4)  #生成N(0,1)分布的的1x4的矩阵 array([ 0.72481524, -0.1976192 , -0.48224937, -0.8019294 ])
#如果想执行方差和均值的话，可以这么干sigma * np.random.randn(...) + mu
2.5 * np.random.randn(2, 4) + 3  #比如这个就是服从N~(3,6.25)的高斯分布
"""
array([[ 5.2147326 ,  0.90325509,  1.39212656,  5.97713821],
       [-0.26270206,  3.09619677,  2.21054634,  2.94103359]])
"""

参考

文章目录
  1. 1. array
    1. 1.1. np.array
    2. 1.2. np.arange
    3. 1.3. np.linspace
    4. 1.4. np.ones
    5. 1.5. np.zeros
    6. 1.6. np.eye
    7. 1.7. np.diag
    8. 1.8. 矩阵的四则运算
    9. 1.9. summary
  2. 2. random
    1. 2.1. np.random.rand
    2. 2.2. np.random.randn
  3. 3. 参考