Python数据分析之numpy数组全解析

1 什么是numpy

numpy是一个在Python中作科学计算的基础库，重在数值计算，也是大部分Python科学计算库的基础库，多用于大型、多维数据上执行数值计算。

在NumPy 中，最重要的对象是称为 ndarray 的N维数组类型，它是描述相同类型的元素集合，numpy全部功能几乎都以ndarray为核心展开。ndarray 中的每一个元素都是数据类型对象(dtype)的对象。ndarray 中的每一个元素在内存中使用相同大小的块

2 numpy数组建立

建立Numpy数组通常有三种方法：

（1）经过传入可待跌对象建立，我将之称为基本方法

（2）使用Numpy内部功能函数，内部方法

（3）使用特殊的库函数，特殊方法

2.1 基本方法：np.array()

基本方法是经过给numpy提供的一些函数中传入可迭代对象来建立数组，这种方法一般是在已知全部元素的状况下使用。numpy中实现这种功能的函数包括：np.array()、np.arange()、np.line()，：

>>> np.array([0, 1, 2, 3, 4]) # 接收一个list做为参数
array([0, 1, 2, 3, 4])
>>> np.array([[11, 12, 13],[21, 22, 23]]) # 建立一个2*3的数组
array([[11, 12, 13],
[21, 22, 23]])
>>> np.array((0, 1, 2, 3, 4)) # 接收一个tuple做为参数
array([0, 1, 2, 3, 4])
np.array()方法能够在建立数组的同时指定数据类型：
>>> np.array([0, 1, 2, 3, 4], dtype=float)
array([0., 1., 2., 3., 4.])

甚至还能够接受range()返回的可迭代对象做为参数：

>>> np.array(range(5))
array([0, 1, 2, 3, 4])
>>> np.array(range(10, 20, 2))
array([10, 12, 14, 16, 18])

2.2 通用方法：np.ones()、np.zeros()、np.eye()

通用方法指的是numpy中提供的arange()、ones()、zeros()、eye()、full()等方法，这些方法能够按照某种规则生成一个数组，并不须要传入已知的可迭代对象。

（1）np.arange()

上面咱们将range()函数结果传递给np.array()，np.arange()实现的就是这个功能，因此说，np.arange()就是numpy中的range()方法。

>>> np.arange(5)
array([0, 1, 2, 3, 4])
>>> np.arange(10, 20, 2)
array([10, 12, 14, 16, 18])

（2）np.linspace()

np.linspace()方法以等间距的形式对给定的两数进行划分来建立数组：

>>> np.linspace(10, 20, 5) # 将10到20间的数等距取5个
array([10. , 12.5, 15. , 17.5, 20. ])

（3）np.ones()

建立一个元素值全为1的数组，接收一个list或者tuple做为参数

>>> np.ones([2]) # 建立一个一维数组
array([1., 1.])
>>> np.ones([2, 2]) # 建立一个2维数组
array([[1., 1.],
[1., 1.]])
>>> np.ones([2, 2, 2])
array([[[1., 1.],
[1., 1.]],
 
[[1., 1.],
[1., 1.]]])

（4）np.zeros()

建立一个元素值全为0的数组，接收一个list或者tuple做为参数

>>> np.zeros([3])
array([0., 0., 0.])
>>> np.zeros([3, 3])
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])

（5）np.random.random()

建立一个元素为0到1之间随机数的数组，接收一个list或者tuple做为参数：

>>> np.random.random((3, 3))
array([[0.19414645, 0.2306415 , 0.08072019],
[0.68814308, 0.48019088, 0.61438206],
[0.5361477 , 0.33779769, 0.38549407]])

既然有random()方法，那么就会有randint()方法，也就是取随机整数的方法，不过这个randint()方法参数形式更random()不太同样，具体请看下面实例：

>>> np.random.randint(1, 10, 3) # 从1到10之间随机取3个整数建立数组
array([6, 4, 6])

