Numpy（Numerical Python）是一个开源的Python科学计算库，用于快速处理任意维度的数组。 Numpy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。 Numpy使用ndarray对象来处理多维数组，该对象是一个快速而灵活的大数据容器。

NumPy提供了一个N维数组类型ndarray，它描述了相同类型的“items”的集合。

使用Python列表可以存储一维数组，通过列表的嵌套可以实现多维数组，那么为什么还需要使用Numpy的ndarray呢？

import random
import time
import numpy as np
a = []
for i in range(10000000):
    a.append(random.random())
# 通过%time魔法方法, 查看当前行的代码运行一次所花费的时间
%time sum1=sum(a)
b=np.array(a)
%time sum2=np.sum(b)

CPU times（CPU 耗时）：程序真正占用 CPU 运算的时间。

Wall time（墙上时间 / 实际耗时）：从代码开始执行到结束的真实时长（挂钟时间），包含：
CPU 计算 + IO 等待、休眠、网络、绘图渲染、系统调度、等待资源等。

从结果看到ndarray的计算速度要快很多，节约了时间。 机器学习的最大特点就是大量的数据运算，那么如果没有一个快速的解决方案，那可能现在python也在机器学习领域达不到好的效果。

ndarray到底跟原生python列表有什么不同呢，请看一张图：

从图中我们可以看出ndarray在存储数据的时候，数据与数据的地址都是连续的，这样就给使得批量操作数组元素时速度更快。

这是因为ndarray中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以ndarray在存储元素时内存可以连续，而python 原生list就只能通过寻址方式找到下一个元素，这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list，但在科学计算中，Numpy 的ndarray就可以省掉很多循环语句，代码使用方面比Python原生list简单的多。

1.numpy内置了并行运算功能，当系统有多个核心时，做某种计算时，numpy会自动做并行计算

Numpy底层使用C语言编写，内部解除了GIL（全局解释器锁），其对数组的操作速度不受Python解释器的限制，所以，其效率远高于纯 Python代码。

1.NumPy 创建数组

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

 数组属性

属性名字 属性解释 
ndarray.shape 数组维度的元组 
ndarray.ndim 数组维数 
ndarray.size 数组中的元素数量 
ndarray.itemsize 一个数组元素的长度（字节） 
ndarray.dtype 数组元素的类型

反映了数组本身固有的信息

import numpy as np 
a = np.array([1,2,3])  
print(a.shape)

b = np.array([[1,  2],  [3,  4]])  
print(b.shape)

c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])  
print(c.shape)


print(a.ndim)
print(a.size)
print(a.dtype)

输出

(3,)
(2, 2)
(2, 2, 3)
1
3
int64

(4,) # 一维数组

(2, 3) # 二维数组

(2, 2, 3) # 三维数组

2.NumPy 数据类型

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

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

b = np.array(['python', 'tensorflow', 'scikit-learn', 'numpy'], dtype = np.bytes_)
print(b.dtype)

dtype写法总结，如需要指定类型为int32，下面几种写法全部等效

dtype='int32'、dtype='i4'、dtype=np.int32、dtype=('int', 4)、dtype=7（NumPy 内部类型编号，int32 代码是 7）

输出

[[1. 2. 3.]
 [4. 5. 6.]]
float32
|S12

3 基本操作

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

numpy.empty

方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

numpy.empty(shape, dtype = float)

numpy.zeros

创建指定大小的数组，数组元素以 0 来填充：

numpy.zeros(shape, dtype = None)

numpy.ones

创建指定形状的数组，数组元素以 1 来填充：

numpy.ones(shape, dtype = None)

numpy.zeros/ones _like

用于创建一个与给定数组具有相同形状的数组，数组元素以 0/1 来填充。

numpy.zeros_like(a, dtype=None)

import numpy as np 
a = np.empty([3,2], dtype = int) 
print (a)
b = np.zeros((5,), dtype = int) 
print(b)
c = np.ones((5,), dtype = int) 
print(c)
d = np.ones_like(a)
print(d)

输出：

[[28429264711581742 28429397856419958]
 [32088563961561180 32370073299845220]
 [30399774231756907 14637132587794549]]
[0 0 0 0 0]
[1 1 1 1 1]
[[1 1]
 [1 1]
 [1 1]]

关于 array 和 asarray 的不同

np.array() 无论传入列表还是已有 NumPy 数组，默认都会创建数据副本，新旧数组相互独立；而 np.asarray() 仅在传入列表等普通序列时新建数组，若传入已有 ndarray 且数据类型一致，则直接共享内存、不做拷贝，修改其中一个数组会同步影响另一个。

