1 创建数组

Ndarray 是 numpy库 中的一个对象，是 pandas 学习的基础，故安装 pandas 会自带 numpy 库。

  1. pip install numpy  -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com

1.1 转换创建（array arange）

列表、元组、集合 转换为 数组 — array
python import numpy as np # 列表 转换 一维 a1 = np.array([1,2,3]) print(a1, '\n', type(a1)) # 列表 转换 多维 a2 = np.array([[1,2,3],[4,5,6]]) print(a2, '\n', type(a2)) # 元组 转换 一维 a3 = np.array((1,2,3)) print(a3, '\n', type(a3)) # 元组 转换 多维 a4 = np.array(((1,2,3),(4,5,6))) print(a4, '\n', type(a4)) # 集合 转换 一维 a5 = np.array({1,2,3}) print(a5, '\n', type(a5)) python [1 2 3] <class 'numpy.ndarray'> [[1 2 3] [4 5 6]] <class 'numpy.ndarray'> [1 2 3] <class 'numpy.ndarray'> [[1 2 3] [4 5 6]] <class 'numpy.ndarray'> # 其他长相的数组，尽量不用 {1, 2, 3} <class 'numpy.ndarray'>
range 转换为 数组 — arange
python import numpy as np # range 转换 数组 （array） a1 = np.array(range(1,5+1)) print(a1, '\n', type(a1)) # range 转换 数组 （arange） a2 = np.arange(1,5+1) print(a2, '\n', type(a2)) python [1 2 3 4 5] <class 'numpy.ndarray'> [1 2 3 4 5] <class 'numpy.ndarray'>

1.2 克隆创建（ones zeros full）

创建全是 1 的数组 — ones
python import numpy as np # 创建一维数组 a1 = np.ones(3) print(a1) # 创建多维数组 a2 = np.ones((2,3)) print(a2) a3 = np.ones((2,3,4)) print(a3) # 定义数组的数据类型 a4 = np.ones((3,), dtype=np.int32) print(a4) a5 = np.array([[1,2,3],[4,5,6]]) # 按照其他数组形状创建 a6 = np.ones_like(a5) print(a6) # 按其他数组形状创建，并改变元素数据类型 a7 = np.ones_like(a5,dtype=float) print(a7) python [1. 1. 1.] [[1. 1. 1.] [1. 1. 1.]] [[[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]] [[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]]] [1 1 1] [[1 1 1] [1 1 1]] [[1. 1. 1.] [1. 1. 1.]]
创建全是 0 的数组 — zeros
python import numpy as np # 创建一维数组 a1 = np.zeros(3) print(a1) # 创建多维数组 a2 = np.zeros((2,3)) print(a2) a3 = np.zeros((2,3,4)) print(a3) # 定义数组数据类型 a4 = np.zeros((3,), dtype=np.int32) a5 = np.array([[1,2,3],[4,5,6]]) # 按照其他数组形状创建 a6 = np.zeros_like(a5) print(a6) # 按其他数组形状创建，并改变元素数据类型 a7 = np.zeros_like(a5, dtype=float) print(a7) python [0. 0. 0.] [[0. 0. 0.] [0. 0. 0.]] [[[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]] [[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]]] [0 0 0] [[0 0 0] [0 0 0]] [[0. 0. 0.] [0. 0. 0.]]
创建全是 某元素 的数组 — full
python import numpy as np # 创建一维数组 a1 = np.full(3, 6) print(a1) # 创建多维数组 a2 = np.full((2,3), 6) print(a2) a3 = np.full((2,3,4), 6) print(a3) # 定义数组数据类型 a4 = np.full((3,),6, dtype=np.int32) print(a4) a5 = np.array([[1,2,3],[4,5,6]]) # 按照其他数组形状创建 a6 = np.full_like(a5, 6) print(a6) # 按其他数组形状创建，并改变元素数据类型 a7 = np.full_like(a5, 6, dtype=float) print(a7) python [6 6 6] [[6 6 6] [6 6 6]] [[[6 6 6 6] [6 6 6 6] [6 6 6 6]] [[6 6 6 6] [6 6 6 6] [6 6 6 6]]] [6 6 6] [[6 6 6] [6 6 6]] [[6. 6. 6.] [6. 6. 6.]]
+ 以上三种方法的参数，除了shape、dtype，还有order。其缺省值为'C'，看上去没啥用。

1.3 随机创建（random.）

创建全是 随机数 的数组 — random/round
python import numpy as np import random # 创建一个随机数 a1 = np.random.randn() print(a1) print(np.round(a1,2)) # 创建一个一维随机数组 a2 = np.random.randn(3) print(np.round(a2,2)) # 创建一个多为随机数组 a3 = np.random.randn(2,3) print(np.round(a3,3)) a4 = np.random.randn(2,3,4) print(np.round(a4)) python 1.031383667708804 1.03 [-1.36 -0.21 -1.37] [[ 0.044 1.477 -0.158] [ 1.259 -0.46 -0.451]] [[[-0. 2. -0. 2.] [ 0. -2. -1. -1.] [ 0. 1. 0. -1.]] [[ 2. 1. -1. 2.] [-2. 1. -0. 0.] [ 1. -1. -1. -1.]]]

1.3.1 均匀分布（uniform rand random randint）

