• Python——第6章 Numpy库的使用

    Numpy 是 Python 专门处理高维数组 (high dimensional array) 的计算的包。

    官网 (www.numpy.org).

    列表和数组区别

    列表：数据类型可以不同——3.1413, ‘pi’, 3.1404, [3.1401, 3.1349], ‘3.1376’

    数组：数据类型相同——3.1413, 3.1398, 3.1404, 3.1401, 3.1349, 3.1376

    1numpy数组及其运算

    1.1创建数组

    import numpy as np
np.array([1,2,3,4,5])#把列表转为数组

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

    • 1
    np.array((1,2,3,4,5))#把元组转换为数组

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

    • 1
    np.array(range(5))#把range对象转换成数组

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

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

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

    • 1
    • 2

    数组的创建—定隔定点的 np.arange() 和 np.linspace()

    更常见的两种创建 numpy 数组方法：

    （1）定隔的 arange：固定元素大小间隔：arange(start , stop , step)

    说明：其中 stop 必须要有，start 和 step 没有的话默认为 1。

    np.arange(8)

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

    • 1
    np.arange(1,10,2)

    • 1
    array([1, 3, 5, 7, 9])

    • 1

    （2）定点的 linspace：固定元素个数： linspace (start , stop , num)

    说明：其中 start 和 stop 必须要有，num 没有的话默认为 50。

    np.linspace(0,10,11)#等差数组，包含11个数

    • 1
    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

    • 1
    np.linspace(0,10,11,endpoint=False)#不包含终点

    • 1
    array([0.        , 0.90909091, 1.81818182, 2.72727273, 3.63636364,
       4.54545455, 5.45454545, 6.36363636, 7.27272727, 8.18181818,
       9.09090909])

    • 1
    • 2
    • 3
    np.logspace(0,100,10)#相当于10**np.linspace(0,100,10)

    • 1
    array([1.00000000e+000, 1.29154967e+011, 1.66810054e+022, 2.15443469e+033,
       2.78255940e+044, 3.59381366e+055, 4.64158883e+066, 5.99484250e+077,
       7.74263683e+088, 1.00000000e+100])

    • 1
    • 2
    • 3
    np.logspace(1,6,5,base=2)#相当于2*np.linspace(1,6,5)

    • 1
    array([ 2.        ,  4.75682846, 11.3137085 , 26.90868529, 64.        ])

    • 1

    数组的创建—使用NumPy中函数创建ndarray数组

    np.zeros(3)#全0一维数组

    • 1
    array([0., 0., 0.])

    • 1
    np.ones(3)

    • 1
    array([1., 1., 1.])

    • 1
    np.zeros((3,3))#全0二维数组，3行3列

    • 1
    array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

    • 1
    • 2
    • 3
    np.zeros((1,3))#全0二维数组，1行3列

    • 1
    array([[0., 0., 0.]])

    • 1
    np.zeros((3,1))

    • 1
    array([[0.],
       [0.],
       [0.]])

    • 1
    • 2
    • 3
    np.ones((3,3))

    • 1
    array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

    • 1
    • 2
    • 3
    np.ones((1,3))

    • 1
    array([[1., 1., 1.]])

    • 1
    np.identity(3)#单位矩阵

    • 1
    array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

    • 1
    • 2
    • 3
    np.identity(2)

    • 1
    array([[1., 0.],
       [0., 1.]])

    • 1
    • 2
    np.empty((3,3))#空数组，只申请空间，不初始化

    • 1
    array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

    • 1
    • 2
    • 3
    np.eye(3) # 单位矩阵，3行3列

    • 1
    array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

    • 1
    • 2
    • 3
    np.hamming(20)#Hamming窗口

    • 1
    array([0.08      , 0.10492407, 0.17699537, 0.28840385, 0.42707668,
       0.5779865 , 0.7247799 , 0.85154952, 0.94455793, 0.9937262 ,
       0.9937262 , 0.94455793, 0.85154952, 0.7247799 , 0.5779865 ,
       0.42707668, 0.28840385, 0.17699537, 0.10492407, 0.08      ])

    • 1
    • 2
    • 3
    • 4
    np.blackman(10)#Blackman窗口

    • 1
    array([-1.38777878e-17,  5.08696327e-02,  2.58000502e-01,  6.30000000e-01,
        9.51129866e-01,  9.51129866e-01,  6.30000000e-01,  2.58000502e-01,
        5.08696327e-02, -1.38777878e-17])

    • 1
    • 2
    • 3
    np.kaiser(12,5)#Kaiser窗口

    • 1
    array([0.03671089, 0.16199525, 0.36683806, 0.61609304, 0.84458838,
       0.98167828, 0.98167828, 0.84458838, 0.61609304, 0.36683806,
       0.16199525, 0.03671089])

    • 1
    • 2
    • 3

    使用random() 创建随机 n 维数组

    np.random.randint(0,50,5)

    • 1
    array([28,  2, 43, 17, 22])

    • 1
    np.random.randint(0,50,(3,5))

    • 1
    array([[12, 47, 33, 10,  2],
       [23,  6, 17,  7, 24],
       [11, 39, 24, 26, 30]])

    • 1
    • 2
    • 3
    np.random.rand(10)

    • 1
    array([0.09670211, 0.99259248, 0.5341233 , 0.71901056, 0.90347888,
       0.91331606, 0.08372737, 0.79742945, 0.31878994, 0.55094098])

    • 1
    • 2
    np.random.standard_normal(5)#从标准正态分布中随机采样5个数字

    • 1
    array([-0.14415678,  1.08512822,  0.99102915, -0.49645761, -1.51070848])

    • 1
    x=np.random.standard_normal(size=(3,4,2))#3页4行2列
