数据预处理—NumPy

1. 基础

# 引入
import numpy as np

1.1 一维数组对象

def py_sum():
    # 原生方式计算A**2+B**3
    a = [0, 1, 2, 3, 4]
    b = [9, 8, 7, 6, 5]
    c = []
    for i in range(len(a)):
        c.append(a[i] ** 2 + b[i] ** 3)
    return c

def np_sum():
    # numpy库计算A**2+B**3
    a = np.array([0, 1, 2, 3, 4])
    b = np.array([9, 8, 7, 6, 5])
    c = a ** 2 + b ** 3
    return c

• 数组对象可以去掉元素间运算所需的循环，使一维向量更像单个数据。
• 设置专门的数组对象，经过优化，可以提升这类应用的运算速度。
• 数组对象采用相同的数据类型，有助于节省运算和存储空间。

1.2 N维数组对象

ndarray 是一个多维数组对象,由两部分构成：

• 实际的数据
• 描述这些数据的元数据(数据维度、数据类型等)

In [5]: a=np.array([[0,1,2,3,4],
                    [9,8,7,6,5]])

In [6]: a
Out[6]: 
array([[0, 1, 2, 3, 4],
       [9, 8, 7, 6, 5]])

In [7]: print(a)
[[0 1 2 3 4]
 [9 8 7 6 5]]

• np.array()生成一个ndarray数组
• ndarray在程序中的别名是：array
• np.array()输出成目形式，元素由空格分割。

2. 属性

轴(axis)：保存数据的维度

秩(rank)：轴的数量

ndarray 数组一般要求所有元素类型相同（同质），数组下标从0开始。

In [7]: a=np.array([[0,1,2,3,4],
                    [9,8,7,6,5]])

In [8]: a.ndim # 秩，即轴的数量或维度的数量
Out[8]: 2

In [9]: a.shape # ndarray对象的尺度,对于矩阵,n行m列
Out[9]: (2, 5)

In [10]: a.size # ndarray对象元素的个数，相当于.shape中n*m的值
Out[10]: 10

In [11]: a.dtype # darray对象的元素类型
Out[11]: dtype('int32')

In [12]: a.itemsize # ndarray对象中每个元素的大小，以字节为单位
Out[12]: 4

非同质情况

In [20]: b
Out[18]: array([list([0, 1, 2, 3, 4]), list([9, 8, 7, 6])], dtype=object)

In [21]: b.shape
Out[21]: (2,)

In [22]: b.dtype
Out[22]: dtype('O') # object类型

In [23]: b.itemsize
Out[23]: 8

In [24]: b.size
Out[24]: 2

3. 数据类型

类型	说明
bool	布尔类型，True或False
intc	与C语言中的int类型一致，一般是int32或int64
intp	用于索引的整数，与C语言中ssize_t一致,int32或int64
int8	字节长度的整数，取值:[-128,127]
int16	16位长度的整数，取值:[-32768,32767]
int32	32位长度的整数，取值:[-2^31,2^31-1]
int64	64位长度的整数，取值:[-2^63,2^63-1]
uint8	8位无符号整数,取值:[0,255]
uint16	16位无符号整数,取值:[0,65535]
uint32	32位无符号整数,取值:[0,2^32-1]
uint64	64位无符号整数，取值:[0,2^64-1]
float16	16位半精度浮点数:1位符号位，5位指数，10位尾数
float32	32位半精度浮点数:1位符号位，8位指数，23位尾数
float64	64位半精度浮点数:1位符号位，11位指数，52位尾数
complex64	复数类型，实部和虚部都是32位浮点数
complex128	复数类型，实部和虚部都是64位浮点数

• 科学计算涉及数据较多,对存储和性能都有较高要求。
• 对元素类型精细定义,有助于NumPy合理使用存储空间并优化性能。
• 对元素类型精细定义,有助于程序员对程序规模有合理评估。

4. 数组创建

4.1 从列表、元组等创建

In [27]: a = np.array([0,1,2,3]) # 列表

In [28]: print(a)
[0 1 2 3]

In [29]: a = np.array((4,5,6,7)) # 元组

In [30]: print(a)
[4 5 6 7]