import numpy as np

# 原数组
arr_ori = np.array([1, 2, 3])

# 使用 array：生成新副本，互不影响
arr1 = np.array(arr_ori)
arr1[0] = 99
print("array 结果：", arr_ori)  # 输出 [1 2 3]，原数组不变

# 使用 asarray：共享内存，同步变化
arr2 = np.asarray(arr_ori)
arr2[0] = 88
print("asarray 结果：", arr_ori)  # 输出 [88 2 3]，原数组被修改

linspace / arange / logspace 用法

三个函数都用来生成等间隔数值序列，区别在于间隔规则：

1. np.arange()

按步长生成等差数列（类似 Python range）

np.arange(start, stop, step=1, dtype=None)

• 左闭右开：[start, stop)，取不到 stop
• 控制：起始值、终止值、步长

示例

import numpy as np

# 0~9，步长1
print(np.arange(10))
# 2~10，步长2
print(np.arange(2, 11, 2))
# 支持小数步长
print(np.arange(0, 1, 0.2))

输出：

[0 1 2 3 4 5 6 7 8 9]
[ 2  4  6  8 10]
[0.  0.2 0.4 0.6 0.8]

2. np.linspace()

按元素个数生成均匀等差数列

np.linspace(start, stop, num=50, endpoint=True, dtype=None)

• 默认包含 stop（闭区间 [start, stop]）
• 控制：起始值、终止值、元素总个数，自动计算均匀步长

示例

# 0~10 一共 6 个均匀数
print(np.linspace(0, 10, 6))
# endpoint=False：不包含终止值
print(np.linspace(0, 10, 5, endpoint=False))

输出：

[ 0.  2.  4.  6.  8. 10.]
[0. 2. 4. 6. 8.]

3. np.logspace()

对数尺度生成等比数列

np.logspace(start, stop, num=50, base=10.0, endpoint=True)

• 先在对数域做等分，再取指数，生成等比数列
• start/stop 是指数，base 为底数（默认 10）

示例

# 10^1 ~ 10^3，共5个等比数
print(np.logspace(1, 3, 5))
# 底数改为2：2^0 ~ 2^4
print(np.logspace(0, 4, 5, base=2))

输出：

[  10.           31.6227766   100.          316.22776602 1000.        ]
[ 1.  2.  4.  8. 16.]

4 生成随机数组

正态分布

是一种概率分布。正态分布是具有两个参数μ（\mu）和 σ （\sigma ）的连续型随机变量的分布，第一参数 μ 是服从正态分布的随机变量的均值，第二个参 数σ是此随机变量的标准差，所以正态分布记作N(μ，σ )。

正态分布（高斯分布）公式：

：均值，决定发布中心

：标准差，决定发布宽窄，越大数据越分散，一般数据都集中在 到   范围内。

生活、生产与科学实验中很多随机变量的概率分布都可以近似地用正态分布来描述。

方差

是在概率论和统计方差衡量一组数据时离散程度的度量。

等价于：

其中M/为平均值，n为数据总个数，σ 为标准差， 可以理解一个整体为方差，标准差等于方差开根号。

正态分布创建方式通用，推荐

np.random.normal(loc=0.0, scale=1.0, size=None)

• loc：均值 μ（分布中心）
• scale：标准差 σ（离散程度）
• size：生成数据数量 / 数组形状

import numpy as np
import matplotlib.pyplot as plt
 
x1 = np.random.normal(1.75, 1, 100000)
 
# 画图看分布状况
# 1）创建画布
plt.figure(figsize=(20, 10), dpi=100)
# 2）绘制直方图
plt.hist(x1, 1000)
# 3）显示图像
plt.show()

均匀分布

整数

从一个均匀分布中随机采样，生成一个整数或N维整数数组， 取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。

np.random.randint(low, high=None, size=None, dtype='l') 

小数

从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.

np.random.uniform(low=0.0, high=1.0, size=None)

参数介绍:

low: 采样下界，float类型，默认值为0；

high: 采样上界，float类型，默认值为1；

size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出m*n*k个样本，缺省时输出1个值。 返回值：ndarray类型，其形状和参数size中描述一致。

import matplotlib.pyplot as plt
# 生成均匀分布的随机数
x2 = np.random.uniform(-1, 1, 100000)
# 画图看分布状况
# 1）创建画布
plt.figure(figsize=(10, 10), dpi=100)
# 3）显示图像
plt.show()
# 2）绘制直方图
plt.hist(x=x2, bins=1000)  # x代表要使用的数据，bins表示要划分区间数