随机浮点数组 · [起点,终点) 自定义范围（uniform）
python import numpy as np # 一维数组 print(np.random.uniform(0,1,2)) # 二维数组 print(np.random.uniform(0,1,(2,2))) # 三维数组 print(np.random.uniform(0,1,(2,2,2))) python # np.random.uniform(起点,终点,形状) [0.34269663 0.4367221 ] [[0.14276657 0.89903204] [0.99461771 0.20486272]] [[[0.58013093 0.70933401] [0.24433935 0.95509984]] [[0.79287801 0.55315741] [0.17473607 0.9440846 ]]]
随机浮点数组 · [0, 1) 固定范围（rand / random）
python import numpy as np # np.random.rand(形状) # 一维数组 print(np.random.rand(2)) '''返回： [0.94605382 0.08525247] ''' # 二维数组 print(np.random.rand(2,2)) '''返回： [[0.96991459 0.72587732] [0.52986089 0.90864894]] ''' # 三维数组 print(np.random.rand(2,2,2)) '''返回： [[[0.94164405 0.13845486] [0.41290179 0.67060779]] [[0.30618426 0.62729608] [0.41795913 0.89066505]]] ''' # ------------- 区别 ------------- # # .rand 使用参数为三个数字 python import numpy as np # np.random.random((形状)) # 一维数组 print(np.random.random((2))) # 等同于：.random.random(2) '''返回： [0.34986061 0.52611301] ''' # 二维数组 print(np.random.random((2,2))) # 等同于：.random(size=(2,2)) '''返回： [[0.85638201 0.10417258] [0.52316866 0.46533676]] ''' # 三维数组 print(np.random.random((2,2,2))) # 等同于：.random(size=(2,2,2)) '''返回： [[[0.14426044 0.96843475] [0.09216913 0.85866063]] [[0.40495191 0.38221329] [0.8622722 0.68541147]]] ''' # ------------- 区别 ------------- # # .random 使用参数为一个单独的元组
随机整数/数组 · [起点,终点) 自定义范围（randint）
python import numpy as np # ------- 随机整数 均匀分布 ------- # # 从 [0,n) 中提取 print(np.random.randint(10)) # 从 [m,n) 中提取 print(np.random.randint(1,10)) # ----- 随机整数数组 均匀分布 ----- # # 创建一维数组 print(np.random.randint(1,10,(3,))) # 创建二维数组 print(np.random.randint(1,10,(2,3))) # 创建三维数组 print(np.random.randint(1,10,(2,3,4))) python # np.random.randint(n) 1 # np.random.randint(m,n) 7 # np.random.randint(m,n,形状) [1 6 3] [[1 2 4] [7 4 2]] [[[7 8 2 8] [4 5 9 4] [8 4 5 8]] [[4 7 3 4] [7 4 6 1] [8 3 4 6]]]

1.3.2 正态分布（normal randn）

正态分布曲线性质：相对于平均值对称；平均值是其众数和中位数；68-95-99.7 标准差法则。

随机浮点数组 · 自定义平均值/方差（normal）
python import numpy as np # 一维数组 print(np.random.normal(2,1,2)) # 二维数组 print(np.random.normal(2,1,(2,2))) # 三维数组 print(np.random.normal(2,1,(2,2,2))) python # np.random.normal(平均值,方差,形状) # 等同于：np.random.normal(2,1,(2)) [1.74080644 2.49652808] [[1.69486313 2.56156702] [3.58256424 0.9100765 ]] [[[2.57965651 0.46012199] [0.5441169 2.1580033 ]] [[1.59974882 2.35407124] [0.81536641 1.70638623]]]
随机浮点数组 · 平均值=0 / 方差=1（randn）
python import numpy as np # 随机数 a1 = np.random.randn() print(a1) print(np.round(a1,2)) # 一维数组 print(np.random.randn(2)) # 二维数组 print(np.random.randn(2,2)) # 三维数组 print(np.random.randn(2,2,2)) python # np.random.uniform(形状) 1.031383667708804 1.03 [-0.58493234 1.03541902] [[ 0.52443611 -0.14712604] [ 1.5610946 -2.07701919]] [[[-0.51962273 1.67191976] [ 0.05709329 -1.77742428]] [[ 0.67770549 -1.22433975] [-0.35490138 -0.02985805]]]

1.3.3 范围选择（choice）

随机浮点数组 · 平均值=0 / 方差=1（randn）
python import numpy as np # ------ 随机数组 列表中选择 ------ # # 随机一维数组 print(np.random.choice([1,3,5,7],3)) # 随机二维数组 print(np.random.choice([1,3,5,7],(2,3))) # 随机三维数组 print(np.random.choice([1,3,5,7],(2,3,4))) # 用数字代替列表（从[0,3]选） print(np.random.choice(3,(2,3))) python # np.random.uniform(形状) [3 5 1] [[3 1 9] [5 5 3]] [[[1 5 3 9] [5 3 9 9] [3 5 1 7]] [[1 1 7 1] [9 9 7 5] [7 9 9 3]]] # 数字 n 可看做 [0,1,2...,n] [[1 0 2] [1 2 1]]

1.3.4 浮点取整（round）

浮点取整 — round
python import numpy as np # 创建一个多维随机数组 a = np.random.randn(2,3) # 取整保留三位小数 print(np.round(a,3)) # 取整数 print(np.round(a)) python [[ 0.55956132 1.80628289 -0.19063548] [-0.06615718 0.68923754 0.49649063]] [[ 0.56 1.806 -0.191] [-0.066 0.689 0.496]] # 不改变数据类型，故有 ‘.’ [[ 1. 2. -0.] [-0. 1. 0.]]

1.3.5 空数组（empty）

