NumPy 总结

简介

数据分析最重要的包是 NumPy 和 Pandas 。

• NumPy 是 Python 数值计算的扩展。
• NumPy 是 SciPy 、Pandas 等数据科学的基础库。
  它提供的数据结构比 Python 自身提供的数据结构更有效，速度快。NumPy 提供的数据结构是 Python 进行数据分析的基础。

NumPy 运算效率比 Python 的 list 快很多，为啥快呢？因为底层实现的原理不同，列表 list 在内存中时分散存储的，NumPy 数组在内存中连续均匀的存储。

在 NumPy 中有两个重要的对象。

• ndarray（N-dimensional array object）解决多维数组问题。
• ufunc universal function object）处理数组的函数。

ndarray

NumPy 操作的主要对象是同类型的多维数组。在 NumPy 数组中，维数称为秩（rank）维数称为秩（rank），一维数组的秩为 1，二维数组的秩为2，以此类推。在 NumPy 中，每一个线性的数组称为一个（axes），其实秩就是描述轴的数量。

创建数组

可以使用 array 函数从常规的 python 列表或元组中创建数组。得到的数组类型是从 python 列表中的元素推导出来的。

In [39]: a = np.array((1,2,3))

In [40]: a
Out[40]: array([1, 2, 3])

In [41]: a = np.array(((1,2,3),(4,5,6)))

In [42]: a
Out[42]:
array([[1, 2, 3],
       [4, 5, 6]])

结合起来也是可以的：

In [43]: a = np.array([(1,2,3),(4,5,6)])

In [44]: a
Out[44]:
array([[1, 2, 3],
       [4, 5, 6]])

import numpy as np
a = np.array((1,2,3))
b = np.array(([1,2,3],[4,5,6]))
print(a.shape,b.shape)

(3,) (2, 3)

函数 shape 用于查看数组的大小。

数组的类型也是可以在创建的时候就指定：

In [2]: a = np.array([[1,2,3],[4,5,6]],dtype=complex)

In [3]: a
Out[3]:
array([[1.+0.j, 2.+0.j, 3.+0.j],
       [4.+0.j, 5.+0.j, 6.+0.j]])

complex 是复数的意思。
ufunc 运算ufunc 是 universal function 的缩写，是不是听起来就感觉功能非常强大？确如其名，它能对数组中每个元素进行函数操作。NumPy 中很多 ufunc 函数计算速度非常快，因为都是采用 C 语言实现的。

连续数组的创建

NumPy 可以很方便地创建连续数组，比如我使用 arange 或 linspace 函数进行创建：

x1 = np.arange(1,11,2)
x2 = np.linspace(1,9,5)
x1,x2

(array([1, 3, 5, 7, 9]), array([1., 3., 5., 7., 9.]))

np.arange 和 np.linspace 起到的作用是一样的，都是创建等差数组。

• arange() 类似内置函数 range()，通过指定初始值、终值、步长来创建等差数列的一维数组，默认是不包括终值的。
• linspace 是 linear space (线性空间) 的缩写，代表线性等分向量的含义。linspace() 通过指定初始值、终值、元素个数来创建等差数列的一维数组，默认是包括终值的。

算术运算

通过 NumPy 可以自由地创建等差数组，同时也可以进行加、减、乘、除、求 n 次方和取余数。

x1 = np.arange(1,11,2)
x2 = np.linspace(1,9,5)

print('加:',np.add(x1,x2))
print('减:',np.subtract(x1,x2))
print('乘:',np.multiply(x1,x2))
print('除:',np.divide(x1,x2))
print('求 n 次方:',np.power(x1,x2))
print('取余数:',np.remainder(x1,x2))


加: [ 2.  6. 10. 14. 18.]
减: [0. 0. 0. 0. 0.]
乘: [ 1.  9. 25. 49. 81.]
除: [1. 1. 1. 1. 1.]
求 n 次方: [1.00000000e+00 2.70000000e+01 3.12500000e+03 8.23543000e+05
 3.87420489e+08]
取余数: [0. 0. 0. 0. 0.]