5.数组的索引、切片

分一维数组、多维数组，搭配基础用法、花式索引、布尔索引，附示例。

前置准备

import numpy as np
# 一维数组
a = np.array([10, 20, 30, 40, 50, 60])
# 二维数组（常用）
b = np.array([[1,2,3],
              [4,5,6],
              [7,8,9]])

一维数组

1 基础索引（取单个元素）

和 Python 列表一致，从 0 开始，支持负索引。

print(a[0])    # 第一个元素：10
print(a[2])    # 第三个元素：30
print(a[-1])   # 倒数第一个：60
print(a[-2])   # 倒数第二个：50

2 切片 [start:end:step]

规则：左闭右开，默认 start=0, end=末尾, step=1

a = [10,20,30,40,50,60]
print(a[1:4])     # 索引1~3：[20 30 40]
print(a[:3])      # 前3个：[10 20 30]
print(a[3:])      # 从索引3到末尾：[40 50 60]
print(a[::2])     # 步长2，全取：[10 30 50]
print(a[::-1])    # 逆序：[60 50 40 30 20 10]

二维数组（重点）

格式：数组[行索引, 列索引]，逗号分隔行、列

1 取单行 / 单列

# 取第 1 行（索引1）
print(b[1])       # [4 5 6]

# 取第 0 列 所有行
print(b[:, 0])    # [1 4 7]

2 取单个元素

print(b[0, 1])    # 第0行第1列：2
print(b[2, -1])   # 第2行最后一列：9

3 行列切片

# 行切片：前2行，所有列
print(b[:2, :])
# 列切片：所有行，后2列
print(b[:, 1:])
# 子区域：第1、2行，第0、1列
print(b[1:, :2])

4 步长切片

# 所有行，列步长2
print(b[:, ::2])

输出：

[[1 3]
 [4 6]
 [7 9]]

花式索引（整数数组索引）

按指定索引列表取值，不遵循连续切片规则。

一维花式索引

a = np.array([10,20,30,40,50])
idx = [0, 2, 4]
print(a[idx])   # [10 30 50]

二维花式索引

# 取第0行、第2行
print(b[[0,2]])
# 按坐标取值：(0,0)、(1,2)
print(b[[0,1], [0,2]])  # [1 6]

 注意：NumPy 切片是「视图」，不是副本修改切片会影响原数组：

arr = np.array([1,2,3,4])
slice_arr = arr[1:3]
slice_arr[0] = 99
print(arr)  # [ 1 99  3  4] 原数组被修改

如需独立副本，用 .copy()：6.

slice_arr = arr[1:3].copy()

布尔索引（筛选数据，高频用法）

用布尔数组当掩码，保留 True 对应元素。

a = np.array([1,2,3,4,5,6])
# 条件：大于3
mask = a > 3
print(mask)          # [False False False  True  True  True]
print(a[mask])       # [4 5 6]

# 简写一行
print(a[a % 2 == 0]) # 取偶数：[2 4 6]

二维数组布尔筛选：

print(b[b > 4])  # 取出所有大于4的元素：[5 6 7 8 9]

数组布尔筛选后赋值

b[b > 4] = 12

通用判断函数

np.all()

判断前两名同学的成绩[0:2, :]是否全及格

np.all(score[0:2, :] > 60) 

np.any()

判断前两名同学的成绩[0:2, :]是否有大于90分的

np.any(score[0:2, :] > 80) 

np.where（三元运算符）

通过使用np.where能够进行更加复杂的运算

判断前四名学生,前四门课程中，成绩中大于60的置为1，否则为0

temp = score[:4, :4]
np.where(temp > 60, 1, 0)

复合逻辑需要结合np.logical_and和np.logical_or使用

判断前四名学生,前四门课程中，成绩中大于60且小于90的换为1，否则为0

np.where(np.logical_and(temp > 60, temp < 90), 1, 0)

判断前四名学生,前四门课程中，成绩中大于90或小于60的换为1，否则为0

np.where(np.logical_or(temp > 90, temp < 60), 1, 0)

统计运算

在数据挖掘/机器学习领域，统计指标的值也是我们分析问题的一种方式。常用的指标如下：

最小值 min(a, axis) Return the minimum of an array or minimum along an axis.

最大值 max(a, axis]) Return the maximum of an array or maximum along an axis.

中位数 median(a, axis) Compute the median along the specified axis.