x

    • 1
    • 2
    array([[[ 0.85754025, -0.28172407],
        [ 0.23733268,  0.87116374],
        [-0.62887857, -1.36845296],
        [-0.53553569,  1.01818603]],

       [[-0.48036281,  0.30293107],
        [-0.41027798,  0.87720648],
        [-0.74450358, -0.60304887],
        [-0.48493204, -1.9946126 ]],

       [[ 0.19694871,  0.53144363],
        [ 0.032769  , -1.362219  ],
        [-0.03665392,  1.49506453],
        [ 1.55785374, -0.96754543]]])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    np.diag([1,2,3,4])                 # 对角矩阵

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

    • 1
    • 2
    • 3
    • 4

    1.2测试两个数组的对应元素是否足够接近

    import numpy as np
x=np.array([1,2,3,4.001,5])
y=np.array([1,1.999,3,4.01,5.1])
print(np.allclose(x,y))
print(np.allclose(x,y,rtol=0.2))#设置相对误差
print(np.allclose(x,y,atol=0.2))#设置绝对参数
print(np.isclose(x,y))
print(np.isclose(x,y,atol=0.2))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    False
True
True
[ True False  True False False]
[ True  True  True  True  True]

    • 1
    • 2
    • 3
    • 4
    • 5

    1.3修改数组中的元素值

    import numpy as np
x=np.arange(8)
x

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

    • 1
    np.append(x,8) # 返回新数组，在尾部追加一个元素

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

    • 1
    np.append(x,[9,10]) # 返回新数组，在尾部追加多个元素

    • 1
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  9, 10])

    • 1
    x              # 不影响原来的数组

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

    • 1
    x[3]=8   # 使用下标的形式原地修改元素值
x        # 原来的数组被修改了

    • 1
    • 2
    array([0, 1, 2, 8, 4, 5, 6, 7])

    • 1
    np.insert(x,1,8)   # 返回新数组，插入元素

    • 1
    array([0, 8, 1, 2, 8, 4, 5, 6, 7])

    • 1
    x=np.array([[1,2,3],[4,5,6],[7,8,9]])

    • 1
    x[0,2]=4          # 修改第0行第2列的元素值

    • 1
    x[1:,1:]=1       # 切片，把行下标大于等于1
x

    • 1
    • 2
    array([[1, 2, 4],
       [4, 1, 1],
       [7, 1, 1]])

    • 1
    • 2
    • 3
    x[1:,1:]=[1,2]    # 同时修改多个元素值
x

    • 1
    • 2
    array([[1, 2, 4],
       [4, 1, 2],
       [7, 1, 2]])

    • 1
    • 2
    • 3
    x[1:,1:]=[[1,2],[3,4]] # 同时修改多个元素值
x

    • 1
    • 2
    array([[1, 2, 4],
       [4, 1, 2],
       [7, 3, 4]])

    • 1
    • 2
    • 3

    1.4数组与标量的运算

    import numpy as np
