numpy是机器学习里面基础数字算法库，补充了python语言缺乏的数字计算能力，Numpy底层由C语言实现，运行效率充分优化。2006年，Numpy脱离Scipy成为独立的项目。
ndarry数组
numpy.array() 传入数组参数，可以是一维的也可以是二维三维的，数组会将其转变成ndarray结构。
import numpy as np a = np.array([1, 2, 3, 4]) # [1 2 3 4] b = np.array([[1, 2, 3], [1, 2, 3]]) # 创建维度为2的数组 # [[1 2 3] # [1 2 3]] print(type(a)) # <class 'numpy.ndarray'>
ndarray.ndim 数组的维数
print(a.ndim) # 1 print(b.ndim) # 2
ndarray.size 数组的元素数量
print(b.size) # 6
len(ndarray) 查看数组的第一维度数
print(len(b)) # 2
ndarray.dtype 查看数组元素的类型
print(type(b)) # <class 'numpy.ndarray'> print(b.dtype) # int32 b = a.astype("float32") print(b.dtype) # float32
ndarray对象属性dtype
| 类型名 | 表示符 |
| 布尔型 | bool |
| 有符号整型 | int8(-128~127)/int16/int32/int64 |
| 无符号整型 | unit(-128~127)/unit16/unit32/unit64 |
| 浮点型 | float16/float32/float64 |
| 复数型 | complex64/complex128 |
| 字串型 | str，每个字符用32位Unicode编码表示 |
假如有如下numpy数据
data = [('zs', [50,51,52], 15), ('ls', [83,71,62], 16), ('ww', [90,91,92], 17)]
第一种dtype的设置方式
ary = np.array(data,dtype='U2, 3int32, int32') print(ary) # [('zs', [50, 51, 52], 15) # ('ls', [83, 71, 62], 16) # ('ww', [90, 91, 92], 17)] print(ary[0][1]) # [50 51 52] print(ary[0]['f0']) # zs
第二种dtype的设置方式
ary = np.array(data, dtype={ 'names':['name', 'scores', 'age'], 'formats':['U2', '3int32', 'int32']}) print(ary) # [('zs', [50, 51, 52], 15) # ('ls', [83, 71, 62], 16) # ('ww', [90, 91, 92], 17)] print(ary[0]['age']) # 返回zs的年龄 15 print(ary[2]['scores']) # 返回ww的成绩 [90 91 92]
ndarray数组存放日期数据
dates = ['2011-01-01', '2012-01-01', '2011-02-01', '2012', '2011-01-01 10:10:10'] ary = np.array(dates) print(ary.dtype) # <U19 ary = ary.astype('M8[D]') print(ary) ['2011-01-01' '2012-01-01' '2011-02-01' '2012-01-01' '2011-01-01'] print(ary.dtype) # datetime64[D] print(ary[1]-ary[0]) # 365 days
类型字符码
| 类型 | 字符码 |
| np.bool | ? |
| np.int8/16/32/64 | i1/i2/i4/i8 |
| np.unit8/16/32/64 | u1/u2/u4/u8 |
| np.float/16/32/64 | f2/f4/f8 |
| np.complex64/128 | c8/c16 |
| np.str | U<字符数> |
| np.datetime64 | M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s] |
字节序前缀，用于多字节整型和字符串：<小端；>大端；[=]硬件字节序
类型字符码格式：<字节序前缀><维度><类型><字节数或字符数>
例如：
3i4：3个元素，整型，每个元素占4个字节
<(2,3)u8：小端字节序，2行3列的二维数组，无符号整型，每个元素占8字节
U7:7个字符的Unicode字符串，每个字符占4个字节，采用默认字节序。
维度操作
视图变维（数据共享）：reshape()和 ravel()
import numpy as np a = np.arange(1, 9) # [1 2 3 4 5 6 7 8] b = a.reshape(2, 4) # 视图变维 变为2行4列的二维数组 c = b.reshape(2, 2, 2) # 视图变维 变为2页2行2列的三维数组 d = c.ravel() # 视图变维 变为1维数组
print(c.shape) # (2, 2, 2) e = c.flatten() # 压缩成一维数组 print(e.shape) # (8,)
就地变维：直接改变原数组对象的维度，不返回新数组
import numpy as np a = np.arange(1, 9) print(a.shape) # (8,) a.shape = (2, 4) print(a.shape) # (2, 4) a.resize(2, 2, 2) print(a.shape) # (2, 2, 2)
切片索引
一维切片索引
vector = numpy.array([5, 10, 15, 20]) print(vector[0:3]) # 切片索引取值# [ 5 10 15]
利用返回值获取元素
import numpy vector = numpy.array([5, 10, 15, 20]) print(vector == 10) # [False True False False] # 利用返回值获取元素 print(vector[vector == 10])# [10]
二维切片索引
多维的切片是按照各个维度分别取的
import numpy as np a = np.arange(25).reshape(5, 5) print(a) # [[ 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]] # 取第1、2行，第2、3、4列 print(a[1:3, 2:5]) # 多维的切片是按照各个维度分别取 print(a[:, 2:5]) # 行取全部，列取第3-5
有时候将一个切片索引的参数改成None，那么ndarray的shape会变
print(a[:, None].shape) # (5, 1, 5)
None代表新增加一个维度，它有一个别称叫做newaxis，因为在第二维上用了None，所以数组的shape变成了(5, 1, 5)
我们在第三个维度上看看，shape会变成什么样子。
print(a[:, :, None].shape) # (5, 5, 1)
有时候数组的一个维度上是三个点，它是用省略号代替所有冒号，a[:, :, None]和a[…, None]的输出是一样的，就是因为…代替了前面两个冒号。
print(a[..., None].shape) # (5, 5, 1) print(a[:, :, None].shape) # (5, 5, 1)
数组掩码
import numpy as np # 输出10以内3的倍数 a = np.arange(1, 10) mask = a % 3 == 0 print(mask) # [False False True False False True False False True] print(a[mask]) # [3 6 9] mask = [2, 2, 6, 6, 4, 4] print(a) # [1 2 3 4 5 6 7 8 9] print(a[mask]) # [3 3 7 7 5 5]
创建数组的常用函数
arange 指定范围和数值间的间隔array，np.arange(起始值，终止值，步长)，取值范围左闭右开。
np.arange(0, 10, 2) # [0, 2, 4, 6, 8, 10]
reshape 生成0-14的15个数字，使用reshape(3,5)将其构造成一个三行五列的array
arr = np.arange(15).reshape(3, 5) # array([[0, 1, 2, 3, 4], # [5, 6, 7, 8, 9], # [10, 11, 12, 13, 14]])
squeeze函数 把shape中为1的维度去掉
arr = arr.reshape(1,1,-1) print(arr) # [[[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]]] print(np.squeeze(arr)) # [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14] print(np.squeeze(arr).shape) # (15,)
zero:生成指定结构的默认为0.的array
a = np.zeros((3,4)) # [[0. 0. 0. 0.] # [0. 0. 0. 0.] # [0. 0. 0. 0.]]
ones:生成一个三维的array，通过dtype指定类型
a = np.ones((2, 3, 4), dtype=np.int32) # 3行4列2层 # [[[1 1 1 1] # [1 1 1 1] # [1 1 1 1]] # # [[1 1 1 1] # [1 1 1 1] # [1 1 1 1]]]
numpy.zeros_like()
创造相同结构的全零数组
ary = np.array([1, 2, 3, 4, 5]) print(np.zeros_like(ary)) # [0 0 0 0 0]
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
在指定间隔[start, stop]之间返回均匀num个数字，如果endpoint是True，则不会取最后一个端点stop
np.linspace(2.0, 3.0, num=5) # array([ 2. , 2.25, 2.5 , 2.75, 3. ]) np.linspace(2.0, 3.0, num=5, endpoint=False) # array([ 2. , 2.2, 2.4, 2.6, 2.8])
向下取整np.floor()和向下取整np.ceil()
a = np.random.random((2,2)) # [[0.74892422 0.7665049 ] # [0.29296727 0.74230182]] b = np.floor(10*a) # [[7. 7.] # [2. 7.]] b = np.ceil(a) # [[1. 1.] # [1. 1.]]
a.T 转置（行列变换）
a = np.array([[1,2],[3,4]]) print(a.T)# 转置 # [[1 3] # [2 4]]
a.resize(1,4) 变换结构，和reshape相似
a = np.array([[1,2],[3,4]]) a.resize(1,4) print(a) # array([[1, 2, 3, 4]])
numpy.clip(a, a_min, a_max, out=None)
把数组a中小于a_min的值都化为a_min，大于a_max的值都化为a_max
import numpy as np x=np.array([1,2,3,5,6,7,8,9]) print(np.clip(x,3,8)) # [3 3 3 5 6 7 8 8]
pad函数的用法
ndarray = numpy.pad(array, pad_width, mode, **kwargs)
参数：
- array：要填补的数组
- pad_width：在各维度的各个方向上想要填补的长度，
- 如((1, 1),(2, 2))，表示：在二维数组array第一维(即行)前面填充1行，最后一行填充1行；在二维数组array第二维(即列)前面填充2列，最后面填充2列。
- 如果直接输入一个整数，则说明各个维度和各个方向所填补的长度都一样。
- mode：填补类型，即怎样去填补，有“constant”，“edge”等模式，如果为constant模式，就得指定填补的值，如果不指定，则默认填充0。
对一维数组填充
import numpy as np array = np.array([1, 1]) # (1,2)表示在一维数组array前面填充1位，最后面填充2位 # constant_values=(0,2) 表示前面填充0，后面填充2 ndarray=np.pad(array,(1,2),'constant', constant_values=(0,2)) print(array) # [1 1] print(ndarray) # [0 1 1 2 2]
对二维数组填充
import numpy as np array = np.array([[1, 1],[2,2]]) """ ((1,1),(2,2)) 在二维数组array第一维（此处便是行）前面填充1行，最后面填充1行； 在二维数组array第二维（此处便是列）前面填充2列，最后面填充2列 constant_values=(0,3) 表示第一维填充0，第二维填充3 """ ndarray=np.pad(array,((1,1),(2,2)),'constant', constant_values=(0,3)) print(array) # [[1 1] # [2 2]] print(ndarray) # [[0 0 0 0 3 3] # [0 0 1 1 3 3] # [0 0 2 2 3 3] # [0 0 3 3 3 3]]
数组的组合与拆分
np.hstack(a,b) 横向拼接
import numpy as np a = np.arange(1, 7).reshape(2, 3) b = np.arange(7, 13).reshape(2, 3) # 水平方向完成组合操作，生成新数组 c = np.hstack((a, b)) # (2, 6)
np.vstack(a,b) 纵向拼接
import numpy as np a = np.arange(1, 7).reshape(2, 3) b = np.arange(7, 13).reshape(2, 3) # 垂直方向完成组合操作，生成新数组 c = np.vstack((a, b)) # (4, 3)
np.hsplit(a,2) 矩阵横向切割 把a横 竖切成2分
# a.shape (2, 6) # 水平方向完成拆分操作，生成两个数组 d, e = np.hsplit(c, 2) # d.shape (2, 3) # e.shape (2, 3)
np.vsplit(a,2) 矩阵纵向切割 把a纵 横切2分
# a.shape (4,3) # 垂直方向完成拆分操作，生成两个数组 d, e = np.vsplit(a, 2) # d.shape (2, 3) # e.shape (2, 3)
深度方向（3维）
import numpy as np a = np.arange(1, 7).reshape(2, 3) b = np.arange(7, 13).reshape(2, 3) # 深度方向（3维）完成组合操作，生成新数组 i = np.dstack((a, b)) # (2, 3, 2) print(i.shape) # 深度方向（3维）完成拆分操作，生成两个数组 k, l = np.dsplit(i, 2) # k.shape # (2, 3, 1) # l.shape # (2, 3, 1)
通过axis方法进行数组拼接
axis的取值
- 0: 第一个维度方向，垂直方向
- 1: 第二个维度方向，水平方向
- 2: 第三个维度方向
numpy.concatenate((a1, a2, ...), axis=0)
import numpy as np a = np.array([[1, 2], [3, 4]]) # (2, 2) b = np.array([[5, 6]]) # (1, 2) c=np.concatenate((a, b), axis=0) # (3, 2) d=np.concatenate((a, b.T), axis=1) # (2, 3)
拆分，axis的取值同上
np.split(c, 2, axis=0)
注意：拼接的数组，除了需要拼接的维度可以不同，其他维度必须相同。
例如，a.shape为(4,5,6,10)，b.shape为(4,5,6,20)
np.concatenate([a,b], axis=3) # 返回张量的shape为(4,5,6,30)
矩阵运算
column是列，row是行。
相加、相减、开根号、e平方、取log对数
a = np.array([10,20,30,40]) b = np.array(4) print(np.abs(-b)) # 取绝对值 print(a - b) # array([ 6, 16, 26, 36]) # 取平方 print(a**2) # array([ 100, 400, 900, 1600]) print(np.square(a)) # 开根号 print(np.sqrt(a**2)) # [10. 20. 30. 40.] # 以e为底的对数 print(np.exp(a)) # [2.20264658e+04 4.85165195e+08 1.06864746e+13 2.35385267e+17] # 以e为底的对数 print(np.log(a)) # [2.30258509 2.99573227 3.40119738 3.68887945] # 以10为底的对数 print(np.log10(a)) # [1. 1.30103 1.47712125 1.60205999]
求和
matrix = numpy.array([[1,2,3], [4,5,6], [7,8,9]]) print(matrix.sum())# 45 print(matrix.sum(1))# 按每行求和 # [ 6 15 24] print(matrix.sum(0))# 按每列求和 # [12 15 18]
sum(1) 是 sum(axis=1)) 的缩写，1表示按照 x轴方向求和，0表示按照y轴方向求和
矩阵乘法
A*B A.dot(B) np.dot(A,B)
import numpy as np A = np.array([[1, 1], [0, 1]]) B = np.array([[2, 0], [3, 4]]) print(A*B) print(A.dot(B)) # A*B print(np.dot(A,B)) # A*B # [[2 0] # [0 4]]
矩阵求均值
numpy.mean(a, axis, dtype, out，keepdims )
mean()函数功能：求取均值
经常操作的参数为axis，以m * n矩阵举例：
- axis 不设置值，对 m*n 个数求均值，返回一个实数
- axis = 0：压缩行，垂直方向，对各列求均值，返回 1* n 矩阵
- axis =1 ：压缩列，水平方向，对各行求均值，返回 m *1 矩阵
a = np.array([[1, 2], [3, 4]]) print(a) # array([[1, 2], # [3, 4]]) print(np.mean(a)) # 2.5 print(np.mean(a, axis=0)) # axis=0，计算每一列的均值 # array([ 2., 3.]) print(np.mean(a, axis=1)) # 计算每一行的均值 # array([ 1.5, 3.5])
numpy的函数有两种用法，以mean为例，第一a=np.mean(array);第二a=array.mean()
np.max() np.min() np.ptp()： 返回一个数组中最大值/最小值/极差
np.argmax() np.argmin()： 返回一个数组中最大/最小元素的下标
np.maximum() np.minimum()： 将两个同维数组中对应元素中最大/最小元素构成一个新的数组
np.median(array) 中位数，如果为偶数，返回中间两个元素的平均值。
np.std(array) 标准差
复制的区别
地址复制：通过 b = a 复制 a 的值，b 与 a 指向同一地址，改变 b 同时也改变 a。
1 a = np.arange(12) 2 b = a 3 print(a is b) 4 5 print(a.shape) 6 print(b.shape) 7 b.shape = (3,4) 8 print(a.shape) 9 print(b.shape) 10 11 # True 12 # (12,) 13 # (12,) 14 # (3, 4) 15 # (3, 4)
复制值：通过 a.view() 仅复制值，当对 c 值进行改变会改变 a 的对应的值，而改变 c 的 shape 不改变 a 的 shape，只有值会变，矩阵结构不变
1 a = np.arange(12)# [ 0 1 2 3 4 5 6 7 8 9 10 11] 2 c = a.view() 3 print(c is a) 4 5 c.shape = (2,6) 6 c[0,0] = 9999 7 8 print(a) 9 print(c) 10 11 # False 12 # [9999 1 2 3 4 5 6 7 8 9 10 11] 13 # [[9999 1 2 3 4 5] 14 # [ 6 7 8 9 10 11]]
完全拷贝：a.copy() 进行的完整的拷贝，产生一份完全相同的独立的复制
1 a = np.arange(12) 2 c = a.copy() 3 print(c is a) 4 5 c.shape = 2,6 6 c[0,0] = 9999 7 8 print(a) 9 print(c) 10 11 # False 12 # [ 0 1 2 3 4 5 6 7 8 9 10 11] 13 # [[9999 1 2 3 4 5] 14 # [ 6 7 8 9 10 11]]
numpy.random 随机模块
numpy的random模块用于生成随机数，
numpy.random.random(D0, d1,....dN)
生成[0, 1)之间指定结构的随机数
np.random.random((2, 3)) # [[ 0.86166627, 0.37756207, 0.94265883], # [ 0.9768257 , 0.96915312, 0.33495431]]
numpy.random.rand(D0, d1, ..., DN)：
给定形状的数组，并在[0,1)之间
np.random.rand(3,2) # array([[ 0.14022471, 0.96360618], #random # [ 0.37601032, 0.25528411], #random # [ 0.49313049, 0.94909878]]) #random
numpy.random.randn(D0, d1, ..., DN)：
从“标准正态分布”返回一个或多个样本
a = np.random.randn(2, 4) # [[-0.9115162 -1.32887292 -1.02910152 0.8023337 ] # [-1.14456771 -0.53251834 -1.75465906 -1.25668335]]
numpy.random.normal（loc = 0.0，scale = 1.0，size = None）
从正态分布中中抽取随机样本，其中均值为loc，方差为scale，size是形状
s = np.random.normal(0,1, 1000) print(s.shape) # (1000,)
numpy.random.randint(low, high=None, size=None, dtype='l')：
生成[low,high)的随机整数，取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。
a = np.random.randint(5, size=(2, 4)) # array([[4, 0, 2, 1], # [3, 2, 2, 0]]) b = np.random.randint(5,10,size=(2, 4)) # [[6 9 8 5] # [8 8 6 8]]
numpy.random.uniform(low=0.0, high=1.0, size=None)
功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.
参数：
- low: 采样下界，float类型，默认值为0；
- high: 采样上界，float类型，默认值为1；
- size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出m*n*k个样本，缺省时输出1个值。
numpy.random.choice(a, size=None, replace=True, p=None)
从序列中获取元素，若a为整数，元素取值为np.range(a)中随机数；若a为数组，取值为a数组元素中随机元素。
size：表示从a中随机选取size个数replace： 抽样之后是否放回，False不放回抽样，True放回抽样。p：表示每个元素被抽取的概率，如果没有指定，a中所有元素被选取的概率是相等的。
numpy.random.shuffle(x)：
对X进行重排序，如果X为多维数组，只沿第一条轴洗牌(横轴)，输出为None。
arr = np.arange(9).reshape((3, 3)) # [[0 1 2] # [3 4 5] # [6 7 8]] np.random.shuffle(arr) # [[3 4 5] # [0 1 2] # [6 7 8]]
numpy.random.seed(seed=None) # 种下随机种子，使得生成的随机数相同
读取文件
numpy.gerfromtxt()用于读取文件，其中传入的参数依次是：
1、需要读取txt文件位置，此处文件与程序位于同一目录下
2、delimiter 分割的标记
3、dtype 转换类型，如果文件中既有文本类型也有数字类型，就先转成文本类型
import numpy world_alcohol = numpy.genfromtxt("world_alcohol.txt", delimiter=",",dtype=str) print(type(world_alcohol)) print(world_alcohol) print(help(numpy.genfromtxt))
help(numpy.genformtxt)用于查看帮助文档
np.loadtxt("path", delimiter=",", usecols=(1, 3), unpack=False, dtype='u10, f8', converters={1:func})
参数：
- "path"：读取csv文件路径
- '../aapl.csv'：文件路径
- delimiter=','：分隔符
- usecols=(1, 3)：读取1、3两列 （下标从0开始）
- unpack=False：是否按列拆包
- dtype='U10, f8'：制定返回每一列数组中元素的类型
- converters={1:func} ：转换器函数字典
import numpy as np import datetime as dt # 日期转换函数 def dmy2ymd(dmy): # 把“日月年”字符串转换成“年月日”字符串 dmy = str(dmy, encoding='utf-8') time = dt.datetime.strptime(dmy, '%d-%m-%Y').date() t = time.strftime('%Y-%m-%d') return t dates, opening_prices,highest_prices, lowest_prices, closeing_prices = np.loadtxt( './aapl.csv', # 文件路径 delimiter=',', # 分隔符 usecols=(1, 3, 4, 5, 6), # 读取1、3、4、5、6两列 （下标从0开始） unpack=True, dtype='M8[D], f8, f8, f8, f8', # 制定返回每一列数组中元素的类型 converters={1:dmy2ymd}) print(dates) # 表格中数据 28-01-2011 # 转换后数据 2011-01-28
如果不设置dtype，t=time.strtime()换成t=time.weekday()得到的结果是[4. 0. 1. 2. 3. 4. 0. 1.]
卷积
a = [1 2 3 4 5] 原数组
b = [8 7 6] 卷积核数组 kernel
使用b作为卷积核对a数组做一维卷积运算的过程如下：
44 65 86 有效卷积 (valid) 23 44 65 86 59 同维卷积 (same) 8 23 44 65 86 59 30 完全卷积 (full) 0 0 1 2 3 4 5 0 0 6 7 8 6 7 8 6 7 8 6 7 8 6 7 8 6 7 8 6 7 8 c = np.convolve(a, b, '卷积类型')
使用卷积函数numpy.convolve(a, b, 卷积类型)实现5日均线
sma52 = np.convolve( closing_prices, np.ones(5) / 5, 'valid') mp.plot(dates[4:], sma52, c='limegreen', alpha=0.5, linewidth=6, label='SMA-5(2)')
加权卷积
使用卷积函数numpy.convolve(a, b, 卷积类型)实现加权5日均线
# 实现加权卷积 # 通过指数函数，寻求一组卷积核 kernel = np.exp(np.linspace(-1, 0, 5)) kernel = kernel[::-1] kernel /= kernel.sum() print(kernel) sma53 = np.convolve(closing_prices, kernel, 'valid') mp.plot(dates[4:], sma53, label='SMA-5(3)', linewidth=1, color='violet', linestyle='-')
时间数据处理
import numpy as np import datetime as dt # 转换器函数：将日-月-年格式的日期字符串转换为星期 def dmy2wdays(dmy): dmy = str(dmy, encoding='utf-8') d = dt.datetime.strptime(dmy, '%d-%m-%Y').date() wday = d.weekday() return wday # 加载文件，第一列 wdays时间数据 wdays, closing_prices = np.loadtxt('./aapl.csv', delimiter=',', usecols=(1), unpack=True, converters={1: dmy2wdays}) print(wdays) # [4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 1. 2. 3. 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4.]
日月年转年月日
def dmy2ymd(dmy): # 把日月年字符串转为年月日字符串 print(dmy) # b'11-03-2011' dmy = str(dmy, encoding='utf-8') d = dt.datetime.strptime(dmy, '%d-%m-%Y').date() ymd = d.strftime('%Y-%m-%d') print(ymd) # 2011-03-11 return ymd