• 在 n 次方中，x2 数组中的元素实际上是次方的次数，x1 数组的元素为基数。
• 在取余函数里，还可以用 np.mod(x1, x2)，结果是一样的。

统计函数

如果你想要对一堆数据有更清晰的认识，就需要对这些数据进行描述性的统计分析，比如了解这些数据中的最大值、最小值、平均值，是否符合正态分布，方差、标准差多少等等。它们可以让你更清楚地对这组数据有认知。

计数组 / 矩阵中的最大值函数 amax()，最小值函数 amin()

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

1
[1 2 3]
[1 4 7]
9
[7 8 9]
[3 6 9]

• amin() 用于计算数组中的元素沿指定轴的最小值。
• 对于一个二维数组 a，amin(a) 指的是数组中全部元素的最小值，amin(a,0) 是延着 axis=0 轴的最小值，axis=0 轴是把元素看成了 [1,2,3], [4,5,6], [7,8,9] 三个元素，所以最小值为 [1,2,3]，amin(a,1) 是延着 axis=1 轴的最小值，axis=1 轴是把元素看成了 [1,4,7], [2,5,8], [3,6,9] 三个元素，所以最小值为 [1,4,7]。同理 amax() 是计算数组中元素沿指定轴的最大值。

统计最大值与最小值之差 ptp()

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

8
[6 6 6]
[2 2 2]

对于相同的数组 a，np.ptp(a) 可以统计数组中最大值与最小值的差，即 9-1=8。同样 ptp(a,0) 统计的是沿着 axis=0 轴的最大值与最小值之差，即 7-1=6（当然 8-2=6,9-3=6，第三行减去第一行的 ptp 差均为 6），ptp(a,1) 统计的是沿着 axis=1 轴的最大值与最小值之差，即 3-1=2（当然 6-4=2, 9-7=2，即第三列与第一列的 ptp 差均为 2）。

统计数组的百分位数 percentile()

a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(np.percentile(a,50))
print(np.percentile(a,50,axis=0))
print(np.percentile(a,50,axis=1))

5.0
[4. 5. 6.]
[2. 5. 8.]

percentile() 代表着第 p 个百分位数，这里 p 的取值范围是 0-100，如果 p=0，那么就是求最小值，如果 p=50 就是求平均值，如果 p=100 就是求最大值。同样你也可以求得在 axis=0 和 axis=1 两个轴上的 p% 的百分位数。

统计数组中的中位数 median()、平均数 mean()

a = np.array([[1,2,3],[4,5,6],[7,8,9]])
# 中位数
print(np.median(a))
print(np.median(a,axis=0))
print(np.median(a,axis=1))
# 平均数
print(np.mean(a))
print(np.mean(a,axis=0))
print(np.mean(a,axis=1))

5.0
[4. 5. 6.]
[2. 5. 8.]
5.0
[4. 5. 6.]
[2. 5. 8.]

统计数组中的加权平均值 average()

a = np.array([1,2,3,4])
wts = np.array([1,2,3,4])
print(np.average(a))
print(np.average(a,weights=wts))

2.5
3.0

average() 函数可以求加权平均，加权平均的意思就是每个元素可以设置个权重，默认情况下每个元素的权重是相同的，所以 np.average(a)=(1+2+3+4)/4=2.5，你也可以指定权重数组 wts=[1,2,3,4]，这样加权平均 np.average(a,weights=wts)=(11+22+33+44)/(1+2+3+4)=3.0。

统计数组中的标准差 std()、方差 var()

a = np.array([1,2,3,4])
print(np.std(a)) # 标准差
print(np.var(a)) # 方差

2.5
3.0

方差的计算是指每个数值与平均值之差的平方求和的平均值，即 mean((x - x.mean())** 2)。标准差是方差的算术平方根。在数学意义上，代表的是一组数据离平均值的分散程度。所以 np.var(a)=1.25, np.std(a)=1.118033988749895。

NumPy 排序

排序是算法中使用频率最高的一种，也是在数据分析工作中常用的方法，计算机专业的同学会在大学期间的算法课中学习。