In [33]: a = np.array([(4,5,6,7),[0,1,2,3]]) #混合

In [34]: print(a)
[[4 5 6 7]
 [0 1 2 3]]

4.2 用NumPy中函数创建

# 生成1维数组，类似于range()
In [40]: np.arange(5)
Out[40]: array([0, 1, 2, 3, 4])

# 参数shape表示形状，是一个元组。生成一个全1数组
In [41]: np.ones((3,5))
Out[41]: 
array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

# 生成全0数组
In [43]: np.zeros((3,5))
Out[43]: 
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

#参数：形状，内容
In [47]: np.full((2,5),6)
Out[47]: 
array([[6, 6, 6, 6, 6],
       [6, 6, 6, 6, 6]])

#生成对角矩阵
In [49]: np.eye(3)
Out[49]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

ones、zeros、eye默认生成浮点数的数组，可加参数指定类型，比如dtype=np.int32

In [52]: a = np.full((2,3),8)

# 根据a的形状创建全1数组
In [53]: np.ones_like(a)
Out[53]: 
array([[1, 1, 1],
       [1, 1, 1]])

# 根据a的形状创建全0数组
In [54]: np.zeros_like(a)
Out[54]: 
array([[0, 0, 0],
       [0, 0, 0]])

# 根据a的形状创建全3数组
In [55]: np.full_like(a,3)
Out[55]: 
array([[3, 3, 3],
       [3, 3, 3]])

# 根据起止数据，等间距填充数据，形成数组
In [56]: np.linspace(1,10,3)
Out[56]: array([ 1. ,  5.5, 10. ])
    
#不包括结尾数据
In [57]: np.linspace(1,10,3,endpoint=False)
Out[57]: array([1., 4., 7.])

In [72]: a = np.full((2,3),1)
In [73]: b = np.full((2,3),2)
# 合并，一维直接合并，多维列数得一致
In [74]: np.concatenate((a,b))
Out[74]: 
array([[1, 1, 1],
       [1, 1, 1],
       [2, 2, 2],
       [2, 2, 2]])

• 从字节流(raw bytes)中创建ndarray数组。
• 从文件中读取特定格式，创建ndarray数组。

5.数组变换

5.1 维度变换

# a初始内容
In [82]: a
Out[82]: 
array([[4, 5, 6, 7],
       [0, 1, 2, 3],
       [8, 9, 8, 9]])

#调用flatten降维，返回新数组
In [90]: a.flatten()
Out[90]: array([4, 5, 6, 7, 0, 1, 2, 3, 8, 9, 8, 9])

# a和原来一致
In [83]: a
Out[83]: 
array([[4, 5, 6, 7],
       [0, 1, 2, 3],
       [8, 9, 8, 9]])


# 调用reshape，返回变换后的新数组
In [84]: a.reshape(4,3)
Out[84]: 
array([[4, 5, 6],
       [7, 0, 1],
       [2, 3, 8],
       [9, 8, 9]])

#a和原来一致，没变
In [85]: a
Out[85]: 
array([[4, 5, 6, 7],
       [0, 1, 2, 3],
       [8, 9, 8, 9]])

# 调用resize
In [86]: a.resize((2,6))

#a变为新数组
In [87]: a
Out[87]: 
array([[4, 5, 6, 7, 0, 1],
       [2, 3, 8, 9, 8, 9]])

5.2 类型变换

# a初始值
In [94]: a
Out[94]: 
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])
        
# 类型转换为浮点型。不加参数，会拷贝一份原数组
In [95]: b=a.astype(np.float)

In [96]: b
Out[96]: 
array([[[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]],

       [[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]]])

# 数组转变为list列表
In [97]: b.tolist()
Out[97]: 
[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]],
 [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]]

6. 数组操作

• 索引：获取数组中特定位置元素的过程
• 切片：获取数组元素子集的过程

6.1 一维

In [98]: a = np.array([9,8,7,6,5])

In [99]: a[2] # 索引
Out[99]: 7

In [100]: a[1:4:2] # 切片，下标[1,4)中步长为2的元素
Out[100]: array([8, 6])

6.2 多维