x=np.array((1,2,3,4,5)) # 创建数组对象
x

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

    • 1
    x*2       # 数组与数值相乘，返回新数组

    • 1
    array([ 2,  4,  6,  8, 10])

    • 1
    x/2        # 数组与数值相除

    • 1
    array([0.5, 1. , 1.5, 2. , 2.5])

    • 1
    x//2        # 数组与数值相除

    • 1
    array([0, 1, 1, 2, 2], dtype=int32)

    • 1
    x**3        # 幂运算

    • 1
    array([  1,   8,  27,  64, 125], dtype=int32)

    • 1
    x+2         # 数组与数值相加

    • 1
    array([3, 4, 5, 6, 7])

    • 1
    x%3         # 余数

    • 1
    array([1, 2, 0, 1, 2], dtype=int32)

    • 1
    2**x           # 分别计算2**1、2**2、2**3、2**4、2**5

    • 1
    array([ 2,  4,  8, 16, 32], dtype=int32)

    • 1
    2/x

    • 1
    array([2.        , 1.        , 0.66666667, 0.5       , 0.4       ])

    • 1
    63//x

    • 1
    array([63, 31, 21, 15, 12], dtype=int32)

    • 1

    1.5数组与数组的运算

    np.array([1,2,3,4])+np.array([4,3,2,1])      # 等长数组相加，对应元素相加，返回信数组

    • 1
    array([5, 5, 5, 5])

    • 1
    np.array([1,2,3,4])+np.array([4])      # 数组中每个元素加4，数组不等长

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

    • 1
    a=np.array((1,2,3))                    

    • 1
    a + a              # 等长数组之间的加法运算，对应元素相加

    • 1
    array([2, 4, 6])

    • 1
    a * a              # 等长数组之间的乘法运算，对应元素相乘

    • 1
    array([1, 4, 9])

    • 1
    a - a           # 等长数组之间的减法运算，对应元素相减

    • 1
    array([0, 0, 0])

    • 1
    a / a           # 等长数组之间的除法运算，对应元素相除

    • 1
    array([1., 1., 1.])

    • 1
    a**a            # 等长数组之间的幂运算，对应元素乘方

    • 1
    array([ 1,  4, 27], dtype=int32)

    • 1
    b=np.array(([1,2,3],[4,5,6],[7,8,9]))

    • 1
    c=a*b         # 不同维度的数组与数组相乘

    • 1
    c            # a中的每个元素乘以b中对应列的元素
             # a中下标0的元素乘以b中列下标0的元素
             # a中下标1的元素乘以b中列下标1的元素
             # a中下标2的元素乘以b中列下标2的元素

    • 1
    • 2
    • 3
    • 4
    array([[ 1,  4,  9],
       [ 4, 10, 18],
       [ 7, 16, 27]])

    • 1
    • 2
    • 3
    a+b       # a中每个元素加b中的对应列元素

    • 1
    array([[ 2,  4,  6],
       [ 5,  7,  9],
       [ 8, 10, 12]])

    • 1
    • 2
    • 3

    1.6数组排序

    import numpy as np
x=np.array([3,1,2])
np.argsort(x)         # 返回升序排序后元素的原下标
                      # 原数组中下标1的元素最小
                      # 下标2的元素次之
                      # 下标0的元素最大

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    array([1, 2, 0], dtype=int64)

    • 1
    x[_]                # 使用数组做下标，获取对应位置的元素

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

    • 1
    x=np.array([3,1,2,4])
x.argmax(),x.argmin() # 最大值和最小值的下标

    • 1
    • 2
    (3, 1)

    • 1
    np.argsort(x)

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

    • 1
    x[_]

    • 1
    array([1, 2, 3, 4])

    • 1
    x.sort()         # 原地排序

    • 1
    x

    • 1
    array([1, 2, 3, 4])

    • 1
    x=np.random.randint(1,10,(2,5))

    • 1
    x

    • 1
    array([[3, 2, 6, 9, 9],
       [8, 5, 5, 1, 1]])

    • 1
    • 2
    x.sort(axis=1)#横向排序

    • 1
    x

    • 1
    array([[2, 3, 6, 9, 9],
       [1, 1, 5, 5, 8]])

    • 1
    • 2

    1.7数组的内积运算

    x ⋅ y = ∑ i = 1 n x i y i x·y=\sum^n _{i=1}{x_iy_i} x⋅y=i=1∑n​xi​yi​

    x=np.array((1,2,3))