（6）np.eye()

建立一个从左上角到右下角的对角线上全为1，其他元素全为0的数组（单位矩阵）。注意，np.eye()的参数可再也不是list或者tuple了。

>>> np.eye(3, 3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

(7) np.full()

np.full()函数能够建立一个填充给定数值的数组，第一个参数是定义数组形状的list或tuple，第2个参数是须要填充的数值：

>>> np.full((2, 3), 3) # 建立一个2*3的数组，全部元素都填充3
array([[3, 3, 3],
[3, 3, 3]])

2.3 读取外部数据

numpy也支持从外部读取数据来建立数组，例如从硬盘中读取csv、txt等文件来建立数组。np.genfromtxt()是numpy中读取文件的一个方法，例如在当前目录下有一个data.csv文件，文件内容为：

id,height,length

1,100,101

2,200,230

3,300,350

经过numpy读取：

>>> np.genfromtxt('data.csv',delimiter=',',skip_header=1)
array([[ 1., 100., 101.],
[ 2., 200., 230.],
[ 3., 300., 350.]])

读取外部数据的方法不止np.genfromtxt()，还有np.load(等，但numpy读取外部数据的应用状况其实并很少，这里再也不细说。

 3 numpy中数组的数据类型

做为一个强大的科学计算库，numpy中支持的数据类型远不止Python原生的几种数据类型。以下所示为numpy中支持的数据类型：

数据类型	描述
bool_	布尔（True或False），存储为一个字节
int_	默认整数类型（与Clong相同；一般是int64或int32）
INTC	与Cint（一般为int32或int64）相同
INTP	用于索引的整数（与Cssize_t相同；一般是int32或int64）
INT8	字节（-128至127）
INT16	整数（-32768至32767）
INT32	整数（-2147483648至2147483647）
Int64的	整数（-9223372036854775808至9223372036854775807）
UINT8	无符号整数（0到255）
UINT16	无符号整数（0到65535）
UINT32	无符号整数（0到4294967295）
UINT64	无符号整数（0到18446744073709551615）
float_	float64的简写。
float16	半精度浮点：符号位，5位指数，10位尾数
FLOAT32	单精度浮点数：符号位，8位指数，23位尾数
float64	双精度浮点：符号位，11位指数，52位尾数
complex_	complex128的简写。
complex64	复数，由两个32位浮点数（实部和虚部）
complex128	复数，由两个64位浮点数（实部和虚部）

这些数据类型能够经过如np.bool_、np.float16等形式来调用，上文中提到过，建立数组时能够指定数据类型：

>>> a = np.array([0, 1, 0, 1], dtype=np.bool_)
>>> a
array([False, True, False, True])

能够经过numpy数组自带的dtype属性来查看数组的数据类型：

>>> a.dtype
dtype('bool')

为何输出的类型是bool而不是bool_呢？由于numpy中后缀带下划线“_”的数据类型指向的就是Python原生的数据类型，也就是说，np.bool_与Python中的bool数据类型等效，np.float_与Python中的float类型等效。

当一个数组已经被建立，可是想要改变其数据类型，那就能够经过np.asdtype()方法：

>>> a.astype(np.int)
array([0, 1, 0, 1])
>>> a = np.random.random((2,2))
>>> a
array([[0.02914317, 0.645534 ],
[0.61839509, 0.64155607]])
>>> a.dtype
dtype('float64')
>>> a.astype(np.float16)
array([[0.02914, 0.6455 ],
[0.618 , 0.6416 ]], dtype=float16)
>>> a.dtype
dtype('float64')

4 numpy中数组的形状

numpy中数组使用与存放多维数据，因此，所谓数组的形状指的就是数据的维度大小，以及每一维度元素个数。咱们能够经过数组自带的shape属性来查看形状信息：

>>> a = np.array([[2, 3, 4], [5, 6, 7]])
>>> a
array([[2, 3, 4],
[5, 6, 7]])
>>> a.shape # 查看形状属性
(2, 3)

能够看到，查看形状属性时返回的是一个元组，元素的长度表明数组的维度，元组每个属性表明对应的维度的元素个数，（2，3）就表示第一个维度元素个数是2（两行），第二个维度长度是3（3列）。

在数组建立以后，数组的形状也是能够改变的。改变数组的形状经过数组的reshape()方法：

>>> a = np.ones((2, 12))
>>> a
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.]])
>>> a.shape
(2, 12)
>>> b = a.reshape(2, 3, 4)
>>> b
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.]]])
>>> b.shape
(2, 3, 4)
>>> b = a.reshape((2,3,4)) # 元组做为参数
>>> b
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.]]])
>>> b.shape
(2, 3, 4)

