NumPy 是一个用于科学计算的 Python 库。它提供了高效的多维数组对象 ndarray 和大量用于操作数组的函数。NumPy 的主要功能包括：

• 快速的数组运算。

• 矩阵运算。

• 用于随机数生成的函数。

• 线性代数运算。

• 统计函数（如最大值、最小值、平均值、中位数等）。

NumPy 在科学计算中广泛使用，因为它提供了高效的数组运算和矩阵运算，可以大大简化科学计算的代码。它还可以与其他的数据分析库（如 pandas 和 SciPy）很好地集成，提供更强大的数据分析功能。一般来说，NumPy 是在 Python 中进行科学计算的基础库，是很多科学计算库的基础。如果要在 Python 中进行科学计算，建议先学习 NumPy 库。

文档与参考网址：

• NumPy 教程 | 菜鸟教程 (runoob.com)

• NumPy官方中文文档

安装

pip install numpy

引入

import numpy as np

Numpy的核心：ndarray

NumPy的核心是ndarray（n维数组）对象，它是一个快速、灵活且可扩展的多维数组。你可以把ndarray看作为数学中的向量。

ndarray对象由两部分组成：数据和描述数据的元数据。数据是实际数组元素，而元数据包括数组的形状、数据类型和存储顺序。

创建ndarray

你可以通过调用NumPy的array函数来创建ndarray对象，它接受一个可迭代的对象（如列表、元组或其他数组）并返回一个新的ndarray对象。例如：

import numpy as np
​
# 创建一个一维数组
a = np.array([1, 2, 3])
print(a)  # [1 2 3]
​
# 创建一个二维数组
b = np.array([[1, 2, 3], [4, 5, 6]])
print(b)  # [[1 2 3]
         #      [4 5 6]]

除此之外，还可以使用其他的方式创建ndarray对象。如下：

• np.zeros(shape): 创建一个元素都为0的数组，shape可以是数字也可以是元组，如果输入一个数字，则创建一个有n个元素的向量，输入元组则创建一个x * y的矩阵

# 创建一个元素都为0的3x3矩阵
np.zeros((3, 3)) #     [[0. 0. 0.]
                 #      [0. 0. 0.]
                 #      [0. 0. 0.]]
​
# 创建一个元素都为0并且有3个元素的向量
np.zeros(3) # [0. 0. 0.]

• np.ones(shape): 创建一个元素都为1的数组，shape可以是数字也可以是元组，如果输入一个数字，则创建一个有n个元素的向量，输入元组则创建一个x * y的矩阵

# 创建一个元素都为1的3x3数组
np.ones((3, 3))  #     [[1. 1. 1.]
                 #      [1. 1. 1.]
                 #      [1. 1. 1.]]
# 创建一个元素都为1并且有3个元素的向量
np.ones(3) # [1. 1. 1.]

• np.eye(N): 创建一个n * n的单位矩阵

# 创建一个3x3的单位矩阵
np.eye(3) #     [[1. 0. 0.]
          #      [0. 1. 0.]
          #      [0. 0. 1.]]

• np.arange(start, stop, step): 创建一个等差数列的数组

# 创建一个等差数列数组，起始值为0，终止值为1，步长为0.1
np.arange(0, 1, 0.1) #  [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

• np.linspace(start, stop, num=50): 创建一个均匀分布的数组

# 创建一个均匀分布的数组，起始值为0，终止值为1，元素个数为5
np.linspace(0, 1, 5) #  [0.   0.25 0.5  0.75 1.  ]

• np.random.random(size): 创建一个的随机数(大小不大于1)的数组，size可以是数字也可以是元组，如果输入一个数字，则创建一个有n个元素的向量，输入元组则创建一个x * y的矩阵

# 创建一个3x3的随机数矩阵
np.random.random((3, 3))    #     [[0.79687771 0.13244968 0.21523274]
                            #      [0.24786926 0.32724818 0.78840362]
                            #      [0.15807901 0.11015224 0.74444607]]
# 创建一个具有3个元素的随机数向量
np.random.random(3) # [0.3172022  0.51064917 0.88901291]

• np.full(shape, fill_value): 创建一个填充数组，fill_value为填充的内容，shape可以是数字也可以是元组，如果输入一个数字，则创建一个有n个元素的向量，输入元组则创建一个x * y的矩阵

# 创建一个3x3的常数矩阵
np.full((3, 3), np.pi)      #     [[3.14159265 3.14159265 3.14159265]
                            #      [3.14159265 3.14159265 3.14159265]
                            #      [3.14159265 3.14159265 3.14159265]]
# 创建一个具有3个元素的常数向量
np.full(3, np.pi) #     [[3.14159265 3.14159265 3.14159265]

访问ndarry中的元素

若想访问ndarray中的元素，可以像普通列表一样对某个下标的元素进行访问，下标都是从0开始。例如：

array = np.array([1, 2, 3])
print(array[0])  # 1
print(type(array[0])) # <class 'numpy.int32'>

