NumPy是机器学习技术栈的基础，它能对机器学习中常用的数据结构——向量(vector)、矩阵(matrice)、张量(tensor)等进行高效的操作。

1.创建向量、矩阵、稀疏矩阵

import numpy as np
from scipy import sparse

# 创建一个行向量
vector_row = np.array([1, 2, 3])
# 创建一个列向量
vector_column = np.array([[1], [2], [3]])

# 创建一个矩阵
matrix = np.array([[1, 2], [4, 5], [4, 7]])

# 创建一个稀疏矩阵
matrix_sparse = sparse.csr_matrix(matrix)

2.选择元素（索引和切片）

import numpy as np

vector = np.array([1, 2, 3, 4, 5, 6])
print(vector[2])
print(vector[-2])
print(vector[:])
print(vector[:2])
print(vector[2:])

print('------------------------------------------')
matrix = np.array([[1, 2, 3], [4, 5, 4], [4, 7, 8]])
print(matrix[2])
print(matrix[0,0])
print(matrix[:2, :])
print(matrix[:, 1:2])

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

3.查看常见属性

import numpy as np

vector = np.array([1, 2, 3, 4, 5, 6])
print('查看行数、列数', vector.shape)
print('查看元素的数量', vector.size)
print('查看维数', vector.ndim)

print('----------------------------------------')
matrix = np.array([[1, 2, 3], [4, 5, 4], [4, 7, 8]])
print('查看行数、列数', matrix.shape)
print('查看元素的数量', matrix.size)
print('查看维数', matrix.ndim)

查看行数、列数 (6,)
查看元素的数量 6
查看维数 1
------------------------------------------
查看行数、列数 (3, 3)
查看元素的数量 9
查看维数 2

4.常见的计算

import numpy as np

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

# 多个元素同时运算
print(matrix + 10)
print(matrix * 10)

# 返回最大元素
print(np.max(matrix))
# 返回每一列的最大元素
print(np.max(matrix, axis=0))
# 返回每一行的最大元素
print(np.max(matrix, axis=1))

# 计算平均值
print(np.mean(matrix))
# 计算方差
print(np.var(matrix))
# 计算标准差
print(np.std(matrix))
# 计算每一列平均值
print(np.mean(matrix, axis=0))
# 计算每一列方差
print(np.var(matrix, axis=0))
# 计算每一列标准差
print(np.std(matrix, axis=0))

[[11 12 13]
 [14 15 14]
 [14 17 18]]
[[10 20 30]
 [40 50 40]
 [40 70 80]]
8
[4 7 8]
[3 5 8]
4.222222222222222
4.395061728395062
2.096440251568134
[3.         4.66666667 5.        ]
[2.         4.22222222 4.66666667]
[1.41421356 2.05480467 2.1602469 ]

5.矩阵变形

import numpy as np

# 创建一个4*3的矩阵
matrix = np.array([[1, 2, 3], [4, 5, 4], [4, 7, 8], [9, 9, 9]])
print(matrix)

# 将该矩阵变形为2*6的矩阵
matrix_new01 = matrix.reshape(2, 6)
print(matrix_new01)

# 将矩阵变形为数组
matrix_new02 = matrix.reshape(12)
print(matrix_new02)

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

6.转置

import numpy as np

# 创建一个矩阵
matrix = np.array([[1, 2, 3], [4, 5, 4], [4, 7, 8], [9, 9, 9]])
print(matrix)

# 转置矩阵
matrix_new03 = matrix.T
print(matrix_new03)

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

7.展开矩阵

import numpy as np

# 创建一个4*3的矩阵
matrix = np.array([[1, 2, 3], [4, 5, 4], [4, 7, 8], [9, 9, 9]])
print(matrix)

# 展开矩阵:
# 方法一：flatten() --> 变成一维数组
matrix_new06 = matrix.flatten()
print(matrix_new06)

# 方法二：reshape(元素个数) --> 变成一维数组
matrix_new07 = matrix.reshape(12)
print(matrix_new07)

# 方法三：reshape(1, -1) --> 变成行向量
matrix_new08 = matrix.reshape(1, -1)
print(matrix_new08)

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

8.常见的线性代数计算

import numpy as np

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

# 计算矩阵的秩
print(np.linalg.matrix_rank(matrix))

# 计算行列式
print(np.linalg.det(matrix))

# 获取矩阵的对角线元素：offset参数控制上下移
print(matrix.diagonal())
print(matrix.diagonal(offset=1))
print(matrix.diagonal(offset=-1))

# 计算矩阵的迹:对角线元素之和
print(matrix.trace())
print(sum(matrix.diagonal()))

# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(matrix)
print(eigenvalues)
print(eigenvectors)

# 计算矩阵的逆
print(np.linalg.inv(matrix))

3
3.999999999999999
[1 5 8]
[2 4]
[4 7]
14
14
[13.65529313+0.j          0.17235343+0.51305068j  0.17235343-0.51305068j]
[[ 0.27384267+0.j          0.48506732-0.24336824j  0.48506732+0.24336824j]
 [ 0.50486987+0.j         -0.72719967+0.j         -0.72719967-0.j        ]
 [ 0.8186065 +0.j          0.39259843+0.15009567j  0.39259843-0.15009567j]]
 [[ 3.    1.25 -1.75]
 [-4.   -1.    2.  ]
 [ 2.    0.25 -0.75]]

9.矩阵的加减乘

import numpy as np

# 矩阵加减法
matrix_a = np.array([[1, 2, 3], [0, 0, 0], [10, 20, 30]])
matrix_b = np.array([[100, 200 ,300], [100, 100, 100], [500, 500, 500]])
print(matrix_a + matrix_b)
print(np.add(matrix_a, matrix_b))

print(matrix_a - matrix_b)
print(np.subtract(matrix_a, matrix_b))

# 矩阵乘法
print(np.dot(matrix_a, matrix_b))
print(matrix_a @ matrix_b)

# 矩阵对应元素相乘
print(matrix_a * matrix_b)

[[101 202 303]
 [100 100 100]
 [510 520 530]]
 
[[101 202 303]
 [100 100 100]
 [510 520 530]]
 
[[ -99 -198 -297]
 [-100 -100 -100]
 [-490 -480 -470]]
 
[[ -99 -198 -297]
 [-100 -100 -100]
 [-490 -480 -470]]
 
[[ 1800  1900  2000]
 [    0     0     0]
 [18000 19000 20000]]
 
[[ 1800  1900  2000]
 [    0     0     0]
 [18000 19000 20000]]
 
[[  100   400   900]
 [    0     0     0]
 [ 5000 10000 15000]]

10.生成随机数

import numpy as np

# 随机数种子:返回同样的数字
np.random.seed(0)

# 生成3个0~1之间的浮点数
print(np.random.random(3))
# 生成3个1~10之间的浮点数
print(np.random.randint(0, 11, 3))
# 从【1.0，2.0)中抽取3个数
print(np.random.uniform(1.0, 2.0, 3))
# 从平均值0，标准差1的正态分布中，随机抽取3个数
print(np.random.normal(0.0, 1.0, 3))

# 随机生成矩阵
print(np.random.randn(3, 4))

[0.5488135  0.71518937 0.60276338]
[3 7 9]
[1.6235637  1.38438171 1.29753461]
[-0.05503512 -0.10731045  1.36546718]
-----------------------------------------------------------
[[-0.09769572 -2.42595457 -0.4530558  -0.470771  ]
 [ 0.973016   -1.27814912  1.43737068 -0.07770457]
 [ 1.08963016  0.09654267  1.41866711  1.16827314]]