y=np.array((4,5,6))
print(np.dot(x,y))#内积
print(x.dot(y))
print(sum(x*y))

    • 1
    • 2
    • 3
    • 4
    • 5
    32
32
32

    • 1
    • 2
    • 3

    1.8访问数组中的元素

    b=np.array(([1,2,3],[4,5,6],[7,8,9]))
b

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

    • 1
    • 2
    • 3
    b[0]      # 第0行所有元素     

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

    • 1
    b[0][0]    # 第0行第0列的元素

    • 1
    1

    • 1
    b[0,2]     # 第0行第2列的元素，等价于b[0][2]的形式

    • 1
    3

    • 1
    b[[0,1]]   # 第0行和第1行的所有元素，只指定行下标，不指定列下标，表示所有列

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

    • 1
    • 2
    b[[0,2,1],[2,1,0]]  # 第0行第2列、第2行第1列、第1行第0列的元素
                    # 第一个列表表示行下标，第二个列表表示列下标

    • 1
    • 2
    array([3, 8, 4])

    • 1
    a=np.arange(10)
a

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

    • 1
    a[::-1] # 反向切片

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

    • 1
    a[::2] # 隔一个取一个元素

    • 1
    array([0, 2, 4, 6, 8])

    • 1
    a[:5]  # 前5个元素

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

    • 1
    c=np.arange(25)
c

    • 1
    • 2
    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])

    • 1
    • 2
    c.shape=5,5   # 修改数组形状
c

    • 1
    • 2
    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]])

    • 1
    • 2
    • 3
    • 4
    • 5
    c[0,2:5]    # 第0行中下标[2,5)之间的元素值

    • 1
    array([2, 3, 4])

    • 1
    c[1]       # 第0行中下标[2,5)之间的元素值

    • 1
    array([5, 6, 7, 8, 9])

    • 1
    c[2:5,2:5]  # 行下标和列下标都介于[2,5)之间的元素值

    • 1
    array([[12, 13, 14],
       [17, 18, 19],
       [22, 23, 24]])

    • 1
    • 2
    • 3
    c[[1,3],[2,4]]  # 第1行第2列的元素和第3行第4列的元素

    • 1
    array([ 7, 19])

    • 1
    c[[1,3],2:4]     # 第1行和第3行的第2、3列

    • 1
    array([[ 7,  8],
       [17, 18]])

    • 1
    • 2
    c[:,3]        # 第3列所有元素

    • 1
    array([ 3,  8, 13, 18, 23])

    • 1
    c[:, [2,4]]          # 第2列和第4列所有元素，对行下标进行切片，冒号表示所有行

    • 1
    array([[ 2,  4],
       [ 7,  9],
       [12, 14],
       [17, 19],
       [22, 24]])

    • 1
    • 2
    • 3
    • 4
    • 5
    c[[1,3]]     # 第1行和第3行所有元素

    • 1
    array([[ 5,  6,  7,  8,  9],
       [15, 16, 17, 18, 19]])

    • 1
    • 2
    c[[1,3]][:,[2,4]]   # 第1、3行的2、4列元素

    • 1
    array([[ 7,  9],
       [17, 19]])

    • 1
    • 2

    1.9数组对函数运算的支持

    x=np.arange(0,100,10,dtype=np.floating)
print(x)
print(np.sin(x))   # 一维数组中所有元素求正弦值

    • 1
    • 2
    • 3
    [ 0. 10. 20. 30. 40. 50. 60. 70. 80. 90.]
[ 0.         -0.54402111  0.91294525 -0.98803162  0.74511316 -0.26237485
 -0.30481062  0.77389068 -0.99388865  0.89399666]


C:\Users\soul学长\AppData\Local\Temp/ipykernel_6100/3916564714.py:1: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.
  x=np.arange(0,100,10,dtype=np.floating)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    x=np.array(([1,2,3],[4,5,6],[7,8,9]))
print(x)       

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

    • 1
    • 2
    • 3
    print(np.cos(x)) # 二维数组中所有元素求余弦值

    • 1
    [[ 0.54030231 -0.41614684 -0.9899925 ]
 [-0.65364362  0.28366219  0.96017029]
 [ 0.75390225 -0.14550003 -0.91113026]]

    • 1
    • 2
    • 3
    print(np.round(np.cos(x)))  # 四舍五入

    • 1
    [[ 1. -0. -1.]
 [-1.  0.  1.]
 [ 1. -0. -1.]]

    • 1
    • 2
    • 3
    print(np.ceil(x/2))   #向上取整

    • 1
    [[1. 1. 2.]
 [2. 3. 3.]
 [4. 4. 5.]]

    • 1
    • 2
    • 3

    1.10改变数组形状

    x=np.arange(1,11,1)
