简介
NumPy 是一个开源的 Python 库,次要用在数据分析和科学计算,基本上能够把 NumPy 看做是 Python 数据计算的根底,因为很多十分优良的数据分析和机器学习框架底层应用的都是 NumPy。比方:Pandas, SciPy, Matplotlib, scikit-learn, scikit-image 等。
NumPy 库次要蕴含多维数组和矩阵数据结构。它为 ndarray(一个 n 维数组对象)提供了对其进行无效操作的办法。NumPy 能够用于对数组执行各种数学运算。并且提供了可在这些数组和矩阵上运行的宏大的高级数学函数库。
装置 NumPy
有很多形式能够依照 NumPy:
pip install numpy
如果你应用的是 conda,那么能够:
conda install numpy
或者间接应用 Anaconda. 它是一系列数据分析包的汇合。
Array 和 List
Python 中有一个数据类型叫做 List,list 中能够存储不同品种的对象。在应用程序中这样做没有什么问题,然而如果是在科学计算中,咱们心愿一个数组中的元素类型必须是统一的,所以有了 NumPy 中的 Array。
NumPy 能够疾速的创立 Array,并且对其中的数据进行操作。
NumPy 中的 Array 要比 Python 中的 List 要快得多,并且占用更少的内存空间。
看下两者之间的性能差别:
In [1]: import numpy as np
...: my_arr = np.arange(1000000)
...: my_list = list(range(1000000))
...: %time for _ in range(10): my_arr2 = my_arr * 2
...: %time for _ in range(10): my_list2 = [x * 2 for x in my_list]
...:
CPU times: user 12.3 ms, sys: 7.88 ms, total: 20.2 ms
Wall time: 21.4 ms
CPU times: user 580 ms, sys: 172 ms, total: 752 ms
Wall time: 780 ms
下面的例子对一个蕴含一百万的数据进行乘 2 操作,能够看到,应用 NumPy 的效率是 Python 的几十倍,如果在大型数据我的项目中这个效率会造成十分大的性能影响。
创立 Array
下面的例子中,咱们曾经创立了一个 array,应用的是 np.arange 办法。
咱们还能够通过 List 来创立 Array,List 能够是一维列表,也能够是多维列表:
>>> a = np.array([1, 2, 3, 4, 5, 6])
>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
和 List 一样,Array 也能够通过 index 来拜访:
>>> print(a[0])
[1 2 3 4]
接下来咱们介绍几个罕用的名词:
- vector — 示意的是一维数组
- matrix — 示意的是二维数组
- tensor — 示意的是三维或者更高维度的数组
在 NumPy 中维度也被称之为 axes。
上面咱们来看下其余几种创立 Array 的办法:
最简略的就是 np.array,之前的例子中咱们曾经提到过了。
如果要疾速的创立都是 0 的数组,咱们能够应用 zeros:
>>> np.zeros(2)
array([0., 0.])
或者都填充为 1:
>>> np.ones(2)
array([1., 1.])
还能够创立空的数组:
In [2]: np.empty(2)
Out[2]: array([0. , 2.00389455])
留神,empty 办法中的内容并不一定是空的,而是随机填充数据,所以咱们在应用 empty 创立数组之后,肯定要记得笼罩其中的内容。应用 empty 的益处就是创立的速度比拟快。
还能够在 range 范畴内填充数组:
In [3]: np.arange(10)
Out[3]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
能够指定距离:
In [4]: np.arange(1,10,2)
Out[4]: array([1, 3, 5, 7, 9])
应用 linspace 能够创立等分的数组:
In [5]: np.linspace(0, 10, num=5)
Out[5]: array([0. , 2.5, 5. , 7.5, 10.])
默认状况下创立的数组内容类型是 np.float64,咱们还能够将其切换成整数:
np.int64
In [6]: x = np.ones(2, dtype=np.int64)
In [7]: x
Out[7]: array([1, 1])
Array 操作
sort
咱们能够应用 sort 对数组进行排序:
In [8]: arr = np.array([2, 1, 5, 3, 7, 4, 6, 8])
In [10]: np.sort(arr)
Out[10]: array([1, 2, 3, 4, 5, 6, 7, 8])
==sort== 是对 Array 中的元素进行排序,除了 sort 之外还有其余的一些排序的办法。
还能够应用 argsort,argsort 是一种间接排序的办法,他返回的是排序好的原数组的 index:
In [11]: x = np.array([10, 5, 6])
In [12]: np.argsort(x)
Out[12]: array([1, 2, 0])
下面咱们对 array 进行 ==argsort==,排序之后应该返回,5,6,10。5 的 index 是 1,6 的 index 是 2,10 的 index 是 0,所以返回 1,2,0。
==lexsort== 和 argsort 一样都是间接排序法,返回的都是排序过后的 index,不同是 lexsort 能够进行多 key 的排序。
surnames = ('Hertz', 'Galilei', 'Hertz')
first_names = ('Heinrich', 'Galileo', 'Gustav')
ind = np.lexsort((first_names, surnames))
ind
array([1, 2, 0])
下面的 lexsort 是先依照 surnames 排序,而后再依照 first_names 进行排序。
lexsort 的排序程序是从后到前。也就是最初一个传入的 key 最先排序。
==searchsorted== 用来查找要插入元素的 index 值,举个例子:
np.searchsorted([1,2,3,4,5], 3)
2
np.searchsorted([1,2,3,4,5], 3, side='right')
3
np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
array([0, 5, 1, 2])
==partition== 是对要排序的数据进行宰割,举个例子:
a = np.array([3, 4, 2, 1])
np.partition(a, 3)
array([2, 1, 3, 4])
第一个参数是一个 Array,第二个参数是要分隔的基准元素,这个基准元素的地位和排序过后的地位是一样的,其余的元素比基准元素小的放在后面,比基准元素大的放在前面。
还能够依照多个元素进行宰割:
np.partition(a, (1, 3))
array([1, 2, 3, 4])
concatenate
concatenate 用来连贯多个数组。
>>> a = np.array([1, 2, 3, 4])
>>> b = np.array([5, 6, 7, 8])
>>> np.concatenate((a, b))
array([1, 2, 3, 4, 5, 6, 7, 8])
还能够连贯多维数组:
>>> x = np.array([[1, 2], [3, 4]])
>>> y = np.array([[5, 6]])
>>> np.concatenate((x, y), axis=0)
array([[1, 2],
[3, 4],
[5, 6]])
统计信息
ndarray.ndim 用来统计数组的维数:
>>> array_example = np.array([[[0, 1, 2, 3],
... [4, 5, 6, 7]],
...
... [[0, 1, 2, 3],
... [4, 5, 6, 7]],
...
... [[0 ,1 ,2, 3],
... [4, 5, 6, 7]]])
>>> array_example.ndim
3
ndarray.size 用来统计数组中的元素个数:
>>> array_example.size
24
ndarray.shape 输入数组的形态:
>>> array_example.shape
(3, 2, 4)
阐明下面的数组是一个 3 2 4 的数组。
reshape
应用 reshape 能够从新结构一个数组。
>>> a = np.arange(6)
>>> print(a)
[0 1 2 3 4 5]
>>> b = a.reshape(3, 2)
>>> print(b)
[[0 1]
[2 3]
[4 5]]
下面咱们将一个一维的数组转成了一个 3 * 2 的数组。
reshape 还能够承受多个参数:
>>> numpy.reshape(a, newshape=(1, 6), order='C')
array([[0, 1, 2, 3, 4, 5]])
第一个参数是要重构的数组,第二个参数新的 shape,order 能够取三个值,C,F 或者 A。
C 示意依照 C 的 index 形式进行排序,F 示意依照 Fortran 的 index 形式进行排序。A 示意主动抉择。
在 Fortran 中,当挪动存储在内存中的二维数组的元素时,第一个索引是变动最快的索引。当第一个索引更改时挪动到下一行时,矩阵一次存储一列。另一方面,在 C 中,最初一个索引变动最快。
减少维度
np.newaxis 能够给现有的数组减少一个维度:
>>> a = np.array([1, 2, 3, 4, 5, 6])
>>> a.shape
(6,)
>>> a2 = a[np.newaxis, :]
>>> a2.shape
(1, 6)
>>> col_vector = a[:, np.newaxis]
>>> col_vector.shape
(6, 1)
还能够应用 expand_dims 来指定 axis 的地位:
>>> b = np.expand_dims(a, axis=1)
>>> b.shape
(6, 1)
>>> c = np.expand_dims(a, axis=0)
>>> c.shape
(1, 6)
index 和切片
数组的 index 和切片跟 Python 中的 list 是相似的:
>>> data = np.array([1, 2, 3])
>>> data[1]
2
>>> data[0:2]
array([1, 2])
>>> data[1:]
array([2, 3])
>>> data[-2:]
array([2, 3])
除此之外,数组还反对更多更弱小的 index 操作:
>>> a = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
>>> print(a[a < 5])
[1 2 3 4]
下面咱们找出了 a 中所有元素小于 5 的值。
In [20]: a<5
Out[20]:
array([[True, True, True, True],
[False, False, False, False],
[False, False, False, False]])
能够看到 a < 5 其实返回的也是一个数组,这个数组的元素 shape 和原数组是一样的,只不过外面的值是 true 和 false,示意是否应该被抉择进去。
同样的,咱们能够挑出所有大于 5 的元素:
>>> five_up = (a >= 5)
>>> print(a[five_up])
[5 6 7 8 9 10 11 12]
选出所有能够被 2 整除的数:
>>> divisible_by_2 = a[a%2==0]
>>> print(divisible_by_2)
[2 4 6 8 10 12]
还能够应用 & 和 | 运算符:
>>> c = a[(a > 2) & (a < 11)]
>>> print(c)
[3 4 5 6 7 8 9 10]
还能够应用 nonzero 来打印出满足条件的 index 信息:
In [23]: a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
In [24]: b = np.nonzero(a < 5)
In [25]: b
Out[25]: (array([0, 0, 0, 0]), array([0, 1, 2, 3]))
>>> print(a[b])
[1 2 3 4]
下面返回的元组中,第一个值示意的是行号,第二个值示意的是列。