注意，ndarry中元素的数据类型不再是python中的int，而是numpy的int32，关于numpy的数据类型接下来会详解讲解。

数据类型

numpy支持的数据类型比Python内置的类型要多很多，基本上可以和C语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了常用 NumPy 基本类型。

numpy.dtype

numpy.dtype是NumPy中用于表示数据类型的对象。你可以通过调用numpy.dtype函数来创建一个数据类型对象，它接受一个数据类型的字符串描述作为参数。例如：

# 创建一个浮点型数据类型对象
float_dtype = np.dtype('float')
print(float_dtype)  # float64

# 创建一个布尔型数据类型对象
bool_dtype = np.dtype('bool')
print(bool_dtype)  # bool

# 创建一个字符串型数据类型对象，长度为5
string_dtype = np.dtype('S5')
print(string_dtype)  # |S5

你还可以使用np.int8、np.int16、np.int32、np.int64、np.float32、np.float64等等来创建数据类型对象。还可以使用数据类型对象来创建复合数据类型，例如：

# 创建一个结构体数据类型，包含两个字段：'name'和'age'
struct_dtype = np.dtype([('name', 'S10'), ('age', 'i4')])

# 使用结构体数据类型创建数组
s = np.array([('Alice', 20), ('Bob', 30)], dtype=struct_dtype)
print(s)  # [(b'Alice', 20) (b'Bob', 30)]

# 访问数组中的字段
print(s['name'])  # [b'Alice' b'Bob']
print(s['age'])   # [20 30]

# 修改数组中的字段
s['age'] = 25
print(s)  # [(b'Alice', 25) (b'Bob', 25)]

创建数据类型对象后，可以利用它来创建数组，例如：

# 创建一个浮点型数据类型对象
float_dtype = np.dtype('float')

# 使用浮点型数据类型对象创建数组
a = np.array([1, 2, 3], dtype=float_dtype)
print(a)  # [1. 2. 3.]

# 创建一个布尔型数据类型对象
bool_dtype = np.dtype('bool')

# 使用布尔型数据类型对象创建数组
b = np.array([True, False, True], dtype=bool_dtype)
print(b)  # [ True False  True]

# 创建一个字符串型数据类型对象，长度为5
string_dtype = np.dtype('S5')

# 使用字符串型数据类型对象创建数组
c = np.array(['abc', 'def'], dtype=string_dtype)
print(c)  # [b'abc' b'def']

ndarray.dtype

为了获取数组的数据类型，可以使用ndarray.dtype属性来获取数组的数据类型，例如：

# 创建一个浮点型数组
a = np.array([1, 2, 3], dtype='float')

# 获取数组的数据类型
print(a.dtype)  # float64

若想进行数据类型转换，可以使用ndarray.astype方法来将数组的数据类型转换为另一种数据类型。例如：

# 创建一个浮点型数组
a = np.array([1, 2, 3], dtype='float')

# 获取数组的数据类型
dtype = a.dtype
print(dtype)  # float64

# 将数组的数据类型转换为整型
b = a.astype('int')
print(b)  # [1 2 3]

切片和索引

在使用ndarray对象时，你可以和普通数组一样通过切片和索引来访问其中的元素。

切片

切片是一种通过索引访问数组元素的方式，可以通过使用冒号来访问一个范围内的元素。例如，访问数组arr中第2到5个元素：

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

# 使用切片访问数组中第2到5个的元素
print(arr[2:5]) # [3 4 5]

除了使用冒号来切片外，还可以使用 numpy.ix_() 函数创建一个索引对象来进行多维数组的切片。

例如：

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

# 使用索引对象访问第二维索引为 1 和第三维索引为 2 的元素
idx = np.ix_([1], [2])
print(arr[idx]) # [[6]]

矩阵的切片

上面介绍了一维向量的切片，如果该数组是一个矩阵，可以进行如下的切片操作

首先我们创建一个3阶单位阵

array = np.eye(3)

我们对矩阵的第一行进行切片，方法如下：

# 访问矩阵的第一行
first_row = array[0]
print(first_row)  # [1. 0. 0.]

然后我们对矩阵的第一列进行切片，方法如下：

# 访问矩阵的第一列
first_column = array[:, 0]
print(first_column)  # [1. 0. 0.]

接下来我们切掉矩阵的第一行和第一列，方法如下：

# 切掉矩阵的第一行和第一列，访问矩阵的右下角2*2的子矩阵
sub_matrix = array[1:, 1:]
print(sub_matrix)   # [[1. 0.]
                    #  [0. 1.]]

注意array[1:, 1:]中，1:中的1代表的是数量，表示切掉多少行多少列，顺序是从左往右，从上往下。

array = np.eye(5)
print(array)    # [[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.]]

print(array[2:, 1:])    # [[0. 1. 0. 0.]
                        #  [0. 0. 1. 0.]
                        #  [0. 0. 0. 1.]]

索引