x

    • 1
    • 2
    array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

    • 1
    x.shape  # 查看数组的形状

    • 1
    (10,)

    • 1
    x.size   # 数组中元素的数量

    • 1
    10

    • 1
    x.shape=2,5   # 改为2行5列
x

    • 1
    • 2
    array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])

    • 1
    • 2
    x.shape

    • 1
    (2, 5)

    • 1
    x.shape=5,-1     # -1表示自动计算
x

    • 1
    • 2
    array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10]])

    • 1
    • 2
    • 3
    • 4
    • 5
    x=x.reshape(2,5)   # reshape()方法返回新数组
x

    • 1
    • 2
    array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])

    • 1
    • 2
    x=np.array(range(5))

    • 1
    x.reshape((1,10))   # reshape()不能修改数组元素个数，出错

    • 1
    ---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_6100/1914000034.py in 
----> 1 x.reshape((1,10))   # reshape()不能修改数组元素个数，出错


ValueError: cannot reshape array of size 5 into shape (1,10)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    x.resize((1,10))   # reshape()不能修改数组元素个数，出错
x

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

    • 1
    np.resize(x,(1,3))  # 使用numpy的resize()返回新数组

    • 1
    array([[0, 1, 2]])

    • 1
    x         # 不对原数组进行任何修改

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

    • 1

    1.11数组布尔运算

    x=np.random.rand(10)      # 包含10个随机数的数组
x

    • 1
    • 2
    array([0.23494488, 0.62911978, 0.08695988, 0.49816789, 0.78656564,
       0.41347271, 0.09284217, 0.50007711, 0.37424032, 0.38977916])

    • 1
    • 2
    x>0.5         # 比较数组中每个元素值是否大于0.5

    • 1
    array([False,  True, False, False,  True, False, False,  True, False,
       False])

    • 1
    • 2
    x[x>0.5]      # 获取数组中大于0.5的元素

    • 1
    array([0.62911978, 0.78656564, 0.50007711])

    • 1
    x<0.5         # 获取数组中大于0.5的元素

    • 1
    array([ True, False,  True,  True, False,  True,  True, False,  True,
        True])

    • 1
    • 2
    sum((x>0.4)&(x<0.6))     # 值大于0.4且小于0.6的元素数量，True表示1，False表示0

    • 1
    3

    • 1
    np.all(x<1)        # 测试是否全部元素都小于1

    • 1
    True

    • 1
    np.any(x>0.8)     # 是否存在大于0.8的元素

    • 1
    False

    • 1
    a=np.array([1,2,3])
b=np.array([3,2,1])

    • 1
    • 2
    a>b                # 两个数组中对应位置上的元素比较

    • 1
    array([False, False,  True])

    • 1
    a[a>b]               # 数组a中大于b数组对应位置上元素的值

    • 1
    array([3])

    • 1
    a==b

    • 1
    array([False,  True, False])

    • 1
    a[a==b]

    • 1
    array([2])

    • 1
    x=np.arange(1,10)
x

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

    • 1
    x[(x%2==0)&(x>5)]         # 大于5的偶数，两个数组进行布尔与运算

    • 1
    array([6, 8])

    • 1
    x[(x%2==0)&(x>5)]        # 大于5的元素或者偶数元素，布尔或运算

    • 1
    array([6, 8])

    • 1

    1.12分段函数

    x=np.random.randint(0,10,size=(1,10))
x

    • 1
    • 2
    array([[7, 5, 6, 0, 8, 6, 3, 7, 6, 2]])

    • 1
    np.where(x<5,0,1)#小于5的元素值对应0，其他对应1

    • 1
    array([[1, 1, 1, 0, 1, 1, 0, 1, 1, 0]])

    • 1
    x.resize((2,5))
x

    • 1
    • 2
    array([[7, 5, 6, 0, 8],
       [6, 3, 7, 6, 2]])

    • 1
    • 2
    # 小于4的元素乘以2，大于7的元素乘以3，其他元素变为0