空数组 — empty
python import numpy as np # 创建一维数组 a1 = np.empty(3) print(a1) # 创建多维数组 a2 = np.empty((2,3)) print(a2) a3 = np.empty((2,3,4)) print(a3) # 定义数组的数据类型 a4 = np.empty((3,), dtype=np.int32) print(a4) a5 = np.array([[1,2,3],[4,5,6]]) # 按照其他数组形状创建 a6 = np.empty_like(a5) print(a6) # 按其他数组形状创建，并改变元素数据类型 a7 = np.empty_like(a5,dtype=float) print(a7) python [5.41011259e+241 8.70650590e+183 1.81596891e-152] [[0. 0. 0.] [0. 0. 0.]] [[[4.67296746e-307 1.69121096e-306 8.90097448e-308 1.33508591e-307] [6.23036978e-307 1.11261162e-306 8.90104239e-307 1.24610383e-306] [1.69118108e-306 8.06632139e-308 1.20160711e-306 1.69119330e-306]] [[1.29062229e-306 8.45590539e-307 6.23054972e-307 1.24612081e-306] [1.60218491e-306 6.89813978e-307 1.78021527e-306 1.42418172e-306] [2.04712906e-306 7.56589622e-307 1.11258277e-307 8.90111708e-307]]] [1936029551 537538164 538976288] [[1818588769 1914714656 1952541797] [1713398885 1952673397 544108393]] [[0. 0. 0.] [0. 0. 0.]]

1.4 元素数据类型（dtype）

数组在创建时，都可以以dtype参数设定数组中数据的数据类型。其类型数量高于本体数量。

数组中的所有元素的数据类型要一致。

返回元素的数据类型
python import numpy as np arr = np.random.randn(2,3,4) # 元素数据类型 print(arr.dtype) # 返回：int32 python import numpy as np arr2 = np.arange(1,5+1) # 元素数据类型 print(arr2.dtype) # 返回：float64
数据类型 说明 范围 别名 数组样式
bool 布朗值 True、False [True False]
int 整数型 [-1 0 1]
intc C中的int
intp 用于索引的int
int8 字节 -128~127 i1
int16 整数 -32_768~32_767 i2
int32 整数 -2_147_483_648~ 2_147_483_647 i4
int64 整数 -9_223_372_036_854_775_808 ~9_223_372_036_854_775_807 i8
uint8 无符号整数 0~255 [255 0 1]
uint16 无符号整数 0~65_535
uint32 无符号整数 0~4_294_967_295
uint64 无符号整数 0~18_446_744_073_709_551_615
float16 半精度浮点数 +/-1.(0~10位) * 10^(0~5位) [-1. 0. 1.]
float32 单精度浮点数 +/-1.(0~23位) * 10^(0~8位)
float64 双精度浮点数 +/-1.(0~52位) * 10^(0~11位) float
complex64 复数 双 32 位浮点数 [-1.+0.j 0.+0.j 1.+0.j]
complex128 复数 双 64 位浮点数 complex128

1.5 注意事项（copy）

浅拷贝 / 深拷贝 — copy
python import numpy as np arr = np.arange(5) # 浅拷贝 -- 新变量名=旧变量名 arr2 = arr arr2[2] = 6 print(arr2) print(arr) # 深拷贝 -- 索引 / 切片 arr3 = arr[0] arr3 = 6 print(arr3) print(arr) arr4 = arr[:] arr4 = np.array([1,3,5,7,9]) print(arr4) print(arr) # 深拷贝 -- copy arr5 = arr.copy() arr5 = np.array([6,6,6,6,6]) print(arr5) print(arr) python # 通过 “新变量名=旧变量名” 创建数组，只是把内存多指向给一个变量名，更改其中一个变量的同时，另一个变量也会跟着修改。 [0 1 6 3 4] [0 1 6 3 4] 6 [0 1 6 3 4] [1 3 5 7 9] [0 1 6 3 4] [6 6 6 6 6] [0 1 6 3 4]

2 查询数组

2.1 查询属性（shape ndim size）

数组形状维度查询 — shape ndim size
python import numpy as np arr = np.random.randn(2,3,4) # 数组的形状 print(arr.shape) # 返回：(5,) # 数组的维度（也叫秩zhì） print(arr.ndim) # 返回：1 # 所有元素数量 print(arr.size) # 返回：5 python import numpy as np arr2 = np.arange(1,5+1) # 数组的形状 print(arr2.shape) # 返回：(2, 3, 4) # 数组的维度 print(arr2.ndim) # 返回：3 # 所有元素数量 print(arr2.size) # 返回：24

2.2 索引切片（中括号）

2.2.1 基础索引