能够看到，np.reshape()方法能够同时传入多个描述形状的数字，也能够传入一个数组，固然，若是将形状改变为一维数组时，必须传入的是元组。另外须要注意，传入reshape方法的多个参数的乘积必须与改变前数组总长度相等，不然会报错。

numpy数组中专门提供了一个方法加你个数组转换为觉得数组，那就是flatten()方法，这个方法在执行数组运算是很是有用：

>>> a = np.ones((2, 3))
>>> b = a.flatten()
>>> b
array([1., 1., 1., 1., 1., 1.])
>>> b.shape
(6,)

5 索引与切片

对数据使用时，不可避免要进行索引和切片，numpy在这一方面不可谓不强大。numpy数组中全部的索引都是从0开始的，咱们能够根据索引来精确取数据。

5.1 按索引取值

下面全部实例都已下方数组a来展开：

>>> a = np.arange(36).reshape((4, 9))
>>> a
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]])

（1）取一行

>>> a[1] # 取第二行数据
array([ 9, 10, 11, 12, 13, 14, 15, 16, 17])

（2）取连续多行数据

>>> a[:2] # 取前两行数据
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8],
[ 9, 10, 11, 12, 13, 14, 15, 16, 17]])

也能够加上步长：

>>> a[::2] # 每隔一行取一次
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8],
[18, 19, 20, 21, 22, 23, 24, 25, 26]])
>>> a[1:] # 取第2行后面全部行
array([[ 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）取不连续多行数据

>>> a[[0,-1]] # 取第一行和最后一行
>>> a[[0,-1]]
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8],
[27, 28, 29, 30, 31, 32, 33, 34, 35]])

能够看到，对numpy根据索引进行取值的方法与Python中list索引取值方法相似，都是经过方括号里面传入索引取值，当须要对多维进行索引时，每一位数据之间用逗号隔开。

（4）取一列

>>> a[:,1] # 取第2列
array([ 1, 10, 19, 28])

（5）取连续多列

>>> a[:,1:3] # 取第2列到第3列
array([[ 1, 2],
[10, 11],
[19, 20],
[28, 29]])

（6）取不连续多列

>>> a[:,[0,3]] # 取第1列和第4列
array([[ 0, 3],
[ 9, 12],
[18, 21],
[27, 30]]))

（7）取连续多行多列

>>> a[1:3:,1:3] # 取第二、3行中的第二、3列
array([[10, 11],
[19, 20]])

（8）取多个不连续位置数据

看到这里你应该也明白了取行、取列的规律了，若是取不连续的多行多列呢？例如取第一、3行与第二、4列，你可能认为是a[[0, 2], [1, 3]]，咱们来看看：

>>> a[[0, 2], [1, 3]]
array([ 1, 21])

可见，返回的并非预期的数据，而是第1行第2列、第3行第4列的数据，也就是（0,1）和（2,3）位置的数据。

从而咱们能够得出结论，若是取第3行中第3列、第5列，第4行中第1列、第7列数据方法以下：

>>> a[[2,2,3,3],[2,4,0,6]] # 第3行中第3列、第5列，第4行中第1列、第7列数据
array([20, 22, 27, 33])

