Python是一种流行的编程语言，被广泛用于数据科学和机器学习等领域。
其中，numpy是一个Python包，它提供了一个强大的多维数组对象，以及对这些数组进行操作的函数。
在本教程中，我们将深入介绍numpy的使用，包括创建数组、数组操作、数组索引、数组分片、数组计算、数组广播、线性代数操作等等。本教程将涵盖以下主题：
- numpy的安装
- numpy数组的创建
- 数组的形状和尺寸
- 数组操作
- 数组索引和切片
- 数组计算
- 数组广播
- 线性代数操作
- 性能优化
- 示例程序
在开始之前，请确保您已经安装了numpy。如果您还没有安装numpy，可以使用以下命令安装：
pip install numpy
1. numpy的安装
在开始使用numpy之前，您需要先安装它。在大多数情况下，您可以使用以下命令来安装numpy：
pip install numpy
如果您使用的是Anaconda发行版，则numpy可能已经预装了。您可以使用以下命令来检查numpy是否已安装：
conda list numpy
如果numpy已安装，则会在输出中显示它的版本号。如果numpy未安装，则会显示错误消息。
2. numpy数组的创建
numpy数组是一个多维数组对象，它包含相同类型的元素。您可以使用以下方法之一来创建numpy数组：
方法1：使用numpy.array()函数
使用numpy.array()函数可以将列表或元组转换为numpy数组。例如：
import numpy as np
# 将列表转换为numpy数组
a = np.array([1, 2, 3])
print(a) # 输出 [1 2 3]
# 将元组转换为numpy数组
b = np.array((4, 5, 6))
print(b) # 输出 [4 5 6]
方法2：使用numpy.zeros()和numpy.ones()函数
numpy.zeros()函数可以创建一个由0组成的数组，而numpy.ones()函数可以创建一个由1组成的数组。例如：
import numpy as np
# 创建一个由0组成的数组
a = np.zeros((2, 3))
print(a)
# 输出
# [[0. 0. 0.]
# [0. 0. 0.]]
# 创建一个由1组成的数组
b = np.ones((3, 2))
print(b)
# 输出
# [[1. 1.]
# [1. 1.]
# [1. 1.]]
方法3：使用numpy.arange()函数
numpy.arange()函数可以创建一个等间隔的数组。例如：
import numpy as np
# 创建一个等间隔的数组
a = np.arange(1, 7)
print(a) # 输出 [1 2 3 4 5 6]
方法4：使用numpy.linspace()函数
numpy.linspace()函数可以创建一个等间隔的数组，但与numpy.arange()函数不同的是，它可以指定数组的长度。例如：
import numpy as np
# 创建一个长度为6的等间隔数组
a = np.linspace(1, 6, 6)
print(a) # 输出 [1. 2. 3. 4. 5. 6.]
方法5：使用numpy.random.rand()和numpy.random.randn()函数
numpy.random.randn()函数可以创建一个由随机数组成的数组，这些随机数是从标准正态分布中生成的。
例如：
import numpy as np
# 创建一个由随机数组成的数组
a = np.random.rand(2, 3)
print(a)
# 创建一个由随机数组成的数组
b = np.random.randn(3, 2)
print(b)
3. 数组的形状和尺寸
numpy数组的形状和尺寸是数组的重要属性。您可以使用以下属性来访问它们：
属性1：shape
数组的形状可以通过shape属性获得。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape) # 输出 (2, 3)
属性2：ndim
数组的维度可以通过ndim属性获得。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.ndim) # 输出 2
属性3：size
数组的元素总数可以通过size属性获得。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.size) # 输出 6
方法1：使用reshape()函数
可以使用reshape()函数来改变数组的形状。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
b = a.reshape((2, 3))
print(b)
# 输出
# [[1 2 3]
# [4 5 6]]
方法2：使用resize()函数
可以使用resize()函数来改变数组的尺寸。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
a.resize((2, 3))
print(a)
# 输出
# [[1 2 3]
# [4 5 6]]
4. 数组操作
numpy数组支持许多操作，例如添加元素、删除元素、连接数组等等。以下是一些常见的数组操作：
方法1：使用concatenate()函数
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
c = np.concatenate((a, b), axis=0)
print(c)
# 输出
# [[1 2]
# [3 4]
# [5 6]]
方法2：使用stack()函数
可以使用stack()函数将数组沿着新的轴连接在一起。例如：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.stack((a, b))
print(c)
# 输出
# [[1 2 3]
# [4 5 6]]
方法3：使用split()函数
可以使用split()函数将数组分成多个子数组。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
b, c = np.split(a, 2)
print(b)
# 输出 [1 2 3]
print(c)
# 输出 [4 5 6]
方法4：使用delete()函数
可以使用delete()函数删除数组中的元素。例如：
import numpy as np
a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.delete(a, 1, axis=0)
print(b)
# 输出
# [[1 2]
# [5 6]]
方法5：使用insert()函数
可以使用insert()函数在数组中插入元素。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.insert(a, 2, [6, 7])
print(b)
# 输出 [1 2 6 7 3 4 5]
5. 数组运算
numpy数组支持许多运算，例如加、减、乘、除、求余等等。以下是一些常见的数组运算：
运算1：加法
可以使用加法运算符（+）将两个数组相加。例如：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b
print(c)
# 输出 [5 7 9]
运算2：减法
可以使用减法运算符（-）将两个数组相减。例如：
import numpy as np
a = np.array([4, 5, 6])
b = np.array([1, 2, 3])
c = a - b
print(c)
# 输出 [3 3 3]
运算3：乘法
可以使用乘法运算符（*）将两个数组相乘。例如：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a * b
print(c)
# 输出 [4 10 18]
运算4：除法
可以使用除法运算符（/）将两个数组相除。例如：
import numpy as np
a = np.array([4, 5, 6])
b = np.array([2, 2, 2])
c = a / b
print(c)
# 输出 [2. 2.5 3. ]
运算5：求余
可以使用求余运算符（%）将两个数组求余。例如：
import numpy as np
a = np.array([5, 6, 7])
b = np.array([2, 3, 4])
c = a % b
print(c)
# 输出 [1 0 3]
运算6：幂运算
可以使用幂运算符（**）将数组进行幂运算。例如：
import numpy as np
a = np.array([2, 3, 4])
b = np.array([2, 2, 2])
c = a ** b
print(c)
# 输出 [ 4 9 16]
运算7：矩阵乘法
可以使用dot()函数进行矩阵乘法运算。例如：
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
c = np.dot(a, b)
print(c)
# 输出
# [[19 22]
# [43 50]]
运算8：逐元素比较
可以使用比较运算符（<, <=, ==, !=, >, >=）对数组进行逐元素比较。例如：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([2, 2, 2])
c = a < b
print(c)
# 输出 [ True False False]
运算9：逐元素逻辑运算
可以使用逻辑运算符（&, |, ^, ~）对数组进行逐元素逻辑运算。例如：
import numpy as np
a = np.array([True, True, False])
b = np.array([False, True, False])
c = a & b
print(c)
# 输出 [False True False]
6. 广播（Broadcasting）
广播是一种强大的机制，它允许numpy在执行算术运算时使用不同形状的数组。通常，我们会有一个小数组和一个大数组，我们希望多次使用小数组来执行一些操作。例如，假设我们要将一个常数添加到一个数组中：
import numpy as np
a = np.array([1, 2, 3])
b = 2
c = a + b
print(c)
# 输出 [3 4 5]
在这个例子中，常数2被扩展为具有相同形状的数组[2, 2, 2]，然后与数组a相加。这个扩展过程称为广播。
可以在numpy官方文档中查找更多关于广播的信息。
广播的规则如下：
- 如果两个数组的维度不同，则在维度较小的数组前面加上1，直到两个数组的形状都相同。
- 如果两个数组在某个维度上的大小不同，可以在大小为1的维度上进行广播，直到两个数组在所有维度上的大小都相同。也就是说，对于大小不同的数组，可以将较小的数组广播为较大数组的大小。
看一个例子：
import numpy as np
a = np.array([[0, 0, 0], [10, 10, 10], [20, 20, 20], [30, 30, 30]])
b = np.array([0, 1, 2])
c = a + b
print(c)
# 输出
# [[ 0 1 2]
# [10 11 12]
# [20 21 22]
# [30 31 32]]
在这个例子中，数组a的形状是(4, 3)，数组b的形状是(3,)。按照广播规则，数组b被扩展为(1, 3)，然后在第一个维度上重复4次，得到的数组的形状为(4, 3)。然后，数组a和扩展后的数组b进行逐元素相加。
再看一个例子：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([[4], [5], [6]])
c = a + b
print(c)
# 输出
# [[5 6 7]
# [6 7 8]
# [7 8 9]]
在这个例子中，数组a的形状是(3,)，数组b的形状是(3, 1)。按照广播规则，数组a被扩展为(3, 3)，然后在第二个维度上重复3次，得到的数组的形状为(3, 3)。然后，扩展后的数组a和数组b进行逐元素相加。
需要注意的是，如果两个数组无法进行广播，则会引发ValueError异常。例如：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([1, 2])
c = a + b # 会引发ValueError异常
7. 数组的索引和切片
在numpy中，可以使用索引和切片来访问和操作数组的元素。索引和切片的语法和Python列表类似，但有一些特殊的规则。
索引
可以使用索引访问数组中的元素。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a[0]) # 输出 1
print(a[2]) # 输出 3
可以使用负数索引从数组末尾开始访问元素。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a[-1]) # 输出 5
print(a[-3]) # 输出 3
对于多维数组，可以使用逗号分隔的索引元组访问元素。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a[0, 0]) # 输出 1
print(a[1, 1]) # 输出 5
print(a[2, 2]) # 输出 9
也可以使用负数索引访问多维数组的元素。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a[-1, -1]) # 输出 9
print(a[-2, -2]) # 输出 5
切片
可以使用切片访问数组的子数组。切片的语法为start:stop:step，其中start是起始索引（包括），stop是结束索引（不包括），step是步长。如果省略start，则默认为0；如果省略stop，则默认为数组的长度；如果省略step，则默认为1。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a[1:4]) # 输出 [2 3 4]
print(a[:3]) # 输出 [1 2 3]
print(a[2:]) # 输出 [3 4 5]
print(a[::2]) # 输出 [1 3 5]
对于多维数组，可以对每个维度分别使用切片。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a[:2, :2])
# 输出
# [[1 2]
# [4 5]]
在这个例子中，使用a[:2, :2]获取数组a的前两行和前两列，得到一个2x2的子数组。
需要注意的是，切片返回的是原始数组的一个视图，而不是一个副本。也就是说，如果修改子数组中的元素，原始数组也会被修改。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = a[1:4]
b[0] = 0
print(a)
# 输出 [1 0 3 4 5]
在这个例子中，使用a[1:4]获取数组a的第2到第4个元素，返回一个包含这些元素的新数组b。然后，将b的第一个元素修改为0，原始数组a也被修改了。
如果需要获取一个切片的副本，可以使用copy()方法。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = a[1:4].copy()
b[0] = 0
print(a)
# 输出 [1 2 3 4 5]
在这个例子中，使用a[1:4].copy()获取一个包含数组a的第2到第4个元素的副本b，然后修改b的第一个元素为0，原始数组a不会被修改。
迭代
可以使用for循环迭代数组中的元素。对于一维数组，迭代的是数组中的每个元素。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
for x in a:
print(x)
输出：
1
2
3
4
5
对于多维数组，迭代的是数组的第一个维度，也就是行。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
for row in a:
print(row)
输出：
[1 2 3]
[4 5 6]
[7 8 9]
如果需要迭代数组中的每个元素，可以使用flat属性。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
for x in a.flat:
print(x)
输出：
1
2
3
4
5
6
7
8
9
数组操作
Numpy提供了许多用于操作数组的函数和方法，包括转置、重塑、连接、拆分、排序等。以下是一些常用的数组操作。
转置
可以使用transpose()函数或T属性对数组进行转置。例如：
python
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.transpose(a))
# 输出
# [[1 4 7]
# [2 5 8]
# [3 6 9]]
print(a.T)
# 输出
# [[1 4 7]
# [2 5 8]
# [3 6 9]]
在这个例子中，使用np.transpose(a)将数组a进行转置，得到一个3x3的新数组。也可以使用a.T实现同样的效果。
对于一维数组，转置没有任何效果。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(np.transpose(a)) # 输出 [1 2 3 4 5]
print(a.T) # 输出 [1 2 3 4 5]
重塑
可以使用reshape()函数对数组进行重塑。例如：
import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a.reshape(5, 1))
# 输出
# [[1]
# [2]
# [3]
# [4]
# [5]]
print(a.reshape(1, 5))
# 输出 [[1 2 3 4 5]]
在这个例子中，使用a.reshape(5, 1)将一维数组a重塑为5行1列的二维数组，使用a.reshape(1, 5)将一维数组a重塑为1行5列的二维数组。
需要注意的是，重塑操作会创建一个新的数组，而不会修改原始数组。如果新数组的元素个数和原始数组不一致，会抛出ValueError异常。
连接
可以使用concatenate()函数、vstack()函数、hstack()函数和stack()函数对数组进行连接。其中，concatenate()函数可以用于连接任意形状的数组，而vstack()函数和hstack()函数只能用于连接具有相同行数和列数的数组。stack()函数可以在新的维度上连接数组。例如：
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(np.concatenate((a, b)))
# 输出
# [[1 2]
# [3 4]
# [5 6]
# [7 8]]
print(np.vstack((a, b)))
# 输出
# [[1 2]
# [3 4]
# [5 6]
# [7 8]]
print(np.hstack((a, b)))
# 输出
# [[1 2 5 6]
# [3 4 7 8]]
print(np.stack((a, b)))
# 输出
# [[[1 2]
# [3 4]]
# [[5 6]
# [7 8]]]
在这个例子中，使用np.concatenate((a, b))将数组a和数组b连接成一个新数组。使用np.vstack((a, b))将数组a和数组b垂直连接成一个新数组。使用np.hstack((a, b))将数组a和数组b水平连接成一个新数组。使用np.stack((a, b))将数组a和数组b沿着一个新的维度连接成一个新数组。
拆分
可以使用split()函数、vsplit()函数和hsplit()函数对数组进行拆分。其中，split()函数可以用于拆分任意形状的数组，而vsplit()函数和hsplit()函数只能用于拆分具有相同行数和列数的数组。例如：
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) b, c = np.split(a, [2], axis=0)
print(b)
# 输出
# [[1 2 3]
# [4 5 6]]
print(c)
# 输出
# [[7 8 9]]
d, e, f = np.hsplit(a, 3)
print(d)
# 输出
# [[1]
# [4]
# [7]]
print(e)
# 输出
# [[2]
# [5]
# [8]]
print(f)
# 输出
# [[3]
# [6]
# [9]]
在这个例子中，使用np.split(a, [2], axis=0)将数组a垂直拆分为两个数组b和c。第二个参数[2]表示在第2行拆分，axis=0表示按行拆分。
使用np.hsplit(a, 3)将数组a水平拆分为三个数组d、e和f。axis=1表示按列拆分。需要注意的是，拆分操作会创建新的数组，而不会修改原始数组。
数组排序
可以使用sort()函数对数组进行排序。默认情况下，sort()函数会按照最后一维排序，也可以指定axis参数来按照指定的维度排序。例如：
import numpy as np
a = np.array([[3, 1], [2, 4]])
a.sort(axis=1)
print(a)
# 输出
# [[1 3]
# [2 4]]
在这个例子中，使用a.sort(axis=1)对数组a按照第二个维度排序，也就是按照行排序。需要注意的是，sort()函数会修改原始数组。
小结
本文介绍了NumPy库的基本操作，包括创建数组、数组属性、数学运算、逻辑运算、数组索引、数组切片、数组重塑、数组连接、数组拆分和数组排序。NumPy是Python数据科学领域中最为重要的库之一，它提供了高效的数组操作和数学运算功能，是数据分析、科学计算和机器学习等领域的重要工具。
在使用NumPy进行数学运算时，需要注意数组的形状，不同形状的数组在运算时需要进行广播操作。数组的索引和切片操作与Python的列表操作类似，但具有更高的效率和灵活性。数组的连接和拆分操作可以将多个数组组合成一个数组或将一个数组拆分成多个数组。数组的排序操作可以按照指定的维度对数组进行排序。
除了本文介绍的功能之外，NumPy还提供了很多其他的功能，例如矩阵运算、线性代数运算、随机数生成、傅里叶变换等。学习NumPy需要不断实践和探索，可以查看官方文档和参考书籍进行深入学习。
希望本文能够对读者了解和学习NumPy提供一些帮助。
作者：爱吃鱼的猫
第二个参数[2]表示在第2行拆分，axis=0表示按行拆分。
使用np.hsplit(a, 3)将数组a水平拆分为三个数组d、e和f。axis=1表示按列拆分。需要注意的是，拆分操作会创建新的数组，而不会修改原始数组。
数组排序
可以使用sort()函数对数组进行排序。默认情况下，sort()函数会按照最后一维排序，也可以指定axis参数来按照指定的维度排序。例如：
import numpy as np
a = np.array([[3, 1], [2, 4]])
a.sort(axis=1)
print(a)
# 输出
# [[1 3]
# [2 4]]
在这个例子中，使用a.sort(axis=1)对数组a按照第二个维度排序，也就是按照行排序。需要注意的是，sort()函数会修改原始数组。
小结
本文介绍了NumPy库的基本操作，包括创建数组、数组属性、数学运算、逻辑运算、数组索引、数组切片、数组重塑、数组连接、数组拆分和数组排序。NumPy是Python数据科学领域中最为重要的库之一，它提供了高效的数组操作和数学运算功能，是数据分析、科学计算和机器学习等领域的重要工具。
在使用NumPy进行数学运算时，需要注意数组的形状，不同形状的数组在运算时需要进行广播操作。数组的索引和切片操作与Python的列表操作类似，但具有更高的效率和灵活性。数组的连接和拆分操作可以将多个数组组合成一个数组或将一个数组拆分成多个数组。数组的排序操作可以按照指定的维度对数组进行排序。
除了本文介绍的功能之外，NumPy还提供了很多其他的功能，例如矩阵运算、线性代数运算、随机数生成、傅里叶变换等。学习NumPy需要不断实践和探索，可以查看官方文档和参考书籍进行深入学习。
希望本文能够对读者了解和学习NumPy提供一些帮助。
作者：爱吃鱼的猫
csdn博客：爱吃熊掌的鱼的博客_CSDN博客