一维数组 索引&切片
python import numpy as np arr = np.arange(1,6+1) print(arr) # arr[n] # arr[索引:截点:步长] # 指定元素 print(arr[3]) # 缺省值 print(arr[0:len(arr):1]) print(arr[-len(arr)::1]) # 顺序打印全部 print(arr) print(arr[:]) # 第一参数 表起点 print(arr[4:]) print(arr[-3:]) # 第二参数 表终点 print(arr[:3]) print(arr[:-4]) # 第一二参数 符号相同 print(arr[1:4]) print(arr[-6:-3]) # 第三参数 正负 表顺逆 print(arr[::-1]) # 第三参数 大小 表间隔 print(arr[::2]) print(arr[::-2]) # 数组切片结果为数组 arr2 = arr[1:4] print(arr2) print(type(arr2)) python [1 2 3 4 5 6] 4 [1 2 3 4 5 6] [1 2 3 4 5 6] [1 2 3 4 5 6] [1 2 3 4 5 6] [5 6] [4 5 6] [1 2 3] [1 2] [2 3 4] [1 2 3] [6 5 4 3 2 1] [1 3 5] [6 4 2] [2 3 4] <class 'numpy.ndarray'>
plain 从后面索引： -6 -5 -4 -3 -2 -1 从前面索引： 0 1 2 3 4 5 +---+---+---+---+---+---+ ['a','b','c','d','e','f'] +---+---+---+---+---+---+ 从前面截取: : 1 2 3 4 5 : 从后面截取: : -5 -4 -3 -2 -1 :
多维数组 索引&切片
python import numpy as np a1 = np.array([ [11,12,13,14,15], [21,22,23,24,25], [31,32,33,34,35] ]) # 返回元素 print(a1[0,0]) # 返回低维数组 print(a1[0:3,0]) print(a1[1,0:3]) # 返回同维数组 print(a1[:-1]) # 省略列参数 print(a1[:,:-1]) # 行参数不可省 # print(a1[...,:-1])等效于上式 # : 或 ... 都可表示全部 python # 原则同一维数组 # 数组名[行索引, 列索引] 11 # 既使用索引又使用切片 [11 21 31] # 数组名[行索引, 列切片] [21 22 23] # 数组名[行切片, 列索引] [[11 12 13 14 15] [21 22 23 24 25]] [[11 12 13 14] [21 22 23 24] [31 32 33 34]]

2.2.2 布尔索引

布尔索引
python import numpy as np a1 = np.array([ [11,12,13,14,15], [21,22,23,24,25], [31,32,33,34,35] ]) # 布尔索引 # 数组 算术运算符 数字 比较运算符 数字 print(a1%10==3) # 数组[数组关系表达式] print(a1[a1%10==3]) python # 返回一个相同形状数组，元素符合情况写做 True，不符合情况的位置写做 False [[False False True False False] [False False True False False] [False False True False False]] # 返回一个一维数组，包含所有满足情况的元素 [13 23 33]
布尔数组统计
python import numpy as np arr = np.array([[1,9,5,8,0],[4,6,9,5,7]]) # 返回布尔数组 atf = arr>5 print(atf) # 统计True的数量 print(atf.sum()) print(atf.any()) print(atf.all()) # 根据 True / False 替换 print(np.where(atf,arr,0)) python [[False True False True False] [False True True False True]] 5 # 返回整数标记数量 True # 有True得True False # 全True得True # np.where(布尔数组,True替换值，False替换值); arr 则表示替换为原数组元素 [[0 9 0 8 0] [0 6 9 0 7]]

2.2.3 数组索引

数组索引
python import numpy as np a1 = np.array([ [11,12,13,14,15], [21,22,23,24,25], [31,32,33,34,35] ]) # ---- <基础索引：俩数字> ---- # print(a1[2,3]) # -------- <数组索引> -------- # # 俩数字都用一维数组替代 # 两数组相同位置元素构成一个索引 print(a1[[0,1,2],[3,3,3]]) # 单一数字用一维数组替代 print(a1[[0,1,2],3]) # 俩数字都用二维数组替代 # 两个二维数组相同位置元素构成索引 print(a1[[[0,0],[2,2]],[[0,4],[0,4]]]) python 34 # 数组名[[a,b,c],[e,f,g]] # 等效于：[a1[a,e] a1[b,f] a1[c,g]] [14 24 34] # 结果是一维数组 # 等效于：a1[[0,1,2],[3,3,3]] [14 24 34] # 数组名[[[a,b],[c,d]],[[e,f],[g,h]]] # 等效于：[[a1[a,e] a1[b,f]] # a1[c,g] a1[d,h]] [[11 15] [31 35]] # 结果是多维数组

2.2.4 花式索引

花式索引
python import numpy as np arr = np.arange(32).reshape((4,8)) print(arr) # 将多维数组每行数据指定索引重组 print(arr[[0,2]]) # 倒序索引也适用 print(arr[[-1,-2,-3]]) # 想将多维数组行重整的同时，也将列重整，需要 np.ix_ print(arr[np.ix_([0,3],[0,7])]) python [[ 0 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 26 27 28 29 30 31]] # 数组[[行索引1,行索引2,行索引3...]] [[ 0 1 2 3 4 5 6 7] [16 17 18 19 20 21 22 23]] [[24 25 26 27 28 29 30 31] [16 17 18 19 20 21 22 23] [ 8 9 10 11 12 13 14 15]] # 数组[np.ix_([行索引1,行索引2...],[列索引1,列索引2...])] [[ 0 7] [24 31]]

2.9 其他（没学的）

内存相关属性（俺不会） 其他
+ itemsize
+ flags		 + real
+ imag
+ data

3 修改数组

3.1 修改属性（reshape flatten）

数组形状/维度转换 — reshape flatten
python import numpy as np a1 = np.arange(10) print(a1.shape, '\t', a1.ndim) print(a1) # 修改数组形状，同时可修改维度 a2 = a1.reshape(2,5) print(a2.shape, '\t', a2.ndim) print(a2) # 元素数量不对应 a3 = np.arange(10).reshape(3,3) print(a3.shape, '\t', a3.ndim) print(a3) # 强制转换为一维 -- flatten a4 = a2.flatten() print(a4.shape, '\t', a4.ndim) print(a4) python (10,) 1 [0 1 2 3 4 5 6 7 8 9] (2, 5) 2 [[0 1 2 3 4] [5 6 7 8 9]] # 元素数量不对应，则报错 # 报错：ValueError # 报错：ValueError (10,) 1 [0 1 2 3 4 5 6 7 8 9]