平均数 mean(a, axis, dtype) Compute the arithmetic mean along the specified axis.

标准差 std(a, axis, dtype) Compute the standard deviation along the specified axis.

方差 var(a, axis, dtype) Compute the variance along the specified axis.

进行统计的时候，axis 轴的取值并不一定，Numpy中不同的API轴的值都不一样，在这里，axis 0代表列, axis 1代表行去进行统计

temp = score[:4, 0:5]
print("前四名学生,各科成绩的最大分：{}".format(np.max(temp, axis=0)))
print("前四名学生,各科成绩的最小分：{}".format(np.min(temp, axis=0)))
print("前四名学生,各科成绩波动情况：{}".format(np.std(temp, axis=0)))
print("前四名学生,各科成绩的平均分：{}".format(np.mean(temp, axis=0)))

如果需要统计出某科最高分对应的是哪个同学？

np.argmax(temp, axis=)

np.argmin(temp, axis=)

print("前四名学生，各科成绩最高分对应的学生下标：{}".format(np.argmax(temp, axis=0)))

6.形状类型修改

前置准备

import numpy as np
arr = np.arange(12)  # [ 0  1  2  3  4  5  6  7  8  9 10 11]

arr.reshape(shape) 重塑形状不改变原数据，返回新视图（共享内存），元素总数必须和原数组一致，支持 -1 自动计算维度。

# 转为 3行4列
a1 = arr.reshape(3, 4)
print(a1)

# 一维转三维，-1 自动推导维度
a2 = arr.reshape(2, -1, 2)
print(a2.shape)  # (2, 3, 2)

转置 行↔列

transpose () / 属性 T，用于二维 / 多维数组转置，返回视图

c = np.arange(6).reshape(2,3)
print(c)
print(c.T)         # 简写转置
print(c.transpose()) # 完整写法

输出

[[0 1 2]
 [3 4 5]]
[[0 3]
 [1 4]
 [2 5]]
[[0 3]
 [1 4]
 [2 5]]

resize 原地修改形状

原地修改原数组，无返回值，元素总数不足：补 0；超出：截断元素

arr.resize(4,4)
print(arr)  # 不足部分补 0

ndarray.astype(type):返回修改了类型之后的数组

import numpy as np 
a = np.zeros([3,2], dtype = int) 
print(a.dtype)
b=a.astype(np.int32)
print(a.dtype)
print(b.dtype)

数组的去重

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

7.数组间运算

1.数组与数的运算 + -* /

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

2 数组与数组的运算

形状不同的数组不能进行加减运算！

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

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

NumPy 广播（Broadcast）机制

数组在进行矢量化运算时（同时对其数组内每个元素进行+-*/运算），要求数组的形状是相等的。当形状不相等的数组执行算术运算的时候，就会出现广播机制，该机制会对数组进行扩展，使数组的shape属性值一样，这样，就可以进行矢量化运算了。下面通过一个例子进行说明：

arr1 = np.array([[0],[1],[2],[3]])
arr1.shape
# (4, 1)
arr2 = np.array([1,2,3])
arr2.shape
# (3,)
arr1+arr2
# 结果是：
#array([[1, 2, 3],
#[2, 3, 4],
#[3, 4, 5],
#[4, 5, 6]])

上述代码中，数组arr1是4行1列，arr2是1行3列。这两个数组要进行相加，按照广播机制会对数组arr1和arr2都进行扩展，使得数组arr1和arr2 都变成4行3列。

下面通过一张图来描述广播机制扩展数组的过程：

广播是 NumPy 让不同形状数组之间能直接做逐元素运算的规则，无需手动复制扩展数组，节省内存、写法简洁。

1. 一维数组 + 一维数组

• (3,) + (3,) ✅ 正常运算
• (3,) + (1,) ✅ 广播
• (3,) + (2,) ❌ 不兼容

2. 二维 + 一维（经典场景）

# 二维 (2,3) + 一维 (3,)
a = np.array([[1,2,3],[4,5,6]])  # shape (2, 3)
b = np.array([10,20,30])         # shape (3,)
# 补齐：b → (1, 3)，从尾对齐：3==3、2和1兼容
print(a + b)

结果：

[[11 22 33]
 [14 25 36]]

3. 二维之间广播

a = np.ones((2, 1))  # (2, 1)
b = np.ones((1, 3))  # (1, 3)
# 尾维度：1与3兼容、2与1兼容 → 广播为 (2,3)
print(a + b)

判断步骤（通用流程）