（9）取单个数据

>>> b = a[3,3]
>>> b
30
>>> type(b) # 取单个类型是返回的就是一个确切的numpy类型数值
<class 'numpy.int64'>

5.2 bool索引

（1）bool索引取值

numpy中提供了一些通用函数来实现经过bool条件判断实现按条件取值，使用这些通用方法，与使用对应的符号时等效的，符号与numpy通用方法对应关系以下：

运算符	对应的通用函数
==	np.equal
!=	np.not_equal
<	np.less
<=	np.less_equal
>	np.greater
>=	np.greater_equal

咱们经过实例感觉一下：

>>> a = np.arange(24).reshape((4,6))
>>> a
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]])
>>> b = a<5 # bool索引选取
>>> b
array([[ True, True, True, True, True, False],
[False, False, False, False, False, False],
[False, False, False, False, False, False],
[False, False, False, False, False, False]])

能够看到，在元素值小于5的位置上值为True，不知足条件的为False。

也可使用通用函数实现：

>>> b = np.less(a,5) # 通用函数选取
>>> b
array([[ True, True, True, True, True, False],
[False, False, False, False, False, False],
[False, False, False, False, False, False],
[False, False, False, False, False, False]])

对bool索引选取出来的结果全是True或者False，可能不是你想要的，能够进一步使用：

>>> a[b]
array([0, 1, 2, 3, 4])

因此咱们能够直接刷选值：

>>> a[a<5]
array([0, 1, 2, 3, 4])

（2）三目元算

numpy中提供了一个where()方法来实现三目运算。where()方法接受三个参数，第一个参数是判断条件，第二个参数时时判断条件为真时数组中知足条件的元素将要替换的值，第三个参数是判断调价为假时不知足条件元素将要替换的值。

例如，将数组中全部知足元素值小于5的数值替换为0，不知足的元素值替换为1：

>>> a = np.arange(24).reshape((4,6))
>>> a
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]])
>>> np.where(a<5, 0, 1) # 三目运算
array([[0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1]])

6 numpy中赋值、视图、深复制

（1）赋值

当对numpy数组进行赋值时，只是对同一个对象新建了一个引用，并非创建新的对象，因此赋值先后的变量彻底是同一对象，对其中一个引用修改时，全部引用都会生效：

>>> a = np.arange(12)
>>> b = a # 赋值
>>> a is b
True
>>> b.shape = (3, 4)
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])

（2）视图（切片、浅复制）

numpy中容许不一样数组间共享数据，这种机制在numpy中称为视图，对numpy数组的切片和浅复制都是经过视图实现的。若是数组B是数组A的视图(view)，则称A为B的base(除非A也是视图)。视图数组中的数据实际上保存在base数组中。

>>> a = np.arange(12)
>>> b = a.view() # 使用视图
>>> a is b
False
>>> b
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b.shape = (3, 4) # 改变b的形状
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> b[0] = 0
>>> a
array([ 0, 0, 0, 0, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b
array([[ 0, 0, 0, 0],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])

从上面代码中咱们能够发现，a和b是不一样的两个数组，改变b的形状对a不会有影响，可是改变b的数据以后，a的数据也会发现改变，说明a与b是共享数据的。

 再来探索一些切片：

>>> a = np.arange(12)
>>> b = a[:] # 切片
>>> a is b
False
>>> b.shape = (3, 4)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> b[0] = 0
>>> a
array([ 0, 0, 0, 0, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b
array([[ 0, 0, 0, 0],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])

果真，切片效果与视图一致。

（3）深复制

深复制经过数组自带的copy()方法实现，深复制产生的数组与原数组时彻底不一样的两个数组对象，彻底享有独立的内存空间，全部操做都不会相互影响。

>>> a = np.arange(12)
>>> b = a.copy()
>>> a is b
False
>>> b.shape = (3, 4)
>>> b[0] = 0
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> b
array([[ 0, 0, 0, 0],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])