3.2 数组转置（transpose swapaxes）

二维数组转置
python import numpy as np arr = np.arange(24).reshape(4,6) # 返回原数组 print(arr) '''返回： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23]] ''' # 二维数组行列转置 print(arr.transpose()) '''返回： [[ 0 6 12 18] [ 1 7 13 19] [ 2 8 14 20] [ 3 9 15 21] [ 4 10 16 22] [ 5 11 17 23]] ''' python import numpy as np arr = np.arange(24).reshape(4,6) # 返回原数组 print(arr) '''返回： [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17] [18 19 20 21 22 23]] ''' # 二维数组轴转置 print(arr.swapaxes(0,1)) '''返回： [[ 0 6 12 18] [ 1 7 13 19] [ 2 8 14 20] [ 3 9 15 21] [ 4 10 16 22] [ 5 11 17 23]] '''
python 01 ← 1 轴 → [[ 0 1 2 3 4 5] ↑ [ 6 7 8 9 10 11] 0 [12 13 14 15 16 17] 轴 [18 19 20 21 22 23]] ↓ 10
三维数组转置
python import numpy as np arr = np.arange(24).reshape(2,3,4) # 返回原数组 print(arr) '''返回： [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]] ''' # 行、列转置 print(arr.transpose()) '''返回： [[[ 0 12] [ 4 16] [ 8 20]] [[ 1 13] [ 5 17] [ 9 21]] [[ 2 14] [ 6 18] [10 22]] [[ 3 15] [ 7 19] [11 23]]] ''' python import numpy as np arr = np.arange(24).reshape(2,3,4) # 返回原数组 print(arr) '''返回： [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]] ''' # 0,1 轴转置 print(arr.swapaxes(0,1)) '''返回： [[[ 0 1 2 3] [12 13 14 15]] [[ 4 5 6 7] [16 17 18 19]] [[ 8 9 10 11] [20 21 22 23]]] ''' # 1,2 轴转置 print(arr.swapaxes(1,2)) '''返回： [[[ 0 4 8] [ 1 5 9] [ 2 6 10] [ 3 7 11]] [[12 16 20] [13 17 21] [14 18 22] [15 19 23]]] ''' # 0,2 轴转置 print(arr.swapaxes(0,2)) '''返回： [[[ 0 12] [ 4 16] [ 8 20]] [[ 1 13] [ 5 17] [ 9 21]] [[ 2 14] [ 6 18] [10 22]] [[ 3 15] [ 7 19] [11 23]]] '''
python 012 ← 2 轴 → [[[ 0 1 2 3] ↑ ↑ [ 4 5 6 7] 1 轴 [ 8 9 10 11]] ↓ 0 轴 [[12 13 14 15] ↑ [16 17 18 19] 1 轴 [20 21 22 23]]] ↓ ↓ 210

3.3 数组排序

3.3.1 随机排序（shuffle permutation）

数组随机排序 — shuffle / permutation
python import numpy as np # 一维数组随机排序 a1 = np.arange(5) np.random.shuffle(a1) # 没有返回值 print(a1) '''返回： [0 3 1 2 4] ''' # 二维数组随机排序 # 把内部一维数组作为一个整体 a2 = np.arange(12).reshape(3,4) np.random.shuffle(a2) # 没有返回值 print(a2) '''返回： [[ 8 9 10 11] [ 0 1 2 3] [ 4 5 6 7]] ''' # 三维数组随机排序 # 把内部二维数组作为一个整体 a3 = np.arange(12).reshape(2,2,3) np.random.shuffle(a3) # 没有返回值 print(a3) '''返回： [[[ 6 7 8] [ 9 10 11]] [[ 0 1 2] [ 3 4 5]]] ''' python import numpy as np # 一维数组随机排序 a1 = np.arange(5) ar1 = np.random.permutation(a1) print(ar1) '''返回： [3 2 1 0 4] ''' # 一维数组随机排序 简写（省略arange） a1 = np.random.permutation(6) print(a1) '''返回： [0 2 5 3 1 4] ''' # 二维数组随机排序 # 把内部一维数组作为一个整体 a2 = np.arange(12).reshape(3,4) ar2 = np.random.permutation(a2) print(ar2) '''返回： [[ 0 1 2 3] [ 8 9 10 11] [ 4 5 6 7]] ''' # 三维数组随机排序 # 把内部二维数组作为一个整体 a3 = np.arange(12).reshape(2,2,3) ar3 = np.random.permutation(a3) print(ar3) '''返回： [[[ 6 7 8] [ 9 10 11]] [[ 0 1 2] [ 3 4 5]]] '''

3.3.2 大小排序（sort argsort）

