Python基础数据处理库-NumPy
NumPy是Python做数据处理的底层库，是高性能科学计算和数据分析的基础，比如著名的Python机器学习库SKlearn就需要NumPy的支持。掌握NumPy的基础数据处理能力是利用Python做数据运算及机器学习的基础。
- NumPy（或简称NP）的主要功能特性如下：
- 具有数组（ndarray）能力，这是一个具有矢量算术运算和复杂广播的快速且节省空间的多维数组。
- 用于对整租数据进行快速运算的标准数学函数（代替循环实现）。
- 可用于读写数据以及操作内存映射文件。
- 具有线性代数、随机数生成以及傅里叶交换功能。
- 可集成C、C++、Fortran等语言，提供了简单易用的C API，很容易将数据传递给低级语言编写的外部库，也能以NumPy数组的形式将数据返回给Python。
NumPy本身没有多么高级的数据分析能力，但理解NumPy数组以及面向数组的操作会有利于理解之后讲到的Pandas（Python的另一个数据分析库），也有助于自己利用Python编写机器学习或深度学习算法，甚至也是日后应用Sklearn的基础。
对于NumPy而言，它的实际应用会侧重于以下几点：
- 数据读取或生成，尽管它本身这方面的能力不强，但偶尔也可以使用。
- 数据合并、清洗、过滤、转换等数组操作。
- 常用的数组算法应用，例如排序、唯一化、集合运算等。
- 数据描述性统计以及数据聚合或摘要运算。
- 用于易购数据的合并、连接运算的数据对齐和关系型数据运算。
- 利用数组表达式代替条件逻辑表达式（if-else）。
NumPy基础
NumPy操作的对象是N维数组，称为ndarray，大多数情况下都叫做数组。我们先来看一个N维数组：
- >>> import NumPy as np
- >>> data = np.arange(15).reshape(3, 5)
- >>> print (data)
- [[ 0, 1, 2, 3, 4],
- [ 5, 6, 7, 8, 9],
- [10, 11, 12, 13, 14]]
先忽略上面的代码语法，我们只看data，它就是一个3行5列的数组对象。既然是对象，一定有属性，NumPy中数组的属性常用属性如下：
ndarray.ndim。数组轴的个数，在python的世界中，轴的个数被称作秩。如上面我们构建的数组data的轴的个数为2。轴的概念和平面图形里面的X轴、Y轴是一个概念，2个轴代表该数组是二维数据。
- >>> print (data.ndim)
- 2
ndarray.shape。数组的矩阵形状。这是一个指示数组在每个维度上大小的整数元组。如上面的data数组，每个轴的矩阵形状都是3行5列。
- >>> print (data.shape)
- (3, 5)
ndarray.size。数组元素的总个数，等于shape属性中元组元素的乘积。如上面的data数组中元素的总个数为15。
- >>> print (data.size)
- 15
ndarray.dtype。一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型。如上面的data数组的对象类型为int32.
- >>> print (data.dtype)
- int32
除此以外，数组ndarray还有其他属性，例如用于表示每个元素字节数的itemsize，白哦是实际数组缓冲区的data属性等，但这些都应用不多。
NumPy的数据类型。不要为了记忆NumPy的dtypes而烦恼，尤其当你是一个新用户。通常只需要关心普通的数据类型即可（浮点、复数、整形、布尔型、字符串）。 当你需要更多的控制数据如何存储到内存和磁盘，特别是大的数据集时，知道你所控制的存储类型是很有必要的。
ndarray的数据类型语法为：
- #指定数组类型为int16
- >>> int16_arr = np.array( [1, 2, 3], dtype = np.int16)
- >>> print int16_arr
- [1, 2, 3]
- #指定数组类型为float64
- >>> float64_arr = np.array( [1, 2, 3], dtype = np.float64)
- >>> print float64_arr
- [ 1. , 2. , 3. ]
完整的ndarray类型列表如下：
| 类型 | 类型码 | 描述 |
|---|---|---|
| int8, uint8 | i1, u1 | 有符号和无符号8位（1字节）整数类型 |
| int16, uint16 | i2, u2 | 有符号和无符号16位整数类型 |
| int32, uint32 | i4, u4 | 有符号和无符号32位整数类型 |
| int64, uint64 | i8, u8 | 有符号和无符号64位整数类型 |
| float16 | f2 | 半精度浮点类型 |
| float32 | f4 or f | 标准精度浮点。与C的 float 兼容 |
| float64, float128 | f8 or d | 标准双精度浮点。与C的 double 和Python 的 folat 对象兼容 |
| float128 | f16 or g | 扩展精度浮点 |
| complex64, complex128, complex256 | c8, c16, c32 | 分别使用两个32，64，128位浮点表示的复数 |
| bool | ? | 布尔值，存储 True 和 False |
| object | O | Python对象类型 |
| string_ | S | 定长字符窜类型（每字符一字节）。例如，为了生成长度为10的字符窜，使用 ‘S10’ |
| unicode_ | f16 or g | 扩展精度浮点（字节书依赖平台）。同 string_ 有相同的语义规范（例如：U10 ） |
导入NumPy库
首先确保你已经安装了NumPy，如果尚未安装请参考 NumPy下载安装指南。导入NumPy到Python中。
- >>> import NumPy as np
- >>> from NumPy import *
这两种方式都可以导入NumPy到python中使用，建议读者使用第一种以养成良好的代码习惯。本文默认的都以第一种作为引用规则。
创建NumPy数组
创建NumPy数组有几种形式。
第一种，假如已经有了数组表达式或值，这通常来源于前期数据导入代码或者其他库，在这里只需要将其转换成NumPy数组即可。如下列代码，a为列表，通过np.array()将其转换为NumPy的ndarray类型。
- >>> a = [[1,2,3],[4,5,6]
- >>> a2 = np.array(a)
- >>> print (type(a2))
- NumPy.ndarray
注意：
- array函数支持Python创建的列表和元素。
- array()内的值一定是元素或列表，而不能是其他值。
- array()转换后的对象类型会根据默认为实际可用值，也可手动指定。
当然，很多场景下被转换的变量可能不是上述“现成” 的矩阵，这时候需要我们“手动”进行转换。如下列代码，原始被转换的变量是一个1行15列的数组，这时候我们需要根据实际需求将其转换为3行5列的数组，通过reshape函数即可实现。
- >>> import NumPy as np
- >>> a3 = np.arange(15).reshape(3, 5)
- >>> print a3
- [[ 0, 1, 2, 3, 4],
- [ 5, 6, 7, 8, 9],
- [10, 11, 12, 13, 14]]
第二种，某些时候数组里面的值可能是未知的，但矩阵的大小其实是已经确定的，比如我们了解到接下来的运算中需要一个3行4列的矩阵，那么就可以利用NumPy创建矩阵。当然，矩阵的值可能为空，也可以是某些特定值，这取决于创建的方法。
方法一：使用zeros创建全为0的矩阵。如下代码创建了一个3行4列且值全为0的二维矩阵。
- >>> a4 = np.zeros((3,4))
- >>> print a4
- [[0., 0., 0., 0.],
- [0., 0., 0., 0.],
- [0., 0., 0., 0.]]
方法二：使用ones创建全为1的矩阵。如下代码创建了一个三维，每个维都是3行4列的矩阵。
- >>> a5 = np.ones((3,4))
- >>> print a5
- [[[ 1, 1, 1, 1],
- [ 1, 1, 1, 1],
- [ 1, 1, 1, 1]],
- [[ 1, 1, 1, 1],
- [ 1, 1, 1, 1],
- [ 1, 1, 1, 1]]]
方法三：使用empty创建一个内容随机并且依赖与内存状态的数组。如下代码创建了一个2行3列的矩阵，但值为随机产生。这种创建方法一般很少使用。
- >>> a6 = np.ones((2,3))
- >>> print a6
- [[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260],
- [ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]]
默认情况下，创建的矩阵对象类型是float64，也可以通过dtype创建时指定对象类型。
方法四：使用arange或者linspace创建一个新的数值序列数组。
- #使用arange创建从10到30，步长为5的数值序列，其中开始数值10以及步长5都是可选设置
- >>> a7 = np.arange( 10, 30, 5 )
- >>> print a7
- [10, 15, 20, 25]
- #使用linspace创建从0到2，一共9个数值的序列
- >>> a8 = np.linspace( 0, 2, 9 )
- >>> print a8
- [ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ]
arange函数和linspace都可以创建固定起止数值的数组，但二者的区别在于arange通过控制步长确定数组个数，而linspace直接设置个数（而自动设置步长）。
以上时常用创建数组的方法，更多细节函数请见：array, zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, rand, randn, fromfunction, fromfile
简单的NumPy数组运算
数组间简单运算
- >>> arr1 = np.array([[1., 2., 3.], [4., 5., 6.]])
- >>> arr2 = np.array([[2., 3., 4.], [5., 6., 7.]])
- #数组加法
- >>> print arr1 + arr2
- [[3, 5, 7],
- [9, 11, 13]]
- #数组减法
- >>> print arr1 - arr2
- [[-1, -1, -1],
- [-1, -1, -1]]
- #数组乘法
- >>> print arr1 * arr2
- [[2, 6, 12],
- [20, 30, 42]]
- #数组除法
- >>> print arr1 / arr2
- [[0.5, 0.6667, 0.75],
- [0.8, 0.8333, 0.8571]]
数组与数值运算
数组与数值运算的基本方法与数组间运算语法相同，在此只举一个例子，其余参加数组间语法。
- >>> arr1 = np.array([[1., 2., 3.], [4., 5., 6.]])
- #数组与数值加法
- >>> print (arr1 + 2)
- [[3 , 4, 5],
- [6 , 7, 8]]
- #数组与数值减法
- >>> print (arr1 - 2)
- [[-1, 0, 1],
- [2, 3, 4]]
- #数组与数值乘法
- >>> print (arr1 * 2)
- [[2, 4, 6],
- [8, 10, 12]]
- #数组与数值除法
- >>> print (arr1 / 2)
- [[0.5, 1, 1.5],
- [2, 2.5, 3]
注意：数组与数值间的运算不仅可以有整数，小数也可以有。那么问题来了，如果是arr1 * 0.5结果会是什么呢？会有什么规律？这个交给大家来发掘吧。（提示：将结果对照上述的四则运算）
数组函数运算
通用函数( 又称ufunc)是一个在ndarrays的数据上进行基于元素的操作的函数。NumPy提供常见的数学函数如sin、cos和exp，也提供简单的统计函数如mean, std, vary等。实际上，之前我们已经在使用一些通用函数了，例如生成有序序列的arange、生成全为1的zeros函数等。 这部分重点介绍的是NumnPy的常用来做计算的函数。
- >>> arr = np.arange(4)
- >>> print arr
- [0, 1, 2, 3]
- #求arr的绝对值
- >>> print np.abs(arr)
- [0, 1, 2, 3]
- #求arr的平方根
- >>> print np.sqrt(arr)
- [0, 1, 1.414, 1.732]
- #求arr的平方
- >>> print np.square(arr)
- [0, 1, 4, 9]
- #求arr的指数
- >>> print np.exp(arr)
- [1, 2.728, 7.389, 20.086]
- #求arr以e为底的对数
- >>> print np.log(arr)
- [-inf, 0, 0.693, 1.099]
- #求arr每个元素的正负号
- >>> print np.sign(arr)
- [0, 1, 1, 1]
- #求arr每个元素的cos值
- >>> print np.cos(arr)
- [1, 0.540, -0.416, -0.990]
以下提供了相对完整的常用数组运算函数的列表。更多细节，请访问NumPy Example List了解更多信息。
| 函数 | 描述 |
|---|---|
| abs, fabs | 计算基于元素的整形，浮点或复数的绝对值。fabs对于没有复数数据的快速版本 |
| sqrt | 计算每个元素的平方根。等价于 arr ** 0.5 |
| square | 计算每个元素的平方。等价于 arr ** 2 |
| exp | 计算每个元素的指数。 |
| log, log10, log2, log1p | 自然对数（基于e），基于10的对数，基于2的对数和 log(1 + x) |
| sign | 计算每个元素的符号：1(positive)，0(zero)， -1(negative) |
| ceil | 计算每个元素的天花板，即大于或等于每个元素的最小值 |
| floor | 计算每个元素的地板，即小于或等于每个元素的最大值 |
| rint | 圆整每个元素到最近的整数，保留dtype |
| modf | 分别返回分数和整数部分的数组 |
| isnan | 返回布尔数组标识哪些元素是 NaN （不是一个数） |
| isfinite, isinf | 分别返回布尔数组标识哪些元素是有限的（non-inf, non-NaN）或无限的 |
| cos, cosh, sin sinh, tan, tanh | regular 和 hyperbolic 三角函数 |
| arccos, arccosh, arcsin, arcsinh, arctan, arctanh | 反三角函数 |
| logical_not | 计算基于元素的非x的真值。等价于 -arr |
数组统计运算
数据统计是Python做数据分析的重要步骤，NumPy提供了常用的求和、均值、方差、标准差、最大最小值、累积等函数。以下以sum求和函数为例解释使用方法，其余函数用法类似。
- >>> arr = np.arange(6).reshape(2,3)
- >>> print arr
- [[0, 1, 2],
- [3, 4, 5]]
- #求arr的全部（行和列）的总和
- >>> print np.sum(arr)
- 15
- #大多数情况下，我们会指定求某列或某行的和
- #求基于列的和
- >>> print np.sum(arr, axis = 1)
- [3, 12]
- #求基于行的和
- >>> print np.sum(arr, axis = 0)
- [3, 5, 7]
以下列表是常用的NumPy的统计函数。更多细节，请访问NumPy Example List了解更多信息。
| sum | 对数组的所有或一个轴向上的元素求和。零长度的数组的和为灵。 |
| mean | 算术平均值。灵长度的数组的均值为NaN。 |
| average | 对数组的做加权平均。 |
| std, var | 标准差和方差，有可选的调整自由度（默认值为n）。 |
| min, max | 最大值和最小值 |
| argmin, argmax | 索引最小和最大元素。 |
| cumsum | 从0元素开始的累计和。 |
| cumprod | 从1元素开始的累计乘。 |
| diff | 返回一个由相邻数组元素的差值构成的数组,有点类似于微积分中的微分。 |
注意：本部分是使用Python做机器学习等场景下经常使用的函数，每个函数的用法都需要牢记。
NumPy数组预处理
数据预处理是在进行数据挖掘、探索、学习之前的必要步骤，NumPy提供了较多的数据预处理功能。例如转置、索引、切片、数组间函数处理、逻辑条件表达式、排序、集合等。
NumPy数组转置
数组转置是将数据进行矩阵“对换”的一种方式，NunPy提供了transpose函数和.T属性两种是实现形式。
- #一维数组转置
- >>> arr = np.arange(6)
- >>> print arr
- [0, 1, 2, 3, 4, 5]
- >>> print np.transpose(arr)
- [0, 1, 2, 3, 4, 5]#一维还是一维...
- #二维数组转置
- >>> arr = np.arange(6).reshape((2,3))
- >>> print arr
- [[0, 1, 2],
- [3, 4, 5]]
- >>> print np.transpose(arr)
- [[0,3],
- [1,4],
- [3,5]]
- #三维数组的转置
- >>> 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 np.transpose(arr)
- [[[0, 12],
- [4, 16],
- [8, 20]],
- [[1, 13],
- [5, 17],
- [9, 21]],
- [[2, 14],
- [6, 18],
- [10, 22]],
- [[3, 15],
- [7, 19],
- [11, 23]]]
- #当数组>=三维之后，我们可能希望按照特定规则来转置，transpose 可以接受用于指定转置的坐标轴号码的元组
- >>> print np.transpose(arr, (1,0,2))
- [[[ 0, 1, 2, 3],
- [ 12, 13, 14, 15]],
- [[ 4, 5, 6, 7],
- [ 16, 17, 18, 19]],
- [[ 8, 9, 10, 11],
- [ 20, 21, 22, 23]]]
对于是否指定转化规则，具体来看三维的变化：原始数据的“三维”是(2,3,4)，不指定转换规则后的“三维”是(4,3,2)，而指定规则后的三维则是按照我们指定的规则，将其一维和二维进行调换。
- #原始三维数据规则
- >>> print (arr.shape)
- (2, 3, 4)
- #不指定转换规则
- >>> print (np.transpose(arr).shape)
- (4, 3, 2)
- #指定转换规则
- >>> print (np.transpose(arr,(1, 0, 2)).shape)
- (3, 2, 4)
ndarray的T属性，用法则比较简单，只需要在数组后跟.T即可。.T属性实际是转置里面的特殊情况，即不指定转置规则的默认规则。
- #一维数组转置
- >>> arr = np.arange(6)
- >>> print arr
- [0, 1, 2, 3, 4, 5]
- >>> print arr.T
- [0, 1, 2, 3, 4, 5]#一维还是一维…
- #二维数组转置
- >>> arr = np.arange(6).reshape((2,3))
- >>> print arr
- [[0, 1, 2],
- [3, 4, 5]]
- >>> print arr.T
- [[0,3],
- [1,4],
- [3,5]]
- #三维数组的转置
- >>> 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.T
- [[[0, 12],
- [4, 16],
- [8, 20]],
- [[1, 13],
- [5, 17],
- [9, 21]],
- [[2, 14],
- [6, 18],
- [10, 22]],
- [[3, 15],
- [7, 19],
- [11, 23]]]
当某些情况下，你可能只需要转换其中的两个轴，除了可以使用transpose指定轴以外（当然需要每个轴都指定顺便，只是调整其中的部分而已），还可以使用swapreaxes。
- >>> 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.swapaxes(1, 0)
- [[[ 0, 1, 2, 3],
- [ 12, 13, 14, 15]],
- [[ 4, 5, 6, 7],
- [ 16, 17, 18, 19]],
- [[ 8, 9, 10, 11],
- [ 20, 21, 22, 23]]]
数据集划分为训练集、测试集和验证集
很多时候我们会将数据集划分为训练集和测试集两部分，但在很多场景中需要将数据集分为训练集、测试集和验证集三部分。sklearn没有提供直接将数据集分为3种（含3种）以上的方法，我们可以使用numpy的split方法划分数据集。split参数如下：
split(ary, indices_or_sections, axis=0)
- ary：要划分的原始数据集
- indices_or_sections：要划分的数据集数量或自定义索引分区。如果直接使用整数型数值设置分区数量，则按照设置的值做等比例划分；如果设置一个一维的数组，那么将按照设置的数组的索引值做区分划分边界。
- axis：要划分数据集的坐标轴，默认是0
数据集分割示例：将创建的新数据集通过平均等分和指定分割索引值的方式分为3份
- import numpy as np # 导入库
- x = np.arange(72).reshape((24,3)) # 创建一个24行3列的新数组
- train_set1, test_sets1, val_sets1 = np.split(x, 3) # 将数组平均分为3份
- train_set2, test_sets2, val_sets2 = np.split(x, [int(0.6*x.shape[0]), int(0.9*x.shape[0])]) # 60%训练集,30%测试集,10%验证集
- print ('record of each set - equal arrays: ')
- print ('train_set1: %d, test_sets1: %d, val_sets1: %d'%(train_set1.shape[0], test_sets1.shape[0], val_sets1.shape[0]))
- print (40*'-')
- print ('record of each set - % arrays: ')
- print ('train_set2: %d, test_sets2: %d, val_sets2: %d'%(train_set2.shape[0], test_sets2.shape[0], val_sets2.shape[0]))
上述代码执行后，返回如下结果：
- record of each set - equal arrays:
- train_set1: 8, test_sets1: 8, val_sets1: 8
- ----------------------------------------
- record of each set - % arrays:
- train_set2: 14, test_sets2: 7, val_sets2: 3
使用numpy的hstack和vstack做矩阵合并
hstack是将矩阵以列为单位做合并，与之相对应的是以行为单位做合并的方法vstack，这两个方法的参数都是一个元组。
假如b = a = np.arange(6).reshape(2,3)，a和b都是2行3列矩阵：
当使用numpy.hstack((a,b))做列合并时，合并后的矩阵是2行6列，此时该方法等价于numpy.concatenate((a,b), axis=1)
当使用numpy.vstack((a,b)) 做行合并时，合并后的矩阵是4行3列，此时该方法等价于numpy.concatenate((a,b), axis=0)
将多行转换为一行
将多行数据组转换为一行数组（例如将图片的灰度值展平），可以使用reshape(1,n)，也可以直接使用ravel或flatten函数。
例如:a=np.arange(12).reshape(3,4)，使用a.ravel()或a.flatten()都可以得到结果array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])。
二者的区别在于flatten函数会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图。
使用Numpy的loadtxt、load、fromfile读取数据
Numpy读取数据的方法包括loadtxt、load和fromfile三种方法
| 方法 | 描述 | 返回数据 |
| loadtxt | 从txt文本中读取数据 | 从文件中读取的数组 |
| load | 使用Numpy的 load方法可以读取Numpy专用的二进制数据文件，从npy、npz或pickled文件加载数组或pickled对象 | 从数据文件中读取的数组、元组、字典等 |
| fromfile | 使用Numpy的fromfile方法可以读取简单的文本文件数据以及二进制数据 | 从文件中读取的数据 |
使用loadtxt方法读取数据文件
Numpy可以读取txt格式的数据文件，数据通常都是1维或2维。
语法
- loadtxt(fname, dtype=<type 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)
参数
- fname：文件或字符串，必填，这里指定要读取的文件名称或字符串，支持压缩的数据文件，包括gz和bz格式。
- dtype：数据类型，选填，默认为float（64位双精度浮点数）。Numpy常用类型如下表：
| 类型 | 描述 |
| bool | 用一位存储的布尔类型（值为TRUE或FALSE） |
| inti | 由所在平台决定其精度的整数 |
| int8 | 整数，大小为一个字节，范围：-128 ~ 127 |
| int16 | 整数，范围：-32768 ~ 32767 |
| int32 | 整数，范围：-2**31 ~ 2*31-1 |
| int64 | 整数，范围：-2**31 ~ 2*31-1 |
| uint8 | 无符号整数，0 ~ 255 |
| uint16 | 无符号整数：0 ~ 65535 |
| uint32 | 无符号整数： 0 ~ 2**32-1 |
| uint64 | 无符号整数： 0 ~ 2**64-1 |
| float16 | 半精度浮点数： 16位 ，正负号1位，指数5位，精度10位 |
| float32 | 单精度浮点数：32位，正负号1位，指数8位，精度32位 |
| float64 / float | 双精度浮点数： 64位，正负号1位，指数11位，精度52位 |
| complex64 | 复数，分别用于两个32位浮点数表示实部和虚部 |
| complex128 / complex | 复数，分别用两个64位浮点数表示实部和虚部 |
备注：其中2**32代表2的32次方，其他表示方法类似。
- comments：字符串或字符串组成的列表，用来表示注释字符集开始的标志，选填，默认为#。
- delimiter：字符串，选填，用来分割多个列的分隔符，例如逗号、TAB符，默认值为空格。
- converters：字典，选填，用来将特定列的数据转换为字典中对应的函数的浮点型数据，例如通过将空值转换为0，默认为空。
- skiprows：跳过特定行数据，选填，用来跳过特定前N条记录，例如跳过前1行（可能是标题或注释），默认为0。
- usecols：元组，选填，用来指定要读取数据的列，第一列为0，以此类推，例如(1,3,5)，默认为空。
- unpack：布尔型，选填，用来指定是否转置数组，如果为真则转置，默认为False。
ndmin：整数型，选填，用来指定返回的数组至少包含特定维度的数组，值域为0/1/2，默认为0。
返回:从文件中读取的数组
使用load方法读取数据文件
使用Numpy的 load方法可以读取Numpy专用的二进制数据文件，从npy、npz或pickled文件加载数组或pickled对象，该文件通常基于Numpy的save或savez等方法产生
语法
- load(file, mmap_mode=None, allow_pickle=True, fix_imports=True, encoding='ASCII')
参数
- file：类文件对象或字符串格式，要读取的文件或字符串，必填，类文件对象需要支持seek()和read()方法。
- mmap_mode：内存映射模式，值域为：None、'r+'、'r'、'w+'、'c'，选填。
- allow_pickle：布尔型，选填，是否允许加载存储在npy文件中的pickled对象数组，默认值为True。
- fix_imports：布尔型，选填，如果为True，pickle将尝试将旧的Python 2名称映射到Python 3中使用的新名称，仅在Python 2生成的pickled文件加载Python 3时才有用，默认值为True。
- encoding：字符串，读取Python 2字符串时使用何种编码，选填。
返回:从数据文件中读取的数组、元组、字典等。
使用fromfile方法
使用Numpy的fromfile方法可以读取简单的文本文件数据以及二进制数据。通常情况下，该方法读取的数据来源于Numpy的tofile方法，即通过Numpy的tofile方法将特定数据保存为文件（默认为二进制数据文件，无论文件扩展名如何定义），然后通过fromfile方法读取该二进制文件。
语法
- fromfile(file, dtype=float, count=-1, sep='')
参数
- file：文件或字符串。
- dtype：数据类型，具体参照“表2-3 Numpy数据类型”。注意数据类型要与文件存储的类型一致。
- count：整数型，读取数据的数量，-1意味着读取所有数据。
- sep：字符串，如果file是一个文本文件，那么该值就是数据间的分隔符。如果为空（""）则意味着file是一个二进制文件，多个空格将按照一个空格处理。
返回 从文件中读取的数据。