Numpy学习

链接到Numpy官方文档
本文总结是根据官方文档而来

Numpy知识点

简介与安装

简介： Numpy是Python用于科学计算的一个库，提供了一个多维数组对象，各种衍生对象（如矩阵），可进行傅里叶变换、基本线性代数、基本统计运算以及随机模拟等等。
Numpy和Python内置的序列之间是有区别的： 1. Numpy数组在创建时具有固定的大小，与Python列表的动态增长不同；2. Numpy数组中的元素都需要相同的数据类型；3. Numpy数组便于对大量数据进行高级数学和其他类型的操作；4. 越来越多的科学和数学的Python软件包正在使用Numpy数组。
Numpy有两大功能： 1. 矢量化；2. 广播。矢量化可使得代码中没有任何明确的循环，索引等，其优点包括：矢量化代码更简洁易读，较少的代码运行通常意味着更少的错误，代码更接近与标准数学符号。广播适用于描述操作隐含元素行为的术语，在Numpy的所有操作中，不仅仅是算数运算，而且还是逻辑的，逐位的，功能性的，具体可在下面的基础知识中了解。

---

安装： Linux系统中 ：

pip3 install numpy

基础知识

Numpy数组的一个例子：

>>>import numpy as np
>>>a =  np.arange(12).reshape(3,4)
#定义一个Numpy的数组a：
>>>a.shape
#将输出(3,4),代表这是一个三行四列的矩阵
>>>a.ndim
#数组的维数，比如a就是一个二维的，所以将输出2
>>>a.size
#数组的元素总数，比如a中共有12个元素
>>>a.dtype
#描述数组中元素类型，另外NumPy提供了自己的类型。numpy.int32，numpy.int16和numpy.float64是一些例子。此处将输出：int64
>>>type(a)
#这利用到了Python自身的方法，返回的为a的类型，此处返回：<type'numpy.ndarray'> 

定义数组：

有几种方法供我们定义数组：
例如，我们能从一个常规的Python列表或元组中使用array函数创建数组。所创建的数组类型为序列中元素的类型：

>>>import numpy as np
>>>a = np.array([2,3,4])
>>>a
array([2,3,4])
>>>a.dtype
dtype('int64')
>>>b = np.array([1.2,3.5,5.1])
>>>b.dtype
dtype('float64')

在定义数组时，我们经常会犯的一个错误：

>>>a = np.array(1,2,3,4)  #wrong
>>>a = np.array([1,2,3,4])   #right

array能将序列里的序列转换成二维数组，将序列中的序列中的序列转换成三维数组：

>>>b = np.array([(1.5,2,3),(4,5,6)])
>>>b
array([[1.5,2,3],[4,5,6]])

Numpy提供了一些函数来创建数组，比如有zeros（里面元素全是0）、ones（里面元素全是1）、empty（内容是随机的）【注：所创建数组中元素类型默认是float64】：

>>>np.zeros((2,3))
array([[0.,0.,0.],
       [0.,0.,0.]])
>>>np.ones((2,3),dtype=np.int64)
#其中，可以在定义时指定元素的类型
array([[1,1,1],
       [1,1,1]])
>>>np.empty((2,3))
array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
       [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

为了创建数字序列，Numpy提供了range函数：

>>>np.arange(10,30,5)
#其中，范围在10到30之间（不包括30），步长为5
array([10,15,20,25])
>>>np.arange(0,2,0.3)
array([0.,0.3,0.6,0.9,1.2,1.5,1.8])

通常，我们在定义关于浮点数的序列时，使用linspace方法：

>>>np.linspace(0,2,9)
#代表着范围为0到2，中间共有9个元素
array([0.,0.25,0.5,0.75,1.,1.25,1.5,1.75,2.])

基本操作：

>>>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],dtype=bool)

在Numpy中，*代表着矩阵中对应元素之间相乘，dot代表着矩阵的乘法：

>>>a = np.array([[1,1],
...           [0,1]])
>>>b = np.array([[2,0],
...           [3,4]])
>>>a*b
array([[2,0],
       [0,4]])
>>>a.dot(b) #或者np.dot(a,b)
array([[5,4],
       [3,4]])

还有操作符 += 和 *= 类似于编程语言中的用法；

>>>a = np.random.randn((2,3))
>>>a
array([[ 0.18626021,  0.34556073,  0.39676747],
       [ 0.53881673,  0.41919451,  0.6852195 ]])
>>>a.sun()
2.5718191614547998
>>>a.min()
0.1862602113776709
>>>a.max()
0.6852195003967595