索引是一种通过指定单个元素的索引来访问数组元素的方式。例如，访问数组arr中索引为7的元素：

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

# 使用索引访问数组中索引为 7 的元素
print(arr[7]) # 8

索引的模式和下标一致，但是它支持更加复杂的操作，其中常用的是布尔索引和花式索引。

布尔索引：布尔索引是一种使用布尔数组来索引数组元素的方式，可以通过使用条件判断来寻找数组中的元素。例如，访问数组中值大于5的元素：

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

print(arr > 5) # [False False False False False  True  True  True  True  True]
print(arr[arr > 5]) # [ 6  7  8  9 10]

花式索引：花式索引是一种使用整数数组来索引数组元素的方式，可以使用列表访问数组中多个不同索引的元组。例如，访问数组中索引为[3, 1, 4]的元素：

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

广播（Broadcast）

广播是 NumPy 中的一种强大的功能，它允许在不同形状的数组之间进行数学运算。广播会自动复制小数组以匹配大数组的形状。这样，就可以在不同形状的数组之间执行数学运算。

举个例子：

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

# 广播：b 变成 [2, 2, 2]
c = a + b
print(c) # [3 4 5]

也可以用于多维数组的广播。例如：

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

# 广播：b 变成 [[2, 3, 4], [2, 3, 4]]
c = a + b
print(c) # [[ 3  5  7]
        #  [ 6  8 10]]

可以看到，即使b的维度与a不对应，a也可以与b进行运算。

使用广播，低维度数组的数量需要和高维度数组的列数量对应。上面的多维数组的例子，如果将b的数组换为b = np.array([2, 3])，则会报如下错误：

ValueError: operands could not be broadcast together with shapes (2,3) (2,) 

也就是说，a的列数量为3，b的列数量2，无法进行广播。

字符串操作

精确匹配

如果我们想要寻找字符串数组的某一个字符，我们可以使用布尔索引进行精确查找，方法如下：

str_array = np.array(['Hello', ' World!', ' How are you?'])

print(str_array == "Hello") # [ True False False]
print(str_array[str_array == "Hello"]) # ['Hello']

模糊匹配

如果我们想要寻找字符串数组的某一些字符，我们可以使用字符串函数numpy.char.find(array, sub)寻找对应的字符，并且使用布尔索引返回对应的元素，方法如下：

str_array = np.array(['Hello', ' World!', ' How are you?'])

print(np.char.find(str_array, "l") > 0) # [ True  True False]
print(str_array[np.char.find(str_array, "l") > 0]) # ['Hello' ' World!']

字符串函数

numpy中有许多字符串函数可以用于处理数组中的字符串。其中一些常用的字符串函数包括：

这些函数都可以用于处理数组中的字符串，并返回修改后的字符串数组。

例如：

str_array = np.array(['Hello', ' World!', ' How are you?'])
print(np.char.upper(str_array)) # ['HELLO' ' WORLD!' ' HOW ARE YOU?']

数学运算

为了执行一些数学运算，numpy提供了非常多的用在数学运算中的函数。

运算函数

numpy提供了一组用于执行算术运算的函数。需要注意的是数组必须具有相同的形状或符合数组广播规则。其中一些常用的函数包括：

这些函数都可以用于处理数组中的数字，并返回计算结果。

例如：

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

数学函数

numpy提供了许多用于操作数组和矩阵的数学函数，包括三角函数，算术运算的函数，复数处理函数等。以下是一些常用的 NumPy 数学函数：

这些函数都可以用于处理数组中的数字，并返回计算结果。例如：

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
print(np.sqrt(arr)) 
# [ 1.          1.41421356  1.73205081  2.          2.23606798]

不仅如此，numpy提供了一组用于执行更复杂的数学运算的函数。其中一些常用的函数包括：

例如，使用 numpy.fft.fft() 函数对数组进行快速傅里叶变换：

x = np.array([1, 2, 3, 4])
y = np.fft.fft(x)
print(y)

线性代数

NumPy 提供了一组用于线性代数运算的函数。其中一些常用的函数包括：

例如，可以使用numpy.linalg.inv()函数计算矩阵的逆矩阵：

import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.linalg.inv(a)
print(b)

或使用numpy.linalg.solve()函数来求解线性方程组：

import numpy as np
a = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(a, b)
print(x)

统计函数

NumPy 提供了一组用于统计分析的函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。其中一些常用的函数包括：

这些函数都可以用于处理数组中的数字，并返回计算结果。

例如：

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
print(np.mean(arr)) 
# 3.0

排序、条件刷选函数

NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。

其中一些常用的函数包括：

这些函数都可以用于处理数组中的数字，并返回计算结果。

例如：

import numpy as np
​
arr = np.array([1, 4, 2, 5, 3])
print(np.sort(arr)) 
# [1 2 3 4 5]
​
condition = arr > 2
new_arr = np.extract(condition, arr)
print(new_arr)
# [4, 5, 3]