那么这些排序算法在 NumPy 中实现起来其实非常简单，一条语句就可以搞定。这里你可以使用 sort 函数，sort(a, axis=-1, kind=‘quicksort’, order=None)，默认情况下使用的是快速排序；在 kind 里，可以指定 quicksort、mergesort、heapsort 分别表示快速排序、合并排序、堆排序。同样 axis 默认是 -1，即沿着数组的最后一个轴进行排序，也可以取不同的 axis 轴，或者 axis=None 代表采用扁平化的方式作为一个向量进行排序。另外 order 字段，对于结构化的数组可以指定按照某个字段进行排序。

import numpy as np

a = np.array([[4,1,7],[5,2,8]])
print(np.sort(a))
print(np.sort(a,axis=None))
print(np.sort(a,axis=0))
print(np.sort(a,axis=1))


[[1 4 7]
 [2 5 8]]

[1 2 4 5 7 8]

[[4 1 7]
 [5 2 8]]

[[1 4 7]
 [2 5 8]]

axis=0 是跨行（纵向），axis=1 是跨列（横向）

---

通常，数组的元素最初是未知的，但它的大小是已知的。因此，NumPy提供了几个函数来创建具有初始占位符内容的数组。这就减少了数组增长的必要，因为数组增长的操作花费很大。

• 函数 zeros 创建一个由 0 组成的数组：

In [4]: a = np.zeros((3,4))

In [5]: a
Out[5]:
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

• 函数 ones 创建一个由 1 组成的数组：

In [6]: a = np.ones((3,4))

In [7]: a
Out[7]:
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

• 函数 empty 内容是随机的并且取决于存储器的状态。默认情况下，创建的数组的dtype是 float64。

In [15]: a
Out[15]:
array([[1.69122046e-306, 1.31996133e-285, 1.32001905e-285],
       [2.22129839e-285, 1.32003829e-285, 1.31963425e-285],
       [1.25972084e-285, 0.00000000e+000, 0.00000000e+000]])

In [16]: a.dtype
Out[16]: dtype('float64')

• 创建数字序列，NumPy提供了一个类似于 range 的函数，该函数返回数组而不是列表。

In [21]: np.arange(0,2,0.2)
Out[21]: array([0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8])

In [22]: np.arange(1,5,2)
Out[22]: array([1, 3])

打印数组

当你打印数组时，NumPy以与嵌套列表类似的方式显示它，但是具有以下布局：

• 最后一个轴从左到右打印，
• 倒数第二个从上到下打印，
• 其余的也从上到下打印，每个切片与下一个用空行分开。

一维数组被打印为行、二维为矩阵和三维为矩阵列表。

In [24]: a
Out[24]: array([1, 3])

In [25]: print(a)
[1 3]

In [26]: a = np.array(([1,2,3],[4,5,6]))

In [27]: print(a)
[[1 2 3]
 [4 5 6]]

In [28]: c = np.arange(24).reshape(2,3,4)

In [29]: print(c)
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

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

###基本操作
数组上的算术运算符使用元素级别。加减乘除都是每个元素之间的运算。

>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a<35
array([ True, True, False, False])

• 一些函数

In [36]: a
Out[36]:
array([[1, 2, 3],
       [4, 5, 6]])

In [37]: a.max()
Out[37]: 6

In [38]: a.min()
Out[38]: 1

In [39]: a.sum()
Out[39]: 21

• 默认情况下，这些操作适用于数组，就好像它是数字列表一样，无论其形状如何。但是，通过指定 axis 参数，你可以沿着数组的指定轴应用操作：

In [4]: np.arange(12).reshape(3,4)
Out[4]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [5]: a = np.arange(12).reshape(3,4)

In [6]: a.min(axis=0)
Out[6]: array([0, 1, 2, 3])

In [7]: a.min(axis=1)
Out[7]: array([0, 4, 8])

通用函数

NumPy提供了常见的数学函数，如sin，cos和exp。在NumPy中，这些函数在数组上按元素级别操作，产生一个数组作为输出。

>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([ 1.        ,  2.71828183,  7.3890561 ])
>>> np.sqrt(B)
array([ 0.        ,  1.        ,  1.41421356])
>>> C = np.array([2., -1., 4.])
>>> np.add(B, C)
array([ 2.,  0.,  6.])