np.piecewise(x,[x<3,x>7],[lambda x:x*2,lambda x:x*3]) 

    • 1
    • 2
    array([[ 0,  0,  0,  0, 24],
       [ 0,  0,  0,  0,  4]])

    • 1
    • 2
    # 小于3的元素变为-1，大于3小于5的元素变为1，大于7的元素乘以4
# 条件没有覆盖到的其他元素变为0
np.piecewise(x,[x<3,(3<x)&(x<5),x>7],[-1,1,lambda x:x*4])

    • 1
    • 2
    • 3
    array([[ 0,  0,  0, -1, 32],
       [ 0,  0,  0,  0, -1]])

    • 1
    • 2

    1.13数组堆叠与合并

    arr1=np.array([1,2,3])
arr2=np.array([4,5,6])

    • 1
    • 2
    np.hstack((arr1,arr2))#水平堆叠

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

    • 1
    np.vstack((arr1,arr2))#垂直堆叠

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

    • 1
    • 2
    arr3=np.array([[1],[2],[3]])
arr4=np.array([[4],[5],[6]])

    • 1
    • 2
    arr3

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

    • 1
    • 2
    • 3
    arr4

    • 1
    array([[4],
       [5],
       [6]])

    • 1
    • 2
    • 3
    np.hstack((arr3,arr4))

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

    • 1
    • 2
    • 3
    np.vstack((arr3,arr4))

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    np.concatenate((arr1,arr2))

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

    • 1
    np.concatenate((arr3,arr4))

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    np.concatenate((arr3,arr4),axis=1)

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

    • 1
    • 2
    • 3

    2矩阵生成与常用操作

    2.1矩阵生成

    x=np.matrix([[1,2,3],[4,5,6]])
y=np.matrix([1,2,3,4,5,6])
# x[1,1]返回行下标和列下标都为1的元素
# 注意，对于矩阵x来说，x[1,1]和x[1][1]的含义不一样
print(x,y,x[1,1],sep='\n\n')

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

[[1 2 3 4 5 6]]

5

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2.2矩阵转置

    x=np.matrix([[1,2,3],[4,5,6]])
y=np.matrix([1,2,3,4,5,6])
print(x.T, y.T, sep='\n\n')

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    2.3查看矩阵特征

    import numpy as np

x = np.matrix([[1,2,3], [4,5,6]])
print(x.mean(), end='\n====\n')             # 所有元素平均值
print(x.mean(axis=0), end='\n====\n')       # 纵向平均值
print(x.mean(axis=0).shape, end='\n====\n')
print(x.mean(axis=1), end='\n====\n')       # 横向平均值
print(x.sum(), end='\n====\n')              # 所有元素之和
print(x.max(axis=1), end='\n====\n')        # 横向最大值
print(x.argmax(axis=1), end='\n====\n')     # 横向最大值的下标
print(x.diagonal(), end='\n====\n')         # 对角线元素
print(x.nonzero())                 # 非0元素下标，分别返回行下标和列下标

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    3.5
====
[[2.5 3.5 4.5]]
====
(1, 3)
====
[[2.]
 [5.]]
====
21
====
[[3]
 [6]]
====
[[2]
 [2]]
