目录
- 一、为什么要用 Numpy 库
- 1. 低效的Python for循环
- 2. Numpy为什么如此高效
- 3. 什么时候用Numpy
- 二、Numpy 数组的创建
- 1. 从列表开始创建
- 2. 从头创建数组
- 三、Numpy 数组的性质
- 1. 数组的属性
- 2. 数组索引
- 3. 数组的切片
- 4. 数组的变形
- 5 数组的拼接
- 6. 数组的分裂
- 四、Numpy 四大运算
- 1. 向量化运算
- 2. 矩阵运算
- 3. 广播运算
- 4. 比较运算和掩码
- 5. 花哨的索引
- 五、其他 Numpy 通用函数
- 1. 数值排序
- 2. 最大最小值
- 3. 数值求和、求积
- 4. 中位数、均值、方差、标准差
- 五、总结
任务简介：
尽管可以实现，但是不得不说，Python原生的数据处理方式，处理大规模数据集时，在效率上遇到了瓶颈。支持向量化操作，支持矩阵操作、支持广播机制、拥有庞大的通用函数，灵活的索引和掩码操作，让Numpy库成为当仁不让的数据科学“网红”。
任务说明：
1、了解numpy数组的优点，掌握numpy数组的创建方法。
2、掌握numpy数组的基本性质。
3、掌握numpy的向量化操作。
4、掌握numpy的矩阵操作。
5、掌握numpy的广播操作。
6、掌握常见numpy通用函数。
7、掌握numpy高效、简洁的掩码操作。
一、为什么要用 Numpy 库
1. 低效的Python for循环
【例】 求100万个数的倒数
输入：
def compute_reciprocals(values):
res = []
for value in values: # 每遍历到一个元素，就要判断其类型，并查找适用于该数据类型的正确函数
res.append(1/value)
return res
values = list(range(1, 1000000))
%timeit compute_reciprocals(values)%timeit ：ipython中统计运行时间的魔术方法（多次运行取平均值）
输出：
92.5 ms ± 1.07 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)输入：
import numpy as np
values = np.arange(1, 1000000)
%timeit 1/values输出：
2.54 ms ± 86.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)实现相同计算，Numpy的运行速度是Python循环的35倍，产生了质的飞跃
2. Numpy为什么如此高效
Numpy 是由C语言编写的
- 编译型语言VS解释型语言
C语言执行时，对代码进行整体编译，速度更快 - 连续单一类型存储VS分散多变类型存储
（1）Numpy数组内的数据类型必须是统一的，如全部是浮点型，而Python列表支持任意类型数据的填充
（2）Numpy数组内的数据连续存储在内存中，而Python列表的数据分散在内存中
这种存储结构，与一些更加高效的底层处理方式更加的契合 - 多线程VS线程锁
Python语言执行时有线程锁，无法实现真正的多线程并行，而C语言可以
3. 什么时候用Numpy
在数据处理的过程中，遇到使用“Python for循环” 实现一些向量化、矩阵化操作的时候，要优先考虑用Numpy
如： 1. 两个向量的点乘 2. 矩阵乘法
二、Numpy 数组的创建
1. 从列表开始创建
输入：
import numpy as np
x = np.array([1, 2, 3, 4, 5])
print(x)输出：
[1 2 3 4 5]输入：
print(type(x))
print(x.shape)输出：
<class 'numpy.ndarray'>
(5,)- 设置数组的数据类型
输入：
x = np.array([1, 2, 3, 4, 5], dtype="float32")
print(x)
print(type(x[0]))输出：
[1. 2. 3. 4. 5.]
<class 'numpy.float32'>- 二维数组
输入：
x = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print(x)
print(x.shape)输出：
[[1 2 3]
[4 5 6]
[7 8 9]]
(3, 3)2. 从头创建数组
（1）创建长度为5的数组，值都为0
输入：
np.zeros(5, dtype=int)输出：
array([0, 0, 0, 0, 0])（2）创建一个2*4的浮点型数组，值都为1
输入：
np.ones((2, 4), dtype=float)输出：
array([[1., 1., 1., 1.],
[1., 1., 1., 1.]])（3）创建一个3*5的数组，值都为8.8
输入：
np.full((3, 5), 8.8)输出：
array([[8.8, 8.8, 8.8, 8.8, 8.8],
[8.8, 8.8, 8.8, 8.8, 8.8],
[8.8, 8.8, 8.8, 8.8, 8.8]])（4）创建一个3*3的单位矩阵
输入：
np.eye(3)输出：
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])（5）创建一个线性序列数组，从1开始，到15结束，步长为2
输入：
np.arange(1, 15, 2)输出：
array([ 1, 3, 5, 7, 9, 11, 13])（6）创建一个4个元素的数组，这四个数均匀的分配到0~1
输入：
np.linspace(0, 1, 4)输出：
array([0. , 0.33333333, 0.66666667, 1. ])（7）创建一个10个元素的数组，形成~
的等比数列
输入：
np.logspace(0, 9, 10)输出：
array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,
1.e+08, 1.e+09])（8）创建一个3*3的，在0~1之间均匀分布的随机数构成的数组
输入：
np.random.random((3,3))输出：
array([[0.52136545, 0.92508021, 0.00813796],
[0.15389064, 0.35914984, 0.00220049],
[0.35608872, 0.66095806, 0.13485892]])（9）创建一个3*3的，均值为0，标准差为1的正态分布随机数构成的数组
输入：
np.random.normal(0, 1, (3,3))输出：
array([[-0.01652543, 0.76396753, -0.54986662],
[ 0.56948944, -0.04976978, 0.69200383],
[ 0.34867968, -0.12253876, 0.25197283]])（10）创建一个3*3的，在[0,10)之间随机整数构成的数组
输入：
np.random.randint(0, 10, (3,3))输出：
array([[8, 1, 4],
[1, 3, 4],
[3, 4, 3]])（11）随机重排列
输入：
x = np.array([10, 20, 30, 40])
np.random.permutation(x) # 生产新列表输出：
array([30, 10, 40, 20])输入：
print(x)
np.random.shuffle(x) # 修改原列表
print(x)输出：
[10 20 30 40]
[40 30 10 20]（12）随机采样
numpy.random.choice(a, size=None, replace=True, p=None)a: 如果是一维数组，就表示从这个一维数组中随机采样；如果是int型，就表示从0到a-1这个序列中随机采样。
size: :采样结果的数量，默认为1.可以是整数，表示要采样的数量；也可以为tuple，如(m, n, k)，则要采样的数量为m * n * k，size为(m, n, k)。
replace: boolean型，采样的样本是否要更换？测了一下发现replace指定为True时，采样的元素会有重复；当replace指定为False时，采样不会重复。
p : 一个一维数组，制定了a中每个元素采样的概率，若为默认的None，则a中每个元素被采样的概率相同。
- 按指定形状采样
输入：
x = np.arange(10, 25, dtype = float)
x输出：
array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
23., 24.])输入：
np.random.choice(x, size=(4, 3))输出：
array([[15., 17., 15.],
[13., 20., 19.],
[18., 19., 11.],
[23., 11., 21.]])输入：
np.random.choice(10, 10)输出：
array([1, 5, 2, 1, 5, 8, 7, 0, 0, 5])输入：
x = np.arange(5).reshape(1, 5)
x
x.sum(axis=1, keepdims=True)输出：
array([[0, 1, 2, 3, 4]])
array([[10]])- 按概率采样
输入：
np.random.choice(x, size=(4, 3), p=x/np.sum(x))输出：
array([[17., 24., 22.],
[21., 21., 22.],
[13., 16., 24.],
[13., 17., 24.]])三、Numpy 数组的性质
1. 数组的属性
输入：
x = np.random.randint(10, size=(3, 4))
x输出：
array([[8, 5, 2, 7],
[5, 7, 9, 1],
[1, 5, 8, 5]])- 数组的形状shape
输入：
x.shape输出：
(3, 4)- 数组的维度ndim
输入：
x.ndim输出：
2输入：
y = np.arange(10)
y输出：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])输入：
y.ndim输出：
1- 数组的大小size
输入：
x.size输出：
12- 数组的数据类型dtype
输入：
x.dtype输出：
dtype('int32')2. 数组索引
- 一维数组的索引
输入：
x1 = np.arange(10)
x1输出：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])输入：
x1[0]输出：
0输入：
x1[5]输出：
5输入：
x1[-1]输出：
9- 多维数组的索引——以二维为例
输入：
x2 = np.random.randint(0, 20, (2,3))
x2输出：
array([[ 3, 19, 7],
[16, 12, 1]])输入：
x2[0, 0]输出：
3以上两种写法均可
注意： numpy数组的数据类型是固定的，向一个整型数组插入一个浮点值，浮点值会向下进行取整
输入：
x2[0, 0] = 1.618
x2输出：
array([[ 1, 19, 7],
[16, 12, 1]])3. 数组的切片
- 维数组——跟列表一样
输入：
x1 = np.arange(10)
x1输出：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])输入：
x1[:3]输出：
array([0, 1, 2])输入：
x1[3:]输出：
array([3, 4, 5, 6, 7, 8, 9])输入：
x1[::-1] # 反向输出输出：
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])- 多维数组——以二维为例
输入：
x2 = np.random.randint(20, size=(3,4))
x2输出：
array([[ 6, 5, 18, 8],
[18, 13, 4, 17],
[11, 4, 16, 9]])输入：
x2[:2, :3] # 前两行，前三列输出：
array([[ 6, 5, 18],
[18, 13, 4]])输入：
x2[:2, 0:3:2] # 前两行 前三列（每隔一列）输出：
array([[ 6, 18],
[18, 4]])输入：
x2[::-1, ::-1] # 行和列均反向输出输出：
array([[ 9, 16, 4, 11],
[17, 4, 13, 18],
[ 8, 18, 5, 6]])- 获取数组的行和列
输入：
x3 = np.random.randint(20, size=(3,4))
x3输出：
array([[ 7, 13, 14, 12],
[19, 18, 15, 7],
[ 9, 5, 11, 7]])输入：
x3[1, :] #第一行 从0开始计数输出：
array([19, 18, 15, 7])输入：
x3[1] # 第一行简写输出：
array([19, 18, 15, 7])输入：
x3[:, 2] # 第二列 从0开始计数输出：
array([14, 15, 11])- 切片获取的是视图，而非副本
输入：
x4 = np.random.randint(20, size=(3,4))
x4输出：
array([[ 0, 10, 17, 2],
[12, 4, 3, 11],
[ 4, 9, 5, 7]])输入：
x5 = x4[:2, :2]
x5输出：
array([[ 0, 10],
[12, 4]])注意：视图元素发生修改，则原数组亦发生相应修改
输入：
x5[0, 0] = 0
x5输出：
array([[ 0, 10],
[12, 4]])输入：
x4输出：
array([[ 0, 10, 17, 2],
[12, 4, 3, 11],
[ 4, 9, 5, 7]])修改切片的安全方式：copy
输入：
x4 = np.random.randint(20, size=(3,4))
x4输出：
array([[ 2, 2, 2, 15],
[ 9, 3, 15, 15],
[ 9, 12, 18, 1]])输入：
x6 = x4[:2, :2].copy()
x6输出：
array([[2, 2],
[9, 3]])输入：
x6[0, 0] = 0
x6输出：
array([[0, 2],
[9, 3]])输入：
x4输出：
array([[ 2, 2, 2, 15],
[ 9, 3, 15, 15],
[ 9, 12, 18, 1]])4. 数组的变形
输入：
x5 = np.random.randint(0, 10, (12,))
x5输出：
array([8, 4, 2, 5, 9, 7, 1, 4, 6, 7, 6, 2])输入：
x5.shape输出：
(12,)输入：
x6 = x5.reshape(3, 4)
x6输出：
array([[8, 4, 2, 5],
[9, 7, 1, 4],
[6, 7, 6, 2]])注意：reshape返回的是视图，而非副本
输入：
x6[0, 0] = 0
x5输出：
array([0, 4, 2, 5, 9, 7, 1, 4, 6, 7, 6, 2])一维向量转行向量
输入：
x7 = x5.reshape(1, x5.shape[0])
x7从一维变成二维
输出：
array([[0, 4, 2, 5, 9, 7, 1, 4, 6, 7, 6, 2]])输入：
x8 = x5[np.newaxis, :]
x8输出：
array([[0, 4, 2, 5, 9, 7, 1, 4, 6, 7, 6, 2]])一维向量转列向量
输入：
x7 = x5.reshape(x5.shape[0], 1)
x7输出：
array([[0],
[4],
[2],
[5],
[9],
[7],
[1],
[4],
[6],
[7],
[6],
[2]])输入：
x8 = x5[:, np.newaxis]
x8输出：
array([[0],
[4],
[2],
[5],
[9],
[7],
[1],
[4],
[6],
[7],
[6],
[2]])多维向量转一维向量
输入：
x6 = np.random.randint(0, 10, (3, 4))
x6输出：
array([[5, 7, 9, 9],
[9, 1, 2, 8],
[8, 1, 8, 1]])flatten返回的是副本
输入：
x9 = x6.flatten()
x9输出：
array([5, 7, 9, 9, 9, 1, 2, 8, 8, 1, 8, 1])输入：
x9[0]=0
x6输出：
array([[5, 7, 9, 9],
[9, 1, 2, 8],
[8, 1, 8, 1]])ravel返回的是视图
输入：
x10 = x6.ravel()
x10输出：
array([5, 7, 9, 9, 9, 1, 2, 8, 8, 1, 8, 1])输入：
x10[0]=0
x6输出：
array([[0, 7, 9, 9],
[9, 1, 2, 8],
[8, 1, 8, 1]])reshape返回的是视图
输入：
x11 = x6.reshape(-1)
x11输出：
array([0, 7, 9, 9, 9, 1, 2, 8, 8, 1, 8, 1])输入：
x11[0]=10
x6输出：
array([[10, 7, 9, 9],
[ 9, 1, 2, 8],
[ 8, 1, 8, 1]])5 数组的拼接
x1 = np.array([[1, 2, 3],
[4, 5, 6]])
x2 = np.array([[7, 8, 9],
[0, 1, 2]])- 水平拼接——非视图
输入：
x3 = np.hstack([x1, x2])
x3输出：
array([[1, 2, 3, 7, 8, 9],
[4, 5, 6, 0, 1, 2]])输入：
x3[0][0] = 0
x1输出：
array([[1, 2, 3],
[4, 5, 6]])输入：
x3[0][0] = 0
x1输出：
array([[1, 2, 3],
[4, 5, 6]])输入：
x4 = np.c_[x1, x2]
x4输出：
array([[1, 2, 3, 7, 8, 9],
[4, 5, 6, 0, 1, 2]])输入：
x4[0][0] = 0
x1输出：
array([[1, 2, 3],
[4, 5, 6]])- 垂直拼接——非视图
x1 = np.array([[1, 2, 3],
[4, 5, 6]])
x2 = np.array([[7, 8, 9],
[0, 1, 2]])输入：
x5 = np.vstack([x1, x2])
x5输出：
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[0, 1, 2]])输入：
x6 = np.r_[x1, x2]
x6输出：
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[0, 1, 2]])6. 数组的分裂
- split的用法
输入：
x6 = np.arange(10)
x6输出：
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])输入：
x1, x2, x3 = np.split(x6, [2, 7])
print(x1, x2, x3)输出：
[0 1] [2 3 4 5 6] [7 8 9]- hsplit的用法
输入：
x7 = np.arange(1, 26).reshape(5, 5)
x7输出：
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25]])输入：
left, middle, right = np.hsplit(x7, [2,4])
print("left:\n", left) # 第0~1列
print("middle:\n", middle) # 第2~3列
print("right:\n", right) # 第4列输出：
left:
[[ 1 2]
[ 6 7]
[11 12]
[16 17]
[21 22]]
middle:
[[ 3 4]
[ 8 9]
[13 14]
[18 19]
[23 24]]
right:
[[ 5]
[10]
[15]
[20]
[25]]- vsplit的用法
输入：
x7 = np.arange(1, 26).reshape(5, 5)
x7输出：
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20],
[21, 22, 23, 24, 25]])输入：
upper, middle, lower = np.vsplit(x7, [2,4])
print("upper:\n", upper) # 第0~1行
print("middle:\n", middle) # 第2~3行
print("lower:\n", lower)输出：
upper:
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]
middle:
[[11 12 13 14 15]
[16 17 18 19 20]]
lower:
[[21 22 23 24 25]]四、Numpy 四大运算
1. 向量化运算
- 与数字的加减乘除等
输入：
x1 = np.arange(1,6)
x1输出：
array([1, 2, 3, 4, 5])输入：
print("x1+5", x1+5)
print("x1-5", x1-5)
print("x1*5", x1*5)
print("x1/5", x1/5)输出：
x1+5 [ 6 7 8 9 10]
x1-5 [-4 -3 -2 -1 0]
x1*5 [ 5 10 15 20 25]
x1/5 [0.2 0.4 0.6 0.8 1. ]输入：
print("-x1", -x1)
print("x1**2", x1**2)
print("x1//2", x1//2) # 求整数商
print("x1%2", x1%2) # 求余数输出：
-x1 [-1 -2 -3 -4 -5]
x1**2 [ 1 4 9 16 25]
x1//2 [0 1 1 2 2]
x1%2 [1 0 1 0 1]- 绝对值、三角函数、指数、对数
（1）绝对值
输入：
x2 = np.array([1, -1, 2, -2, 0])
x2输出：
array([ 1, -1, 2, -2, 0])输入：
abs(x2)输出：
array([1, 1, 2, 2, 0])输入：
np.abs(x2)输出：
array([1, 1, 2, 2, 0])（2）三角函数
输入：
theta = np.linspace(0, np.pi, 3) # 生成等差数列
theta输出：
array([0. , 1.57079633, 3.14159265])输入：
print("sin(theta)", np.sin(theta))
print("con(theta)", np.cos(theta))
print("tan(theta)", np.tan(theta))输出：
sin(theta) [0.0000000e+00 1.0000000e+00 1.2246468e-16]
con(theta) [ 1.000000e+00 6.123234e-17 -1.000000e+00]
tan(theta) [ 0.00000000e+00 1.63312394e+16 -1.22464680e-16]输入：
x = [1, 0 ,-1]
print("arcsin(x)", np.arcsin(x))
print("arccon(x)", np.arccos(x))
print("arctan(x)", np.arctan(x))输出：
arcsin(x) [ 1.57079633 0. -1.57079633]
arccon(x) [0. 1.57079633 3.14159265]
arctan(x) [ 0.78539816 0. -0.78539816]（3）指数运算
输入：
x = np.arange(3)
x输出：
array([0, 1, 2])输入：
np.exp(x)输出：
array([1. , 2.71828183, 7.3890561 ])（4）对数运算
输入：
x = np.array([1, 2, 4, 8 ,10])
print("ln(x)", np.log(x))
print("log2(x)", np.log2(x))
print("log10(x)", np.log10(x))输出：
ln(x) [0. 0.69314718 1.38629436 2.07944154 2.30258509]
log2(x) [0. 1. 2. 3. 3.32192809]
log10(x) [0. 0.30103 0.60205999 0.90308999 1. ]- 两个数组的运算
输入：
x1 = np.arange(1,6)
x1输出：
array([1, 2, 3, 4, 5])输入：
x2 = np.arange(6,11)
x2输出：
array([ 6, 7, 8, 9, 10])输入：
print("x1+x2:", x1+x2)
print("x1-x2:", x1-x2)
print("x1*x2:", x1*x2)
print("x1/x2:", x1/x2)输出：
x1+x2: [ 7 9 11 13 15]
x1-x2: [-5 -5 -5 -5 -5]
x1*x2: [ 6 14 24 36 50]
x1/x2: [0.16666667 0.28571429 0.375 0.44444444 0.5 ]2. 矩阵运算
输入：
x = np.arange(9).reshape(3, 3)
x输出：
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])- 矩阵的转置
输入：
y = x.T
y输出：
array([[0, 3, 6],
[1, 4, 7],
[2, 5, 8]])- 矩阵乘法
x = np.array([[1, 0],
[1, 1]])
y = np.array([[0, 1],
[1, 1]])输入：
x.dot(y)输出：
array([[0, 1],
[1, 2]])输入：
np.dot(x, y)输出：
array([[0, 1],
[1, 2]])输入：
y.dot(x)输出：
array([[1, 1],
[2, 1]])输入：
np.dot(y, x)输出：
array([[1, 1],
[2, 1]])注意跟x*y的区别
输入：
x*y输出：
array([[0, 0],
[1, 1]])3. 广播运算
输入：
x = np.arange(3).reshape(1, 3)
x输出：
array([[0, 1, 2]])输入：
x+5输出：
array([[5, 6, 7]])规则:
如果两个数组的形状在维度上不匹配
那么数组的形式会沿着维度为1的维度进行扩展以匹配另一个数组的形状。
输入：
x1 = np.ones((3,3))
x1输出：
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])输入：
x2 = np.arange(3).reshape(1, 3)
x2输出：
array([[0, 1, 2]])输入：
x1+x2输出：
array([[1., 2., 3.],
[1., 2., 3.],
[1., 2., 3.]])输入：
x3 = np.logspace(1, 10, 10, base=2).reshape(2, 5) # 生成等比数列
x3输出：
array([[ 2., 4., 8., 16., 32.],
[ 64., 128., 256., 512., 1024.]])输入：
x4 = np.array([[1, 2, 4, 8, 16]])
x4输出：
array([[ 1, 2, 4, 8, 16]])输入：
x3/x4输出：
array([[ 2., 2., 2., 2., 2.],
[64., 64., 64., 64., 64.]])输入：
x5 = np.arange(3).reshape(3, 1)
x5输出：
array([[0],
[1],
[2]])输入：
x6 = np.arange(3).reshape(1, 3)
x6输出：
array([[0, 1, 2]])输入：
x5+x6输出：
array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4]])4. 比较运算和掩码
- 比较运算
输入：
x1 = np.random.randint(100, size=(10,10))
x1输出：
array([[43, 71, 4, 25, 62, 52, 48, 77, 10, 22],
[23, 69, 10, 50, 71, 70, 33, 86, 66, 65],
[32, 89, 75, 70, 31, 91, 96, 46, 47, 28],
[86, 82, 20, 12, 58, 28, 18, 16, 30, 8],
[27, 98, 3, 95, 29, 30, 47, 35, 62, 50],
[40, 80, 26, 39, 95, 65, 52, 27, 88, 20],
[21, 8, 33, 57, 57, 96, 39, 68, 88, 26],
[62, 50, 14, 40, 75, 50, 79, 3, 99, 8],
[88, 76, 54, 55, 84, 51, 15, 24, 13, 76],
[85, 51, 75, 16, 96, 94, 8, 1, 71, 78]])输入：
x1 > 50输出：
array([[False, True, False, False, True, True, False, True, False,
False],
[False, True, False, False, True, True, False, True, True,
True],
[False, True, True, True, False, True, True, False, False,
False],
[ True, True, False, False, True, False, False, False, False,
False],
[False, True, False, True, False, False, False, False, True,
False],
[False, True, False, False, True, True, True, False, True,
False],
[False, False, False, True, True, True, False, True, True,
False],
[ True, False, False, False, True, False, True, False, True,
False],
[ True, True, True, True, True, True, False, False, False,
True],
[ True, True, True, False, True, True, False, False, True,
True]])- 操作布尔数组
输入：
x2 = np.random.randint(10, size=(3, 4))
x2输出：
array([[7, 5, 7, 8],
[3, 5, 9, 4],
[1, 8, 7, 5]])输入：
print(x2 > 5)
np.sum(x2 > 5)输出：
[[ True False True True]
[False False True False]
[False True True False]]
6输入：
np.all(x2 > 0)输出：
True输入：
np.any(x2 == 6)输出：
False输入：
np.all(x2 < 9, axis=1) # 按行进行判断输出：
array([ True, False, True])输入：
x2输出：
array([[7, 5, 7, 8],
[3, 5, 9, 4],
[1, 8, 7, 5]])输入：
(x2 < 9) & (x2 >5)输出：
array([[ True, False, True, True],
[False, False, False, False],
[False, True, True, False]])输入：
np.sum((x2 < 9) & (x2 >5))输出：
5- 将布尔数组作为掩码
输入：
x2输出：
array([[7, 5, 7, 8],
[3, 5, 9, 4],
[1, 8, 7, 5]])输入：
x2 > 5输出：
array([[ True, False, True, True],
[False, False, True, False],
[False, True, True, False]])输入：
x2[x2 > 5]输出：
array([7, 7, 8, 9, 8, 7])5. 花哨的索引
- 一维数组
输入：
x = np.random.randint(100, size=10)
x输出：
array([80, 71, 43, 23, 12, 60, 75, 1, 9, 20])注意：结果的形状与索引数组ind一致
输入：
ind = [2, 6, 9]
x[ind]输出：
array([43, 75, 20])输入：
ind = np.array([[1, 0],
[2, 3]])
x[ind]输出：
array([[71, 80],
[43, 23]])- 多维数组
输入：
x = np.arange(12).reshape(3, 4)
x输出：
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])输入：
row = np.array([0, 1, 2])
col = np.array([1, 3, 0])
x[row, col] # x(0, 1) x(1, 3) x(2, 0)输出：
array([1, 7, 8])输入：
row[:, np.newaxis] # 列向量输出：
array([[0],
[1],
[2]])输入：
x[row[:, np.newaxis], col] # 广播机制输出：
array([[ 1, 3, 0],
[ 5, 7, 4],
[ 9, 11, 8]])五、其他 Numpy 通用函数
1. 数值排序
输入：
x = np.random.randint(20, 50, size=10)
x输出：
array([44, 37, 45, 38, 44, 21, 33, 44, 25, 27])- 产生新的排序数组
输入：
np.sort(x)输出：
array([21, 25, 27, 33, 37, 38, 44, 44, 44, 45])输入：
x输出：
array([44, 37, 45, 38, 44, 21, 33, 44, 25, 27])- 替换原数组
输入：
x.sort()
x输出：
array([21, 25, 27, 33, 37, 38, 44, 44, 44, 45])- 获得排序索引
输入：
x = np.random.randint(20, 50, size=10)
x输出：
array([48, 35, 49, 37, 24, 49, 32, 44, 40, 34])输入：
i = np.argsort(x)
i输出：
array([4, 6, 9, 1, 3, 8, 7, 0, 2, 5], dtype=int64)4表示第4号位为最小值，6表示第6号位为第二小值
2. 最大最小值
输入：
x = np.random.randint(20, 50, size=10)
x输出：
array([22, 45, 46, 36, 24, 46, 24, 47, 24, 47])输入：
print("max:", np.max(x))
print("min:", np.min(x))输出：
max: 47
min: 22输入：
print("max_index:", np.argmax(x))
print("min_index:", np.argmin(x))输出：
max_index: 7
min_index: 03. 数值求和、求积
输入：
x = np.arange(1,6)
x输出：
array([1, 2, 3, 4, 5])输入：
x.sum()输出：
15输入：
np.sum(x)输出：
15输入：
x1 = np.arange(6).reshape(2,3)
x1输出：
array([[0, 1, 2],
[3, 4, 5]])- 按行求和
输入：
np.sum(x1, axis=1)输出：
array([ 3, 12])- 按列求和
输入：
np.sum(x1, axis=0)输出：
array([3, 5, 7])- 全体求和
输入：
np.sum(x1)输出：
15- 求积
输入：
x输出：
array([1, 2, 3, 4, 5])输入：
x.prod()输出：
120输入：
np.prod(x)输出：
1204. 中位数、均值、方差、标准差
x = np.random.normal(0, 1, size=10000)输入：
import matplotlib.pyplot as plt
plt.hist(x, bins=50)
plt.show()输出：
- 中位数
输入：
np.median(x)输出：
0.0014721550254339377- 均值
输入：
x.mean()输出：
0.001112519314802629- 方差
输入：
x.var()输出：
1.0098297975081443- 标准差
输入：
x.std()输出：
1.0049028796396915五、总结
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