大小排序 — sort / argsort
python import numpy as np arr = np.array([[6,9,5,8,0],[4,6,4,5,7]]) # 行升序 print(np.sort(arr)) # 还可写做：np.sort(arr,-1) '''返回： [[0 5 6 8 9] [4 4 5 6 7]] ''' # 0轴升序 print(np.sort(arr,0)) '''返回： [[4 6 4 5 0] [6 9 5 8 7]] ''' # 1轴升序（二维数组，1轴为行方向） print(np.sort(arr,1)) '''返回： [[0 5 6 8 9] [4 4 5 6 7]] ''' # 行降序索引 print(np.array([np.take(arr[i],np.argsort(-arr[i])) for i in range(2)])) # 一维用 arr[np.argsort(-arr)] 即可 '''返回： [[9 8 6 5 0] [7 6 5 4 4]] ''' # 方法排序 arr.sort() print(arr) # 相当于行排序 '''返回： [[0 5 6 8 9] [4 4 5 6 7]] ''' python import numpy as np arr = np.array([[6,9,5,8,0],[4,6,4,5,7]]) # 对应元素升序后的索引 # 行升序索引 print(np.argsort(arr)) '''返回： [[4 2 0 3 1] [0 2 3 1 4]] ''' # 0轴升序索引 print(np.argsort(arr,0)) '''返回： [[1 1 1 1 0] [0 0 0 0 1]] ''' # 1轴升序索引 print(np.argsort(arr,1)) '''返回： [[4 2 0 3 1] [0 2 3 1 4]] ''' print(np.argsort(-arr)) '''返回： [[1 3 0 2 4] [4 1 3 0 2]] '''

4 数组运算

4.1 运算法则

4.1.1 数组与常数间运算规则

数组与常数间运算：数组中每个元素都与常数做运算
python import numpy as np # 创建一个二维数组 a1 = np.arange(10).reshape(2,5) print(a1) # 加法 print(a1 + 1) # 减法 print(a1 - 1) # 乘法 print(a1 * 2) # 除法 print(a1 / 2) python [[0 1 2 3 4] [5 6 7 8 9]] [[ 1 2 3 4 5] [ 6 7 8 9 10]] [[-1 0 1 2 3] [ 4 5 6 7 8]] [[ 0 2 4 6 8] [10 12 14 16 18]] [[0. 0.5 1. 1.5 2. ] [2.5 3. 3.5 4. 4.5]]

4.1.2 同形状数组间运算规则

形状相同的 数组与数组间 运算
python import numpy as np # 创建两个二维数组 a1 = np.array([[1,2,3],[4,5,6]]) a2 = np.array([[1,3,5],[2,4,6]]) # 运算条件 print(a1.shape==a2.shape) # 加法 print(a1 + a2) # 减法 print(a1 - a2) # 乘法 print(a1 * a2) # 除法 print(a1 / a2) python # 可看做两数组对应位置上的元素分别做运算 # 两数组的形状必须完全一致 True [[ 2 5 8] [ 6 9 12]] [[ 0 -1 -2] [ 2 1 0]] [[ 1 6 15] [ 8 20 36]] [[1. 0.66666667 0.6 ] [2. 1.25 1. ]]

4.1.3 广播原则（高低维数组）

两数组的形状不同时，只有一种情况下是可以进行运算的。

（个人理解）即：1. 一个低维度数组一个高维度数组；2. 低维度数组向一个垂直于他的方向叠加可构成高一维度数组；3. 最终可叠加成高维度数组。

二维数组与一维数组间
python import numpy as np # 二维数组与一维数组间 a1 = np.array([1,2,3]) a2 = np.array([[1,3,5],[2,4,6]]) # 加法 print(a1 + a2) # 减法 print(a1 - a2) # 乘法 print(a1 * a2) # 除法 print(a1 / a2) python # 可把 a1 的 [1,2,3] 看做 # [[1,2,3],[1,2,3]] 在与 a2 # [[1,3,5],[2,4,6]] 做和 [[2 5 8] [3 6 9]] [[ 0 -1 -2] [-1 -2 -3]] [[ 1 6 15] [ 2 8 18]] [[1. 0.66666667 0.6 ] [0.5 0.5 0.5 ]]
三维数组与二维数组间
python import numpy as np # 三维数组与二维数组间 a1 = np.array([1,2,3]) a2 = np.array([[1,3,5],[2,4,6]]) a3 = np.array([[[1,1,1],[2,2,2]], [[3,3,3],[4,4,4]]]) # 加法 print(a1 + a3) # 减法 print(a1 - a3) # 乘法 print(a1 * a3) # 除法 print(a1 / a3) python # 可把 a2 的 [[1,3,5],[2,4,6]] 看做 # [[[1,1,1],[2,2,2]], # [[3,3,3],[4,4,4]]] # 同理 a1 和 a3 也可以进行运算 [[[2 3 4] [3 4 5]] [[4 5 6] [5 6 7]]] [[[ 0 1 2] [-1 0 1]] [[-2 -1 0] [-3 -2 -1]]] [[[ 1 2 3] [ 2 4 6]] [[ 3 6 9] [ 4 8 12]]] [[[1. 2. 3. ] [0.5 1. 1.5 ]] [[0.33333333 0.66666667 1. ] [0.25 0.5 0.75 ]]]

4.2 数组函数运算

数组的函数运算时的参数，常数和数组皆可。为方便书写，大部分都以常数示例。

4.2.1 基本运算

正负 — abs / fabs / sign
python import numpy as np arr = np.array([-1,3,2,-4]) # 绝对值 arr2 = np.abs(arr) print(np.abs(arr)) # 非负数绝对值，返回float型数据 print(np.fabs(arr)) # 正负号 print(np.sign(arr)) python [1 3 2 4] [1. 3. 2. 4.] [-1 1 1 -1]
加减乘除 — add / subtract / multily / divide
python import numpy as np arr = np.array([-1,3,2,-4]) # 加法 print(np.add(arr,2)) # 减法 print(np.subtract(arr,2)) # 乘法 print(np.multiply(arr,2)) # 除法 print(np.divide(arr,2)) # 取余 print(np.mod(arr,2)) python # 等同于 运算符 + [ 1 5 4 -2] # 等同于 运算符 - [-3 1 0 -6] # 等同于 运算符 * [-2 6 4 -8] # 等同于 运算符 / [-0.5 1.5 1. -2. ] [1 1 0 0]