如果我们要求列上的和或行上的和，可通过设置axis的值实现：

>>>b = np.arange(12).reshape(3,4)
>>>b
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>b.sum(axis=0)    #每一行的和,axis=1时为每一列的和
array([12, 15, 18, 21])
>>>b.min(axis=1)
array([0, 4, 8])
>>>b.cumsum(axis=1)   #每一行上的累加和 
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38]])

通用函数：

>>> 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.])
>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.floor(a)  #求不大于x的最大整数
array([-2., -2., -1.,  0.,  1.,  1.,  2.])

通用函数还有更多：
all, any, apply_along_axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, transpose, var, vdot, vectorize, where

索引、切片、迭代

一维数组可以索引、切片、迭代，想pyt4,125,216,343,5126hon中的列表以及其他序列一样：

>>>a = np.arange(10)**3
>>>a
array([0,1,8,27,64,125,216,343,512,729])
>>>a[2]
#输出8
>>>a[2:5]
array([8,27,64])
>>>a[:6:2]=-1000 # 类似于a[0:6:2]=-1000，也就是a[0]=a[2]=a[4]=a[6]=-1000
>>>b = np.array([1,5,9])
>>>b[::-1] #相当于倒置b
array([9,5,1])
>>>

多维数组的每一维都有一个索引，这些索引是由逗号分隔的元组组成的：

>>>def f(x,y)
...     return 10*x+y
>>>b = np.fromfunction(f,(5,4),dtype=int)
>>>b
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
>>>b[2,3]
23
>>>b[0:5,1] #第二列中每一行的值
array([ 1, 11, 21, 31, 41])
>>>b[ : ,1]   #与上个功能一样
array([ 1, 11, 21, 31, 41])
>>>b[1:3,:]  #在第三行到第四行中每一列的值
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])

当提供的索引数量少于轴数时，缺失的索引被认为是完整的切片：

>>>b[-1]   #类似于b[-1,:],代表最后一行
array([40,41,42,43])

相对于第一个轴进行多维数组的迭代：

>>>for row in b
...   print(row)
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]

如果想对每一个元素进行迭代，可以使用flat这个属性：

>>>for element in b.flat:
...    print(element)
0
1
2
3
10
11
12
13
20
21
22
23
30
31
32
33
40
41
42
43

形状操纵：

改变一个数组的形状：

An array has a shape given by the number of elements along each axis:

>>> a = np.floor(10*np.random.random((3,4)))
>>> a
array([[ 2.,  8.,  0.,  6.],
       [ 4.,  5.,  1.,  1.],
       [ 8.,  9.,  3.,  6.]])
>>> a.shape
(3, 4)

数组的形状能够被一些不同的命令改变：