====
[[1 5]]
====
(array([0, 0, 0, 1, 1, 1], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    2.4矩阵乘法

    x=np.matrix([[1,2,3],[4,5,6]])
y=np.matrix([[1,2],[3,4],[5,6]])
print(x*y)

    • 1
    • 2
    • 3
    [[22 28]
 [49 64]]

    • 1
    • 2
    x

    • 1
    matrix([[1, 2, 3],
        [4, 5, 6]])

    • 1
    • 2
    y

    • 1
    matrix([[1, 2],
        [3, 4],
        [5, 6]])

    • 1
    • 2
    • 3

    2.5计算相关系数矩阵

    import numpy as np

print(np.corrcoef([1,2,3,4], [4,3,2,1]))  #负相关，变化方向相反
print(np.corrcoef([1,2,3,4], [8,3,2,1]))  #负相关，变化方向相反
print(np.corrcoef([1,2,3,4], [1,2,3,4]))  #正相关，变化方向一致
print(np.corrcoef([1,2,3,4], [1,2,3,40])) #正相关，变化趋势接近

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    [[ 1. -1.]
 [-1.  1.]]
[[ 1.         -0.91350028]
 [-0.91350028  1.        ]]
[[1. 1.]
 [1. 1.]]
[[1.        0.8010362]
 [0.8010362 1.       ]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    2.6计算方差、协方差、标准差

    import numpy as np

print(np.cov([1,1,1,1,1]))         # 方差
print(np.std([1,1,1,1,1]))         # 标准差
x = [-2.1, -1,  4.3]
y = [3,  1.1,  0.12]
X = np.vstack((x,y))               # 垂直堆叠矩阵
print(X)
print(np.cov(X))                   # 协方差
print(np.cov(x, y))
print(np.std(X))                   # 标准差
print(np.std(X, axis=1))
print(np.cov(x))                   # 方差

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    0.0
0.0
[[-2.1  -1.    4.3 ]
 [ 3.    1.1   0.12]]
[[11.71       -4.286     ]
 [-4.286       2.14413333]]
[[11.71       -4.286     ]
 [-4.286       2.14413333]]
2.2071223094538484
[2.79404128 1.19558447]
11.709999999999999

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    3计算特征值与特征向量

    对于n×n方阵A，如果存在标量λ和n 维非0向量 x → \overrightarrow{x} x ，使得A· x → \overrightarrow{x} x =λ x → \overrightarrow{x} x 成立，那么称 λ 是方阵 A 的一个特征值， x → \overrightarrow{x} x 为对应于 λ 的特征向量。

    从几何意义来讲，矩阵乘以一个向量，是对这个向量进行了一个变换，从一个坐标系变换到另一个坐标系。在变换过程中，向量主要发生旋转和缩放这两种变化。如果矩阵乘以一个向量之后，向量只发生了缩放变化而没有进行旋转，那么这个向量就是该矩阵的特征向量，缩放的比例就是特征值。或者说，特征向量是对数据进行旋转之后理想的坐标轴之一，而特征值则是该坐标轴上的投影或者贡献。特征值越大，表示这个坐标轴对原向量的表达越重要，原向量在这个坐标轴上的投影越大。一个矩阵的所有特征向量组成了该矩阵的一组基，也就是新坐标系中的轴。有了特征值和特征向量之后，向量就可以在另一个坐标系中进行表示。

    import numpy as np

A = np.array([[1,-3,3],[3,-5,3], [6,-6,4]])
e, v = np.linalg.eig(A)                # 特征值与特征向量
print(e, v, sep='\n')
print(np.dot(A,v))                     # 矩阵与特征向量的乘积
print(e*v)                             # 特征值与特征向量的乘积
print(np.isclose(np.dot(A,v), e*v))    # 验证二者是否相等
# 行列式|A-λE|的值应为0，det()是计算行列式的函数
print(np.linalg.det(A-np.eye(3,3)*e))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    [ 4. -2. -2.]
[[-0.40824829 -0.81034214  0.1932607 ]
 [-0.40824829 -0.31851537 -0.59038328]
 [-0.81649658  0.49182677 -0.78364398]]
[[-1.63299316  1.62068428 -0.38652141]
 [-1.63299316  0.63703074  1.18076655]
 [-3.26598632 -0.98365355  1.56728796]]
[[-1.63299316  1.62068428 -0.38652141]
 [-1.63299316  0.63703074  1.18076655]
 [-3.26598632 -0.98365355  1.56728796]]
[[ True  True  True]
 [ True  True  True]
 [ True  True  True]]
3.197442310920445e-14

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    4计算逆矩阵

    import numpy as np

x = np.matrix([[1,2,3], [4,5,6], [7,8,0]])
y = np.linalg.inv(x)
print(y)
print(x*y)          # 对角线元素为1，其他元素为0或近似为0
print(y*x)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    [[-1.77777778  0.88888889 -0.11111111]
 [ 1.55555556 -0.77777778  0.22222222]
 [-0.11111111  0.22222222 -0.11111111]]
[[ 1.00000000e+00  1.66533454e-16  1.38777878e-17]
 [-1.05471187e-15  1.00000000e+00  2.77555756e-17]
 [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]]
[[ 1.00000000e+00 -4.44089210e-16  0.00000000e+00]
 [ 2.77555756e-16  1.00000000e+00  0.00000000e+00]
 [ 6.93889390e-17  1.11022302e-16  1.00000000e+00]]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    5求解线性方程组

    import numpy as np

a = np.array([[3,1], [1,2]])   # 系数矩阵
b = np.array([9,8])            # 系数矩阵
x = np.linalg.solve(a, b)      # 求解
print(x)
print(np.dot(a, x))            # 验证
print(np.linalg.lstsq(a, b))   # 最小二乘解
                               # 返回解、余项、a的秩、a的奇异值

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    [2. 3.]
[9. 8.]
(array([2., 3.]), array([], dtype=float64), 2, array([3.61803399, 1.38196601]))


C:\Users\soul学长\AppData\Local\Temp/ipykernel_6100/2768563426.py:8: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.
To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.
  print(np.linalg.lstsq(a, b))   # 最小二乘解

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    6计算向量和矩阵的范数

    在线性代数中，一个n维空间中的一个点，向量的长度称为模或2-范数。对于向量 （x1，x2，x3，…….，xn），其模长也就是向量与自己的内积的平方根，计算公式为：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N5xQilnc-1684934726704)(C:\Users\soul学长\AppData\Roaming\Typora\typora-user-images\image-20230504225017086.png)]

    向量p-范数计算公式为（其中p为不等于0的整数）

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C8tEvynX-1684934726706)(C:\Users\soul学长\AppData\Roaming\Typora\typora-user-images\image-20230504225028955.png)]

    对于m×n的矩阵A，常用的范数有Frobenius范数（也称F-范数），其计算公式为：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HVSAtHB8-1684934726708)(C:\Users\soul学长\AppData\Roaming\Typora\typora-user-images\image-20230504225036293.png)]

    矩阵A的2-范数是矩阵A的共轭转置矩阵与A的乘积的最大特征值的平方根，其计算公式为：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c6KJmSIK-1684934726711)(C:\Users\soul学长\AppData\Roaming\Typora\typora-user-images\image-20230504225045638.png)]

    x=np.matrix([[1,2],[3,-4]])