In [102]: a
Out[102]: 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

In [104]: a[0,2,3] # 索引。使用下标
Out[104]: 11

In [105]: a[-1,-2,-3] # 索引。倒数第1组，倒数第2行，倒数第3列
Out[105]: 17

"""
a:b, 下标为[a,b)
a:b:c, 下标为[a,b)中，步长为2的元素
"""
In [106]: a[:,1,-3] # 切片。第一维不限制，第二维下标为1，第三维倒数第3个
Out[106]: array([ 5, 17])

In [107]: a[:, 1:3, : ] # 切片。第一、三维不限制，第二维下标为[1,3)
Out[107]: 
array([[[ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23]]])

In [108]: a[:, :, ::2] # 切片。第一、二维不限制，第三维取步长为2
Out[108]: 
array([[[ 0,  2],
        [ 4,  6],
        [ 8, 10]],

       [[12, 14],
        [16, 18],
        [20, 22]]])

7. 数组运算

数组与标量之间的运算作用于数组的每一个元素

7.1 一元函数

函数	说明
np.mean(x)	所有元素的平均值
np.abs(x) np.fabs(x)	计算数组各元素的绝对值
np.sqrt(x)	计算数组各元素的平方根
np.square(x)	计算数组各元素的平方
np.log(x) np.log10(x) np.log2(x)	计算数组各元素的自然对数、10底对数和2底对数
np.ceil(x) np.floor(x)	计算数组各元素的ceiling值（向上取整）或floor值（向下取整）
np.rint( x)	计算数组各元素的四舍五入值（py3中，等于最接近的整数，如果到两边距离相同，则等于偶数）
np.modf(x)	将数组各元素的小数和整数部分以两个独立数组形式返回
np.cos(x) np.cosh(x) np.sin(x) np.sinh(x)np.tan(x) np.tanh(x)	计算数组各元素的普通型和双曲型三角函数
np. exp(x)	计算数组各元素的指数值
np.sign(x)	计算数组各元素的符号值，1(+)，0，-1(-)

7.2 二元函数

函数	说明
+ - * / **	两个数组各元素进行对应运算
np.maximum( x,y) np.fmax() np.minimum( x,y) np.fmin()	元素级的最大值/最小值计算
np.mod(x,y)	元素级的模运算
np.copysign(x,y)	将数组y中各元素值的符号赋值给数组x对应元素
> < >= <= == !=	算术比较，产生布尔型数组

8. 读写文件

8.1 CSV文件

np.savetxt (frame, array, fmt= '%.18e ', delimiter=None)

将数组内容写入文件

• frame：文件、字符串或产生器，可以是.gz或.bz2的压缩文件
• array：存入文件的数组
• fmt:写入文件的格式，例如∶%d %.2f %.18e
• delimiter：分割字符串，默认是任何空格

In [144]: a
Out[144]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])
In [147]: np.savetxt('C:\\Users\\K\\Desktop\\a.csv', a, fmt='%d', delimiter=',')
"""
文件内容：
    0,1,2,3,4
    5,6,7,8,9
    10,11,12,13,14
    15,16,17,18,19
"""

In [149]: np.savetxt('C:\\Users\\K\\Desktop\\b.csv', a, fmt='%.2f')
"""
文件内容：
    0.00 1.00 2.00 3.00 4.00
    5.00 6.00 7.00 8.00 9.00
    10.00 11.00 12.00 13.00 14.00
    15.00 16.00 17.00 18.00 19.00
"""

np.loadtxt(frame, dtype=np.float, delimiter=None, unpack=False)

将文件内容读入数组

• frame：文件、字符串或产生器，可以是.gz或.bz2的压缩文件
• dtype：数据类型，可选，默认浮点
• delimiter：分割字符串，默认是任何空格
• unpack：如果True，读入属性将分别写入不同变量

"""
文件内容：
    0,1,2,3,4
    5,6,7,8,9
    10,11,12,13,14
    15,16,17,18,19
"""

In [151]: b = np.loadtxt('C:\\Users\\K\\Desktop\\a.csv', delimiter=',')