4.2.2 取整函数

取整函数 — ceil / floor / round / rint / modf
python import numpy as np arr = np.array([-1.66, -1.55, -1.44, 1.66,1.55,1.44]) # 向上取整 ceil print(np.ceil(arr)) # 向下取整 float print(np.floor(arr)) # 四舍五入 round / around # -二参默认为0 print(np.round(arr)) # -二参为正 print(np.round(arr,1)) # -二参为负 arr2 = np.array([12.3,21.4]) print(np.around(arr2,-1)) # 四舍五入 float print(np.rint(arr)) # 向 0 取整 modf print(np.modf(arr)[1]) # 整数和小数部分拆分 modf print(np.modf(arr)) # 返回值：(array([小数部分]),array([整数部分])) python [-1. -1. -1. 2. 2. 2.] [-2. -2. -2. 1. 1. 1.] # 和 arr 相同数据类型 # 个位取整 [-2. -2. -1. 2. 2. 1.] # 取整到小数点后位数 [-1.7 -1.6 -1.4 1.7 1.6 1.4] # 取整到小数点前的位数 +1 [10. 20.] [-2. -2. -1. 2. 2. 1.] [-1. -1. -1. 1. 1. 1.] (array([-0.66, -0.55, -0.44, 0.66, 0.55, 0.44]), array([-1., -1., -1., 1., 1., 1.]))

4.2.3 幂指对函数

幂函数 — sqrt / square / reciprocal / power
python import numpy as np arr = np.array([1,2,3,4]) # 平方根 arr2 = np.sqrt(arr2) print(np.round(arr2,2)) # 平方 arr3 = np.square(arr) print(np.round(arr3,2)) # 倒数 print(np.reciprocal(arr)) a = np.array([1.0,2.0,3.0,4.0]) a2 = np.reciprocal(a) print(np.round(a2,2)) # 自定义底数和指数 arr4 = np.power(arr,1/2) print(np.round(arr4,2)) python # 数组所有元素必须为正数 [1. 1.73 1.41 2. ] [ 1 4 9 16] # 返回数组和原数组 元素数据类型相同 [1 0 0 0] [1. 0.5 0.33 0.25] # 数组所有元素必须为正数 [1. 1.41 1.73 2. ]
指数函数 — exp
python import numpy as np arr = np.array([-1,0,1]) # e 的 x 次方 print(np.exp(arr)) python [0.36787944 1. 2.71828183]
幂函数 — log / log10 / log2 / power
python import numpy as np arr = np.array([1,2,10]) # ln，数组所有元素必须为正数 print(np.log(arr)) print(np.log10(arr)) print(np.log2(arr)) python [0. 0.69314718 2.30258509] [0. 0.30103 1. ] [0. 1. 3.32192809]

4.2.4 三角函数

三角函数 — π / sin / cos / tan
python import numpy as np arr = np.array([0,30,45,60,90]) # 常量 π print(np.pi) # 正弦值 arr1 = np.sin(arr/180*np.pi) print(np.round(arr1,2)) # 余弦值 arr2 = np.cos(arr/180*np.pi) print(np.round(arr2,2)) # 正切值 arr3 = np.tan(arr/180*np.pi) print(np.round(arr3,2)) python 3.141592653589793 [0. 0.5 0.71 0.87 1. ] [1. 0.87 0.71 0.5 0. ] [0.00000000e+00 5.80000000e-01 1.00000000e+00 1.73000000e+00
双曲三角函数 — sinh / cosh / tanh （不会用）
python import numpy as np arr = np.array([0,30,45,60,90]) # 双曲正弦值 arr4 = np.sinh(arr/180*np.pi) print(np.round(arr4,2)) # 双曲余弦值 arr5 = np.cosh(arr/180*np.pi) print(np.round(arr5,2)) # 双曲正切值 arr6 = np.tanh(arr/180*np.pi) print(np.round(arr6,2)) python [0. 0.55 0.87 1.25 2.3 ] [1. 1.14 1.32 1.6 2.51] [0. 0.48 0.66 0.78 0.92]
反三角函数 — arcsin / arccos / arctan
python import numpy as np arr = np.array([1,2,10]) # 反正弦值 arr7 = np.arcsin(arr1) print(np.degrees(arr7)) # 反余弦值 arr8 = np.arccos(arr2) print(np.degrees(arr7)) # 反正切值 arr9 = np.arctan(arr3) print(np.degrees(arr7)) python # 在 三角函数 示例结果下进行 [ 0. 30. 45. 60. 90.] [ 0. 30. 45. 60. 90.] [ 0. 30. 45. 60. 90.]

4.2.5 类型判断

类型判断 — isnan / isfinite / isinf
python import numpy as np arr = np.array([-1,0,1]) # 判断是否不是数字 print(np.isnan(arr)) # 判断是否是有穷/无穷 print(np.isfinite(arr)) print(np.isinf(arr)) python [False False False] [ True True True] [False False False]

4.2.6 概率统计

