目录
一、什么是numpy库
NumPy（Numerical Python）是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。（转自numpy_百度百科 (baidu.com)）
在开始之前，我们要知道numpy库在使用时，通常会简化为“np”（牛啤库），因此我们会像这样：（接下来np即指numpy）
import numpy as np二、关于矩阵和向量
1、用numpy表达矩阵
矩阵有行和列，那么自然我们可以用二维数组（列表）进行创建
在此之前先看看一维数组（列表）在np中的效果：
lst = [1, 2, 3]
y = np.array(lst, )
print(y, type(y))
>>> [1 2 3] <class 'numpy.ndarray'>所以用二维数组（列表）创建出的矩阵是这样：
lst_2 = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
A = np.array(lst_2, )
print(A, type(A))
>>> [[1 2 3]
>>> [4 5 6]
>>> [7 8 9]] <class 'numpy.ndarray'>那么三维的则是：
B = np.array([
[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
])
print(B, type(B))
>>> [[[1 2 3]
>>> [4 5 6]
>>> [7 8 9]]
>>>
>>> [[1 2 3]
>>> [4 5 6]
>>> [7 8 9]]
>>>
>>> [[1 2 3]
>>> [4 5 6]
>>> [7 8 9]]] <class 'numpy.ndarray'>2、计算两个向量或矩阵的内积
注意：计算符号为 @
向量内积
对应元素相乘再相加
y1 = np.array([1, 2, 3])
y2 = np.array([3, 4, 5])
print(y1 @ y2)
>>> 26矩阵内积
A的列数 等于 B的行数 (线性代数) --> 3*5矩阵 和 5*n矩阵 最终得 3*n矩阵
A = np.array(lst_2, )
B = np.array([[1, 2, 3, 6, 10],
[7, 2, 3, 8, 3],
[10, 2, 3, 0, 7]])
C = A @ B
print(C)
>>> [[ 45 12 18 22 37]
>>> [ 99 30 45 64 97]
>>> [153 48 72 106 157]]矩阵行列求和
B = np.array([[1, 2, 3, 6, 10],
[7, 2, 3, 8, 3],
[10, 2, 3, 0, 7]])
print(np.sum(B, axis=0)) # 列求和
print(np.sum(B, axis=1)) # 行求和三、numpy的基础操作
1、创建 NumPy 数组
# 从列表创建
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
# 从元组创建
arr2 = np.array((1, 2, 3, 4, 5))
print(arr2)
# 创建二维数组
arr3 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr3)
# 特殊矩阵
print(np.eye(5)) # 单位矩阵
print(np.zeros(shape=(3, 4))) # 零矩阵
E = np.ones(shape=(3, 4)) # 1矩阵
print(E)样例输出：
>>> [1 2 3 4 5]
>>> [1 2 3 4 5]
>>> [[1 2 3]
>>> [4 5 6]]
>>> [[1. 0. 0. 0. 0.]
>>> [0. 1. 0. 0. 0.]
>>> [0. 0. 1. 0. 0.]
>>> [0. 0. 0. 1. 0.]
>>> [0. 0. 0. 0. 1.]]
>>> [[0. 0. 0. 0.]
>>> [0. 0. 0. 0.]
>>> [0. 0. 0. 0.]]
>>> [[1. 1. 1. 1.]
>>> [1. 1. 1. 1.]
>>> [1. 1. 1. 1.]]2、数组属性
# 数组维度
print(arr3.ndim)
# 数组形状
print(arr3.shape)
# 数组大小
print(arr3.size)
# 数组元素类型
print(arr3.dtype)
样例输出：
>>> 2
>>> (2, 3)
>>> 6
>>> int64
3、数组操作
# 数组切片
print(arr3[0, 0]) # 第一个元素
print(arr3[0, :]) # 第一行元素
print(arr3[:, 0]) # 第一列元素
# 数组重塑
arr4 = np.arange(12)
print(arr4)
arr5 = arr4.reshape((3, 4))
print(arr5)
# 数组拼接
arr6 = np.array([[7, 8, 9]])
arr7 = np.concatenate((arr3, arr6), axis=0)
print(arr7)
# 数组转置
E = np.ones(shape=(3, 4)) # 1矩阵
print(E.T) # 矩阵转置样例输出：
>>> 1
>>> [1 2 3]
>>> [1 4]
>>> [ 0 1 2 3 4 5 6 7 8 9 10 11]
>>> [[ 0 1 2 3]
>>> [ 4 5 6 7]
>>> [ 8 9 10 11]]
>>> [[1 2 3]
>>> [4 5 6]
>>> [7 8 9]]
>>> [[1. 1. 1.]
>>> [1. 1. 1.]
>>> [1. 1. 1.]
>>> [1. 1. 1.]]4、数组计算
# 数组加减乘除
arr8 = np.array([1, 2, 3])
arr9 = np.array([4, 5, 6])
print(arr8 + arr9)
print(arr8 - arr9)
print(arr8 * arr9)
print(arr8 / arr9)
# 矩阵乘法
arr10 = np.array([[1, 2], [3, 4]])
arr11 = np.array([[5, 6], [7, 8]])
print(np.dot(arr10, arr11))
样例输出：
>>> [5 7 9]
>>> [-3 -3 -3]
>>> [ 4 10 18]
>>> [0.25 0.4 0.5 ]
>>> [[19 22]
>>> [43 50]]
四、统计计算和算术计算
y = np.array([1, 2, 3])
r1 = np.sum(y) # 和
print(r1)
r2 = np.mean(y) # 均值
print(r2)
r3 = np.var(y) # 方差
print(r3)
>>> 6
>>> 2.0
>>> 0.6666666666666666五、余弦相似度
余弦相似度是一种用于比较两个向量之间相似度的度量方法，通常用于文本挖掘、信息检索、图像处理等领域。
余弦相似度的计算公式如下：
cosine_similarity = (A·B) / (||A|| ||B||)
其中：
A 和 B 是两个向量，A·B 表示 A 和 B 的点积（内积），||A|| 和 ||B|| 分别表示 A 和 B 的模长（长度）。
余弦相似度的值介于 -1 到 1 之间，如果两个向量的余弦相似度越接近 1，表示它们越相似；如果余弦相似度越接近 -1，则表示它们越不相似；如果余弦相似度接近 0，则表示它们之间的相似度很低。
在这里先给出模板：
def cosine_similarity(X, Y):
"""
计算两个矩阵的余弦相似度矩阵
参数：
- X: shape (m, n) 的矩阵
- Y: shape (k, n) 的矩阵
返回：
- shape (m, k) 的矩阵，表示 X 的每一行与 Y 的每一行的余弦相似度
"""
X_norm = np.sqrt(np.sum(X ** 2, axis=1, keepdims=True)) # 计算 X 的每一行的模长
Y_norm = np.sqrt(np.sum(Y ** 2, axis=1, keepdims=True)) # 计算 Y 的每一行的模长
dot_product = np.dot(X, Y.T) # 计算 X 和 Y 的矩阵乘积
similarity = dot_product / np.dot(X_norm, Y_norm.T) # 计算余弦相似度
return similarity样例：
a = np.array([1, 2, 0])
b = np.array([2, 0, 3])
similarity = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
print('余弦相似度为:', similarity)六、注意点
在使用numpy的过程中，有一些需要特别注意的点：
-
numpy中的数组是静态的，即一旦创建后，其形状和大小就不可更改。如果需要更改数组的形状或大小，需要创建一个新的数组。
-
numpy中的数组是按照行优先（row-major）的顺序存储的，即相邻的元素在内存中是相邻的。
-
numpy中的一些函数可以直接作用于整个数组或数组的某个维度，需要注意函数的参数和返回值的形状和大小。
-
在numpy中进行数组运算时，需要注意数组的形状和大小是否匹配。如果数组形状不匹配，会抛出异常。
-
在使用numpy时，需要注意数据类型的选择。numpy支持多种数据类型，包括整型、浮点型、布尔型等。在进行数组运算时，需要保证数据类型相同，否则可能会出现类型错误。
-
在使用numpy时，需要注意数组的内存占用情况。numpy的数组通常会占用较大的内存空间，如果数据集过大，可能会导致内存不足的问题。
总之，在使用numpy时，需要仔细阅读文档，了解函数的参数和返回值，以及函数的限制和注意事项，才能更好地使用numpy完成任务。