In [152]: b
Out[152]: 
array([[ 0.,  1.,  2.,  3.,  4.],
       [ 5.,  6.,  7.,  8.,  9.],
       [10., 11., 12., 13., 14.],
       [15., 16., 17., 18., 19.]])

In [153]: b = np.loadtxt('C:\\Users\\K\\Desktop\\a.csv', delimiter=',', dtype=np.int)

In [154]: b
Out[154]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

csv只能有效存储一维和二维数组

np.savetxt()和np.loadtxt()只能有效存取一维和二维数组

8.1 任意维度数据

array_name.tofile( frame, sep='', format='%s ')

• a：本库生成的数组
• frame：文件、字符串
• sep：数据分割字符串，如果是空串，写入文件为二进制
• format：写入数据的格式

存储时，将多维数据转化为一维

In [155]: a
Out[155]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

In [157]: a.tofile("C:\\Users\\K\\Desktop\\a.dat", sep=',', format='%d')
# 文件中：0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19    

In [158]: a.tofile("C:\\Users\\K\\Desktop\\b.dat", format='%d')
# 文件中乱码（二进制文件）

np.fromfile( frame, dtype=float, count=-1, sep=' ')

• frame：文件、字符串
• dtype：读取的数据奕型
• count：读入元素个数，-1表示读入整个文件
• sep：数据分割字符串，如果是空串，写入文件为二进制

读取结果为一维，可通过reshape转化为多维

# 两个文件中数据，见上个代码块

In [160]: np.fromfile("C:\\Users\\K\\Desktop\\a.dat", dtype=np.float, count=-1, sep=',').reshape(4,5)

Out[160]: 
array([[ 0.,  1.,  2.,  3.,  4.],
       [ 5.,  6.,  7.,  8.,  9.],
       [10., 11., 12., 13., 14.],
       [15., 16., 17., 18., 19.]])

In [162]: np.fromfile("C:\\Users\\K\\Desktop\\b.dat", dtype=np.int, count=-1).reshape(4,5)

Out[162]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

• 该方法需要读取时知道存入文件时数组的维度和元素类型
• a.tofile()和np .fromFile()需要配合使用
• 可以通过元数据文件来存储额外信息

8.3 Numpy 便捷存取

np.save( fname, array)或np.savez(fname，array)

• fname：文件名，以.npy为扩展名，压缩扩展名为.npz
• array：数组变量

np.load( fname)

• fname：文件名，以.npy为扩展名，压缩扩展名为.npz

In [163]: a
Out[163]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

In [164]: np.save("C:\\Users\\K\\Desktop\\a.npy", a)

In [165]: np.load("C:\\Users\\K\\Desktop\\a.npy")
Out[165]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

9. 随机数

函数	说明
rand(d0,d1, . . , dn)	d0-dn为形状，内容为[0,1)浮点数，均匀分布
randn(d0,d1, . . ,dn)	d0-dn为形状，内容为标准正态分布
randint(low, high, shape)	shape为元组表形状，范围是[low,high)
seed(s)	随机数种子，s是给定的种子值，相同种子形成相同随机数
shuffle(a)	根据数组a的第1轴（最外维）进行随排列，改变数组x
permutation(a)	根据数组a的第1轴产生一个新的乱序数组，不改变数组x
choice(a, size, replace, p])	从一维数组a中以概率p抽取元素，形成size形状新数组，replace表示是否可以重用元素，默认为False
uniform( low, high, size)	产生具有均匀分布的数组, low起始值, high结束值, size形状
normal( loc, scale, size)	产生具有正态分布的数组,loc均值,scale标准差,size形状
poisson(lam,size)	产生具有泊松分布的数组,lam随机事件发生率,size形状

In [169]: a
Out[169]: 
array([[[148, 156, 101, 131],
        [126, 108, 160, 166],
        [152, 111, 130, 129]],

       [[169, 151, 125, 106],
        [129, 121, 142, 143],
        [188, 117, 172, 160]],

       [[104, 194, 185, 182],
        [183, 182, 114, 149],
        [102, 148, 146, 152]]])

