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

numpy数组及其运算

创建数组

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

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

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

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

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

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

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

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

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

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

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

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

np.arange(8)

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

np.arange(1,10,2)

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

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

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

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

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

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

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

np.logspace(0,100,10)#相当于10**np.linspace(0,100,10)

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])

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

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

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

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

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

np.ones(3)

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

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

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

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

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

np.zeros((3,1))

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

np.ones((3,3))

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

np.ones((1,3))

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

np.identity(3)#单位矩阵

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

np.identity(2)

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

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

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

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

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

np.hamming(20)#Hamming窗口

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      ])

np.blackman(10)#Blackman窗口

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])

np.kaiser(12,5)#Kaiser窗口

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])

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

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

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

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

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

np.random.rand(10)

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

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

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

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

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]]])

np.diag([1,2,3,4])                 # 对角矩阵

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

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

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))

False
True
True
[ True False  True False False]
[ True  True  True  True  True]

修改数组中的元素值

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

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

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

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

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

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

x              # 不影响原来的数组

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

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

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

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

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

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

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

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

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

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

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

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

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

数组与标量的运算

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

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

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

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

x/2        # 数组与数值相除

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

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

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

x**3        # 幂运算

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

x+2         # 数组与数值相加

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

x%3         # 余数

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

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

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

2/x

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

63//x

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

数组与数组的运算

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

array([5, 5, 5, 5])

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

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

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

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

array([2, 4, 6])

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

array([1, 4, 9])

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

array([0, 0, 0])

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

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

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

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

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

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

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

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

a+b       # a中每个元素加b中的对应列元素

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

数组排序

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

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

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

array([1, 2, 3])

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

(3, 1)

np.argsort(x)

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

x[_]

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

x.sort()         # 原地排序

x

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

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

x

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

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

x

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

数组的内积运算

$x·y=\sum^n _{i=1}{x_iy_i}$

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))

32
32
32

访问数组中的元素

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

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

b[0]      # 第0行所有元素     

array([1, 2, 3])

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

1

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

3

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

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

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

array([3, 8, 4])

a=np.arange(10)
a

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

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

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

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

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

a[:5]  # 前5个元素

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

c=np.arange(25)
c

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])

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

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]])

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

array([2, 3, 4])

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

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

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

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

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

array([ 7, 19])

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

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

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

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

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

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

c[[1,3]]     # 第1行和第3行所有元素

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

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

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

数组对函数运算的支持

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

[ 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]

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

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

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

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

print(np.round(np.cos(x)))  # 四舍五入

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

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

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

改变数组形状

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

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

x.shape  # 查看数组的形状

(10,)

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

10

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

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

x.shape

(2, 5)

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

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

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

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

x=np.array(range(5))

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

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

ValueError                                Traceback (most recent call last)

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


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

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

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

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

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

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

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

数组布尔运算

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

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

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

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

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

array([0.62911978, 0.78656564, 0.50007711])

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

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

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

3

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

True

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

False

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

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

array([False, False,  True])

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

array([3])

a==b

array([False,  True, False])

a[a==b]

array([2])

x=np.arange(1,10)
x

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

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

array([6, 8])

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

array([6, 8])

分段函数

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

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

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

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

x.resize((2,5))
x

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

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

array([[ 0,  0,  0,  0, 24],
       [ 0,  0,  0,  0,  4]])

# 小于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])

array([[ 0,  0,  0, -1, 32],
       [ 0,  0,  0,  0, -1]])

数组堆叠与合并

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

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

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

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

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

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

arr3

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

arr4

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

np.hstack((arr3,arr4))

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

np.vstack((arr3,arr4))

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

np.concatenate((arr1,arr2))

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

np.concatenate((arr3,arr4))

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

np.concatenate((arr3,arr4),axis=1)

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

矩阵生成与常用操作

矩阵生成

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 6]]

[[1 2 3 4 5 6]]

5

矩阵转置

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 4]
 [2 5]
 [3 6]]

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

查看矩阵特征

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元素下标，分别返回行下标和列下标

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))

矩阵乘法

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

[[22 28]
 [49 64]]

x

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

y

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

计算相关系数矩阵

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. -1.]
 [-1.  1.]]
[[ 1.         -0.91350028]
 [-0.91350028  1.        ]]
[[1. 1.]
 [1. 1.]]
[[1.        0.8010362]
 [0.8010362 1.       ]]

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

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))                   # 方差

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

计算特征值与特征向量

对于n×n方阵A，如果存在标量λ和n 维非0向量$\overrightarrow{x}$，使得A·$\overrightarrow{x}$=λ$\overrightarrow{x}$成立，那么称 λ 是方阵 A 的一个特征值，$\overrightarrow{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))

[ 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

计算逆矩阵

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.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]]

求解线性方程组

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的奇异值

[2. 3.]
[9. 8.]
(array([2., 3.]), array([], dtype=float64), 2, array([3.61803399, 1.38196601]))

计算向量和矩阵的范数

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

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

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

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

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

5.477225575051661

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

1.9543950758485487

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

4.0

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

4.0

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

5.477225575051661

奇异值分解

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

u

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

s

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

v

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

u*np.diag(s)*v

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

函数向量化

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

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

import math
a = math.factorial(4)
print(a)

24

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

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

来自书籍：《Python数据分析、挖掘与可视化》