案例：以 shape1 = (4,1,5)、shape2 = (1,2,5) 举例：

1. 从最后一维开始比对：5 == 5 ✅
2. 倒数第二维：1 和 2 ✅（有一个为 1）
3. 第一维：4 和 1 ✅（有一个为 1） → 最终广播后形状：(4, 2, 5)

矩阵和向量

矩阵，英文matrix，和array的区别矩阵必须是2维的，但是array可以是多维的。如图:这个是 3×2 矩阵，即 3 行 2 列，如 m 为行，n 为列，那么 m×n 即 3×2

A表示矩阵，矩阵的个数即行数×列数。

矩阵元素(矩阵项): Aij 指第 i 行，第 j 列的元素。

向量是一种特殊的矩阵，讲义中的向量一般都是列向量，下面展示的就是三维列 向量(3×1)。

矩阵的加法

行列数相等（shape相同）的可以加。例:

矩阵的乘法:每个元素都要乘。

矩阵向量乘法

矩阵和向量的乘法如图：m×n 的矩阵乘以 n×1 的向量，得到的是 m×1 的向量

1*1+3*5 = 16
4*1+0*5 = 4
2*1+1*5 = 7

矩阵乘法遵循准则： (M行, N列)*(N行, L列) = (M行, L列)

a = np.array([[80, 86],[82, 80],[85, 78],[90, 90],[86, 82],[82, 90],[78, 80],[92, 94]])
b = np.array([[0.7], [0.3]])
print(np.matmul(a, b))

输出：

[[81.8]
 [81.4]
 [82.9]
 [90. ]
 [84.8]
 [84.4]
 [78.6]
 [92.6]]

 矩阵乘法

矩阵乘法：
m×n 矩阵乘以 n×o 矩阵，变成 m×o 矩阵。
举例：比如说现在有两个矩阵 A 和 B，那么它们的乘积就可以表示为图中所示的形式。

练一练

求矩阵AB的结果

答案：

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

矩阵乘法的性质

单位矩阵是主对角线元素全为 1，其余元素全为 0 的方阵，记作 E（也常用 I）。

矩阵的乘法不满足交换律：A×B≠B×A

矩阵的乘法满足结合律。即：A×（B×C）=（A×B）×C

n 阶单位矩阵：行数、列数均为 n。

矩阵的转置

矩阵转置 A^T（也写作 A′）

• 原矩阵：Am×n​（m 行 n 列）
• 转置后：An×mT​（n 行 m 列）

import numpy as np
A = np.array([[1,2,3],[4,5,6]])
AT = A.T    # 转置
print(AT)

逆矩阵 A^−1

只有方阵才可能有逆矩阵。

设 A 是 n 阶方阵，若存在同阶方阵 B 满足： AB=BA=E 则称 A 可逆，B 是 A 的逆矩阵，记作 A^−1。

举例

import numpy as np
A = np.array([[2,3],[4,5]], dtype=float)
A_inv = np.linalg.inv(A)  # 求逆
print(A_inv)

合并余分割

一、数组合并（拼接）

1. 垂直合并（上下拼接，axis=0）

np.vstack() / np.concatenate(axis=0)

import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])

# 方式1 vstack 垂直堆叠
res1 = np.vstack([a, b])
# 方式2 concatenate 指定轴0
res2 = np.concatenate([a, b], axis=0)
print(res1)
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]

要求：列数必须相同

2. 水平合并（左右拼接，axis=1）

np.hstack() / np.concatenate(axis=1)

res3 = np.hstack([a, b])
res4 = np.concatenate([a, b], axis=1)
print(res3)
# [[1 2 5 6]
#  [3 4 7 8]]

要求：行数必须相同

二、数组分割

1. 垂直分割（按行切，axis=0）np.vsplit

arr = np.array([[1,2],[3,4],[5,6],[7,8]])
# 均等切成2份
p1, p2 = np.vsplit(arr, 2)
# 按索引分割：在第2行切开
p1, p2 = np.vsplit(arr, [2])

2. 水平分割（按列切，axis=1）np.hsplit

arr = np.array([[1,2,3,4],[5,6,7,8]])
# 均等切2份
p1, p2 = np.hsplit(arr, 2)
# 在第2列分割
p1, p2 = np.hsplit(arr, [2])

3. 通用分割 np.split（指定 axis）

# 按行分割等价 vsplit
p1,p2 = np.split(arr, 2, axis=0)
# 按列分割等价 hsplit
p1,p2 = np.split(arr, 2, axis=1)