In [170]: np.random.permutation(a) # shuffle(a)作用一样，但改变原数组
Out[170]: 
array([[[169, 151, 125, 106],
        [129, 121, 142, 143],
        [188, 117, 172, 160]],

       [[148, 156, 101, 131],
        [126, 108, 160, 166],
        [152, 111, 130, 129]],

       [[104, 194, 185, 182],
        [183, 182, 114, 149],
        [102, 148, 146, 152]]])

"""
m为一维数组
(3,2)为目标数组形状
replace=False，默认值，表示不重复使用m中的数据
p表示每个数据被取概率
"""
np.rendom.choice(m, (3,2), replace=False, p=m/np.sum(b))

10. 统计

In [173]: a
Out[173]: 
array([[[ 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],
        [32, 33, 34, 35]]])
"""
轴的概念：
注意：3维数组，想象成正方体更好理解
第0轴，第1轴，第2轴……
对第0轴操作：按第一个维度分开，依次操作
	按第一个维度，可分为3组，组间求和，结果为：
    	[36, 39, 42, 45],
        [48, 51, 54, 57],
        [60, 63, 66, 69]
对第1轴操作：按第二个维度分开，依次操作
	按第二个维度，每组可分为3行，行间求和，结果为：
		[12, 15, 18, 21],
        [48, 51, 54, 57],
        [84, 87, 90, 93]
	15：第一组，第二列之和（行之间求和）
对第2轴操作：按第三个维度分开，依次操作
	按第三个维度，每组可分为3列，列间求和，结果为：
		[  6,  22,  38],
        [ 54,  70,  86],
        [102, 118, 134]
	22：第一组，第二行之和（列之间求和）
"""

函数	说明
sum(a, axis=None)	根据给定轴axis计算数组a相关元素之和，axis整数或元组
mean(a,axis=None)	根据给定轴axis计算数组a相关元素的期望，axis整数或元组
average(a,axis=None,weights=None)	根据给定轴axis计算数组a相关元素的加权平均值
std(a,axis=None)	根据给定轴axis计算数组a相关元素的标准差
var(a, axis=None)	根据给定轴axis计算数组a相关元素的方差
min(a) max( a)	计算数组a中元素的最小值、最大值
argmin(a) argmax( a)	计算数组a中元素最小值、最大值的降一维后下标
unravel_index(index,shape)	根据shape将一维下标index转换成多维下标
ptp(a)	计算数组a中元素最大值与最小值的差
median( a)	计算数组a中元素的中位数（中值）

In [178]: a
Out[178]: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [179]: np.average(a)
Out[179]: 7.0

In [180]: np.average(a, axis=0)
Out[180]: array([5., 6., 7., 8., 9.])

In [181]: np.average(a, axis=0, weights=[10,5,1])
Out[181]: array([2.1875, 3.1875, 4.1875, 5.1875, 6.1875])
# 4.1875 = (2*10+7*5+12*1)/(10+5+1)

In [185]: a
Out[185]: 
array([[ 0, 20,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [186]: np.max(a) # 最大值
Out[186]: 20

In [187]: np.argmax(a) # 化为1维后，最大值下标
Out[187]: 1

In [188]: np.unravel_index(np.argmax(a), a.shape) # 一维下标转化为多维下标
Out[188]: (0, 1)

11. 梯度

函数	说明
np.gradient(a)	计算数组a中元素的梯度，当a为多维时，返回每个维度梯度

In [190]: a
Out[190]: 
array([[ 0, 20,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [191]: np.gradient(a)
Out[191]: 
[array([[  5. , -14. ,   5. ,   5. ,   5. ],
        [  5. ,  -4.5,   5. ,   5. ,   5. ],
        [  5. ,   5. ,   5. ,   5. ,   5. ]]),
 array([[20. ,  1. , -8.5,  1. ,  1. ],
        [ 1. ,  1. ,  1. ,  1. ,  1. ],
        [ 1. ,  1. ,  1. ,  1. ,  1. ]])]

"""
第一个array，行之间（列方向）的梯度
	-4.5 = (11 - 20) / 2 非边界：下一个值与上一个值的差，除以二
	-14. = (6 - 20) / 1 边界：下一个值与当前值的差，除以1
第一个array，列之间（行方向）的梯度
"""