>>>a.ravel() 
array([ 2.,  8.,  0.,  6.,  4.,  5.,  1.,  1.,  8.,  9.,  3.,  6.])
>>>a.reshape(6,2)
array([[ 2.,  8.],
       [ 0.,  6.],
       [ 4.,  5.],
       [ 1.,  1.],
       [ 8.,  9.],
       [ 3.,  6.]]
>>>a.T # 求a的转置矩阵
array([[ 2.,  4.,  8.],
       [ 8.,  5.,  9.],
       [ 0.,  1.,  3.],
       [ 6.,  1.,  6.]])
>>>a.T.shape
(4,3)
>>>a.shape
(3,4)

a.shape与a.resize的区别？
待编辑
在改变数组形状时，如果其中一个维度为-1，则其他维度会自动作出调整：

>>> a.reshape(3,-1)
array([[ 2.,  8.,  0.,  6.],
       [ 4.,  5.,  1.,  1.],
       [ 8.,  9.,  3.,  6.]])

堆叠不同的数组

几个数组可以沿着不同的轴堆叠在一起：

>>>a = np.floor(10*np.random.random((2,2)))
>>> a
array([[ 8.,  8.],
       [ 0.,  0.]])
>>> b = np.floor(10*np.random.random((2,2)))
>>> b
array([[ 1.,  8.],
       [ 0.,  4.]])
>>> np.vstack((a,b))
array([[ 8.,  8.],
       [ 0.,  0.],
       [ 1.,  8.],
       [ 0.,  4.]])
>>> np.hstack((a,b))
array([[ 8.,  8.,  1.,  8.],
       [ 0.,  0.,  0.,  4.]])

column_stack 能将1D数组堆成2D数组，类似于hstack作用于2D数组【注：row_stack与vstack可类比此例】：

>>> from numpy import newaxis
>>> np.column_stack((a,b))     # with 2D arrays
array([[ 8.,  8.,  1.,  8.],
       [ 0.,  0.,  0.,  4.]])
>>> a = np.array([4.,2.])
>>> b = np.array([3.,8.])
>>> np.column_stack((a,b))     # returns a 2D array
array([[ 4., 3.],
       [ 2., 8.]])
>>> np.hstack((a,b))           # the result is different
array([ 4., 2., 3., 8.])
>>> a[:,newaxis]               # this allows to have a 2D columns vector
array([[ 4.],
       [ 2.]])
>>> np.column_stack((a[:,newaxis],b[:,newaxis]))
array([[ 4.,  3.],
       [ 2.,  8.]])
>>> np.hstack((a[:,newaxis],b[:,newaxis]))   # the result is the same
array([[ 4.,  3.],
       [ 2.,  8.]])

将一个阵列分隔成几个较小的：

使用hsplit和vsplit，分别为沿着水平轴和竖直轴分割数组，方法中要指定要返回的等同数组的数量，或者指定分割之后的列：

>>> a = np.floor(10*np.random.random((2,12)))
>>> a
array([[ 9.,  5.,  6.,  3.,  6.,  8.,  0.,  7.,  9.,  7.,  2.,  7.],
       [ 1.,  4.,  9.,  2.,  2.,  1.,  0.,  6.,  2.,  2.,  4.,  0.]])
>>> np.hsplit(a,3)   # Split a into 3
[array([[ 9.,  5.,  6.,  3.],
       [ 1.,  4.,  9.,  2.]]), array([[ 6.,  8.,  0.,  7.],
       [ 2.,  1.,  0.,  6.]]), array([[ 9.,  7.,  2.,  7.],
       [ 2.,  2.,  4.,  0.]])]
>>> np.hsplit(a,(3,4))   # Split a after the third and the fourth column
[array([[ 9.,  5.,  6.],
       [ 1.,  4.,  9.]]), array([[ 3.],
       [ 2.]]), array([[ 6.,  8.,  0.,  7.,  9.,  7.,  2.,  7.],
       [ 2.,  1.,  0.,  6.,  2.,  2.,  4.,  0.]])]

复制与查看

没有完全复制

>>>a = np.arange(12)
>>>b = a
>>>>b is a
True
>>>b.shape = 3,4  #我们将会发现，如果改变了b的形状，a也会随着改变
>>>a.shape
(3,4)

可验证：

>>>id(a)
148293216
>>>id(b)
148293216

查看或浅复制：

不同的数组对象可以共享相同的数据。该view方法创建一个查找相同数据的新数组对象：

>>>c = a.view()
>>>c is a
False
>>>c.base is a  ## c is a view of the data owned by a
True
>>>c.flags.owndata
False
>>>c.shape = 2,6
>>>a.shape   # a's shape doesn't change
(3,4)
>>>c[0,4] = 1234  
>>>a  # a's data changes
array([[   0,    1,    2,    3],[1234,    5,    6,    7],[   8,    9,   10,   11]])

Slicing an array returns a view of it:

>>> s = a[ : , 1:3]     # spaces added for clarity; could also be written "s = a[:,1:3]"
>>> s[:] = 10           # s[:] is a view of s. Note the difference between s=10 and s[:]=10
>>> a
array([[   0,   10,   10,    3],
       [1234,   10,   10,    7],
       [   8,   10,   10,   11]])

深复制：

>>>a = a.copy()
>>>d is a
False
>>>d.base is a  # d doesn't share anything with a
False
>>> d[0,0] = 9999
>>> a
array([[   0,   10,   10,    3],
       [1234,   10,   10,    7],
       [   8,   10,   10,   11]])

Numpy中的功能和方法概览：

Array Creation（数组创建）：

arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r, zeros, zeros_like

Conversions（转换）：

ndarray.astype, atleast_1d, atleast_2d, atleast_3d, mat

Manipulations（操作）：

array_split, column_stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, ndarray.item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack

Questions（查询）:

all, any, nonzero, where

Ordering（排序）：

argmax, argmin, argsort, max, min, ptp, searchsorted, sort

Operations（基本操作）：

choose， compress， cumprod， cumsum， inner， ndarray.fill， imag， prod， put， putmask， real， sum

Basic Statistics（基本统计）：

cov, mean, std, var

Basic Linear Algebra（基本线性回归）：

cross, dot, outer, linalg.svd, vdot