最值/中位数 — (a/arg)min / (a/arg)max / median / percentile
python import numpy as np arr = np.array([[1,9,5,8,0],[4,6,9,5,7]]) # 最小值 print(np.amin(arr,0)) print(np.amin(arr,1)) print(np.amin(arr)) # 最大值 print(np.amax(arr,0)) print(np.amax(arr,1)) print(np.amax(arr)) # 最小值对应下标 print(np.argmin(arr,0)) print(np.argmin(arr,1)) print(np.argmin(arr)) # 最大值对应下标 print(np.argmax(arr,0)) print(np.argmax(arr,1)) print(np.argmax(arr)) # 中位数 print(np.median(arr,0)) print(np.median(arr,1)) print(np.median(arr)) # 升序百分比 print(np.percentile(arr,100,0)) print(np.percentile(arr,0,0)) print(np.percentile(arr,50,1)) print(np.percentile(arr,50)) python # min() 等同于 amin() [1 6 5 5 0] # 0轴（上下）方向最小值 [0 4] # 1轴（左右）方向最小值 0 # 所有元素最小值 # max() 等同于 amax() [4 9 9 8 7] # 0轴（上下）方向最大值 [9 9] # 1轴（左右）方向最大值 9 # 所有元素最大值 [0 1 0 1 0] [4 0] 4 [1 0 1 0 1] [1 2] 1 [2.5 7.5 7. 6.5 3.5] [5. 6.] 5.5 [4. 9. 9. 8. 7.] # 0轴方向最大值 [1. 6. 5. 5. 0.] # 0轴方向最小值 [5. 6.] # 1轴方向中位数 5.5 # 所有元素中位数
做和做积 — sum / prod / cumsum / cumprod
python import numpy as np arr = np.array([[1,9,5,8,0],[4,6,9,5,7]]) # 所有元素做和 print(arr.sum()) print(np.sum(arr)) print(np.sum(arr,0)) print(np.sum(arr,1)) # 所有元素乘积 print(np.prod(arr)) print(np.prod(arr,0)) print(np.prod(arr,1)) # 所有元素逐个做和 print(np.cumsum(arr)) print(np.cumsum(arr,0)) print(np.cumsum(arr,1)) # 所有元素逐个乘积 print(np.cumprod(arr)) print(np.cumprod(arr,0)) print(np.cumprod(arr,1)) python 54 # 方法获得数组所有元素和 54 [ 5 15 14 13 7] [23 31] 0 [ 4 54 45 40 0] [ 0 7560] [ 1 10 15 23 23 27 33 42 47 54] [[ 1 9 5 8 0] [ 5 15 14 13 7]] [[ 1 10 15 23 23] [ 4 10 19 24 31]] [ 1 9 45 360 0 0 0 0 0 0] [[ 1 9 5 8 0] [ 4 54 45 40 0]] [[ 1 9 45 360 0] [ 4 24 216 1080 7560]]
平均值/方差/标准差 — mean / average / var / std
python import numpy as np arr = np.array([-1,0,1]) # 算数平均值 print(np.mean(arr,0)) print(np.mean(arr,1)) print(np.mean(arr)) # 加权平均值 print(np.average(arr)) print(np.average(arr,0)) print(np.average(arr,0,[2,8])) print(np.average(arr,0,[2,8],returned=True)) # 算完做和 # 方差 print(np.var(arr)) print(np.var(arr,0)) print(np.var(arr,1)) # 标准差 print(np.std(arr)) print(np.std(arr,0)) print(np.std(arr,1)) print(np.sqrt(np.var(arr))==np.std(arr)) python [2.5 7.5 7. 6.5 3.5] [4.6 6.2] 5.4 # 所有元素按比例做和 5.4 # 不设置权重则等同于 mean [2.5 7.5 7. 6.5 3.5] [3.4 6.6 8.2 5.6 5.6] (array([3.4, 6.6, 8.2, 5.6, 5.6]), array([10., 10., 10., 10., 10.])) # 各元素与平均值之差的平方的平均值 8.639999999999999 [ 2.25 2.25 4. 2.25 12.25] [13.04 2.96] # 方差的平方根 2.9393876913398134 [1.5 1.5 2. 1.5 3.5] [3.61109402 1.72046505] True # 标准差相当于方差的平方根

4.2.7 集合操作

去重 — unique
python import numpy as np arr = np.array([[6,9,5,8,0],[4,6,4,5,7]]) # 去重并排序 print(np.unique(arr)) python [0 4 5 6 7 8 9]
集合操作 — intersect1d / union1d / setdiff1d / setxor1d
python import numpy as np a1 = np.array([6,9,4,3,2,10]) a2 = np.array([8,4,6,5,1,10]) # 交集并排序 print(np.intersect1d(a1,a2)) # 并集并排序 print(np.union1d(a1,a2)) # 差集并排序 print(np.setdiff1d(a1,a2)) # 异或集并排序（并集-交集） print(np.setxor1d(a1,a2)) python [ 4 6 10] [ 1 2 3 4 5 6 8 9 10] [2 3 9] [1 2 3 5 8 9]
集合操作 — intersect1d / union1d / setdiff1d / setxor1d
python import numpy as np a1 = np.array([6,9,4,3,2,10]) a2 = np.array([8,4,6,5,1,10]) # 交集并排序 print(np.intersect1d(a1,a2)) # 并集并排序 print(np.union1d(a1,a2)) # 差集并排序 print(np.setdiff1d(a1,a2)) # 异或集并排序（并集-交集） print(np.setxor1d(a1,a2)) python [ 4 6 10] [ 1 2 3 4 5 6 8 9 10] [2 3 9] [1 2 3 5 8 9]
备胎查找 — in1d
python import numpy as np arr = np.array([6,9,5,8,0,4,6,4,5]) # 判断各元素是否为选项之一 print(np.in1d(arr,[1,3,5,7,9])) python [False True True False False False False False True]