print(np.linalg.norm(x))

    • 1
    • 2
    5.477225575051661

    • 1
    print(np.linalg.norm(x,-2))

    • 1
    1.9543950758485487

    • 1
    print(np.linalg.norm(x,-1))

    • 1
    4.0

    • 1
    print(np.linalg.norm([1,2,0,3,4,0],0))

    • 1
    4.0

    • 1
    print(np.linalg.norm([1,2,0,3,4],2))

    • 1
    5.477225575051661

    • 1

    7奇异值分解

    a=np.matrix([[1,2,3],[4,5,6],[7,8,9]])
u,s,v=np.linalg.svd(a)

    • 1
    • 2
    u

    • 1
    matrix([[-0.21483724,  0.88723069,  0.40824829],
        [-0.52058739,  0.24964395, -0.81649658],
        [-0.82633754, -0.38794278,  0.40824829]])

    • 1
    • 2
    • 3
    s

    • 1
    array([1.68481034e+01, 1.06836951e+00, 3.33475287e-16])

    • 1
    v

    • 1
    matrix([[-0.47967118, -0.57236779, -0.66506441],
        [-0.77669099, -0.07568647,  0.62531805],
        [-0.40824829,  0.81649658, -0.40824829]])

    • 1
    • 2
    • 3
    u*np.diag(s)*v

    • 1
    matrix([[1., 2., 3.],
        [4., 5., 6.],
        [7., 8., 9.]])

    • 1
    • 2
    • 3

    8函数向量化

    mat=np.matrix([[1,2,3],[4,5,6]])
mat

    • 1
    • 2
    matrix([[1, 2, 3],
        [4, 5, 6]])

    • 1
    • 2
    import math
a = math.factorial(4)
print(a)

    • 1
    • 2
    • 3
    24

    • 1
    vecFactorial=np.vectorize(math.factorial)#函数向量化
vecFactorial(mat)

    • 1
    • 2
    matrix([[  1,   2,   6],
        [ 24, 120, 720]])

    • 1
    • 2
  • 相关阅读:
    conventional-changelog standard-version 配置项
    Nacos集群搭建
    应用统计学考研笔记：数据整理与抽样案例
    LeetCode 623. 在二叉树中增加一行
    mybatis中foreach使用
    第十七章：Java连接数据库jdbc（java和myql数据库连接）
    C# 将一种类型的数组转换为另一种类型的数组
    windows环境下搭建redis5.x集群
    Jenkins（1）基础概念 与 安装部署简单说明
    通达信期货接口代码分享
  • 原文地址：https://blog.csdn.net/J__aries/article/details/130855895