Numpy的基本使用

下载

numpuy和其他python库一样，可以在命令行中输入下面命令下载。

conda install numpy

你可以输入下面的命令检查自己下载的numpy的版本。

conda list numpy #在命令行中 !conda list numpy #在jupyter notebook中

对于numpy，其核心就是ndarray。ndarray就是n维数组（矩阵），其中的数据必须是相同类型。
在使用numpy之前，需要先引用这个库，一般来说我们使用numpy的缩写np。

import numpy as np

创建ndarray

1.使用常规的python列表方式。
2.使用numpy的内置函数。
我们可以使用numpy的np.array()建立ndarray。

x = np.array([1,2,3,4,5])
print('x = ',x)

x =  [1 2 3 4 5]

使用numpy ndarray可以很直观的获得很多信息。比如说.shape和.dtype内置函数。
.shape可以返回ndarray数组大小，.dtype可以返回ndarray数组存储的数据类型。

x = np.array([1,2,3,4,5])
y = np.array([[1.0,2,3,4,5],[6,7,8,9,10]])
z = np.array(['hello','world'])

print('x = ',x)
print('y = ',y)
print('z = ',z)

print(x.shape)
print(y.shape)
print(z.shape)

print(x.dtype)
print(y.dtype)
print(z.dtype)

x =  [1 2 3 4 5]
y =  [[ 1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10.]]
z =  ['hello' 'world']
(5,)
(2, 5)
(2,)
int32
float64
<U5

我们也可以注意到，尽管y中只有1.0是浮点数，但是因为ndarray只能存储相同类型的元素，所以ndarray会使用向上转型的方式保持数据一致性。在存储字符串的时候，返回数据类型为Unicode。

当然,我们也可以指定ndarray按哪种数据类型储存数据。只需要使用关键字dtype.

x = np.array([1.1,2.2,3.3],dtype = np.int64)

print('x = ',x)
print(x.dtype)

x =  [1 2 3]
int64

numpy还支持将你创建的ndarray保存到文件中或者用在另一个项目。

x = np.array([1,2,3,4,5])

np.save('my_array',x)

这样会将x的数据保存到名称为my_array.npy的文件中。你可以使用load函数将数据下载下来。

y = np.load('my_array.npy')

print('y = ',y)

y =  [1 2 3 4 5]

内置函数

在numpy中有很多有用的内置函数帮我们快速建立一个ndarray。

np.zeros((a,b)),创建一个全是零的ndarray,其中a表示行，b表示列。

x = np.zeros((3,4))
print('x = \n',x)

x = 
 [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

np.ones((a,b)),创建一个全是1的ndarray数组。

x = np.ones((3,4))
print('x = \n',x)

x = 
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

上面的那两个函数创建的ndarray数组的数据类型是浮点数，可以使用关键字dtype自己设置。

可以使用np.full创建任何你想要的数字。np.full(shape,constant value)。默认的数据类型和你设置的具体数字保持一致。

x = np.full((3,4),5)
print('x= \n',x)

x= 
 [[5 5 5 5]
 [5 5 5 5]
 [5 5 5 5]]

生成对角矩阵

np.eye(n)可以生成一个n*n的单位矩阵。

x = np.eye(5)

print('x = \n',x)

x = 
 [[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]

np.diag()可以生成对角矩阵。

x = np.diag([10,20,30,40])

print('x = \n',x)

x = 
 [[10  0  0  0]
 [ 0 20  0  0]
 [ 0  0 30  0]
 [ 0  0  0 40]]

你可以使用np.arange()函数生成一个具有等差的间隔ndarray。np.arange()函数有三个可选参数。不同的参数有不同的效果。

如果只有一个参数n，那么会生成一个1到n-1的ndarray。

x = np.arange(10)
print('x=',x)

x= [0 1 2 3 4 5 6 7 8 9]

如果有两个参数，那么代表的是np.arange(start,stop),生成一个从start到stop-1的ndarray的数组，间隔为1，不包括stop这个数。

x = np.arange(4,10)
print('x = ',x)

x =  [4 5 6 7 8 9]

如果有三个参数np.arange(start,stop,step),那么会生成一个从start开始，间隔为step，一直到stop-1的ndarray数组。

x = np.arange(1,14,3)
print('x = ',x)

x =  [ 1  4  7 10 13]

虽然arange可以生成等间距ndarray数组，但是如果需要浮点数间隔，最好使用np.linspace()函数。因为arange函数的精确度太低。

np.linspace(start,stop,N)会产生从start到stop等间隔的N个数，start和stop都会被包括。如果只有两个参数，那么N缺省值为50.

x= np.linspace(0,25,10)
print('x = \n',x)

x = 
 [ 0.          2.77777778  5.55555556  8.33333333 11.11111111 13.88888889
 16.66666667 19.44444444 22.22222222 25.        ]

你可以使用endpoint=False使得生成的ndarray不包括stop这个数。

x = np.linspace(0,25,10,endpoint = False)

print('x = ',x)

x =  [ 0.   2.5  5.   7.5 10.  12.5 15.  17.5 20.  22.5]

改变ndarray的外形

使用np.shape()函数可以任意改变ndarray的外形，比如将一个16的数组改变成23.但是无法改变成3*3，那需要9个元素。

x= np.arange(20)
print('x = \n',x)

x = np.reshape(x,(4,5))
print('x = \n',x)

x = 
 [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
x = 
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

NumPy可以将函数应用成方法，这样可以简化代码。

x = np.arange(20).reshape(4,5)
print('x = \n',x)

x = 
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

当然，reshape方法还可以用在其他函数后面，比如说linspace。

numpy还可以产生随机数组。使用np.random.random(shape)可以产生指定外形的在0.0到1.0的随机数组。

x = np.random.random((3,3))

print('x = \n',x)

x = 
 [[0.73809735 0.30731617 0.64157321]
 [0.05290896 0.49719134 0.27590918]
 [0.91274159 0.65788666 0.32977202]]

我们也可以使用np.random.randint(start,stop.size=shape)产生在start和stop之间的随机数组。

x = np.random.randint(4,15,size=(3,2))

print('x =\n',x)

x =
 [[ 7  5]
 [12  9]
 [ 6  6]]

访问，修改和插入

ndarray支持通过索引访问元素，同时支持正索引和负索引。第一个元素开始是以0开始，访问两维的ndarray可以是用a[row,column]。可以通过索引直接修改元素。

x = np.array([1,2,3,4,5])

print(x[0])
print(x[-1])

x[2]=10
print('x = ',x)

1
5
x =  [ 1  2 10  4  5]

我们也可以添加或删除ndarray中的元素。

删除我们使用的是np.delete(ndarray,element,axis)其中一维的ndarray不需要使用axis关键字。在二维的ndarray中，axis = 0代表的是选中行，axis = 1代表的是选中列。

x = np.array([1,2,3,4,5])
y = np.array([[1,2,3],[4,5,6],[7,8,9]])

x = np.delete(x,[0,4])
w = np.delete(y,0,axis=0)
z=np.delete(y,[0,2],axis=1)

print('x = \n',x)
print('w =\n',w)
print('z =\n',z)

x = 
 [2 3 4]
w =
 [[4 5 6]
 [7 8 9]]
z =
 [[2]
 [5]
 [8]]

np.append(ndarray,elements,axis)函数可以给ndarray后面添加元素。axis的用法和上边相同。

如果是想要给ndarray数组中插入数据，可以使用np.insert(ndarray,index,elements,axis)。其中index表示将数据插入到什么地方。注意下面例子的一些细节。

x = np.array([1,2,5,6,7,8])
y = np.array([[1,2,3],[7,8,9]])

x = np.insert(x,2,[3,4])
print('x = \n',x)

w = np.insert(y,1,[4,5,6],axis=0)
v = np.insert(y,1,5,axis=1)

print('w =\n',w)
print('v =\n',v)

x = 
 [1 2 3 4 5 6 7 8]
w =
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
v =
 [[1 5 2 3]
 [7 5 8 9]]

NumPy还支持将两个ndarray组合在一起，有两个内置函数。np.vstack()是垂直组合在一起，np.hstack是水平组合在一起。注意一定要形状匹配才行。

x = np.array([1,2])
y = np.array([[3,4],[5,6]])

z = np.vstack((x,y))
w = np.hstack((y,x.reshape(2,1)))

print('z=\n',z)
print('w =\n',w)

z=
 [[1 2]
 [3 4]
 [5 6]]
w =
 [[3 4 1]
 [5 6 2]]

切片

在NumPy中，我们可以很简单的获得ndarray的子集，有三种方式。

1.ndarray[start:end]

2.ndarray[start:]

3.ndarray[:end]

需要注意的是，第一种和最后一种是不包括end元素的。如果ndarray是二维数组，只需要再多加一个参数限定就行。

x = np.arange(20).reshape(4,5)
print('x =\n',x)

z= x[1:4,2:5]
print('z = \n',z)

w = x[1:,2:5]
print('z=\n',z)

q = x[:,2]
print('q =\n',q)

r=x[:,2:3]
print('r=\n',r)

x =
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
z = 
 [[ 7  8  9]
 [12 13 14]
 [17 18 19]]
z=
 [[ 7  8  9]
 [12 13 14]
 [17 18 19]]
q =
 [ 2  7 12 17]
r=
 [[ 2]
 [ 7]
 [12]
 [17]]

注意q是一个一维数组，而r是二维的。,

令人很困惑的是通过切片x创建的这些变量并非是将x的值复制过去了，这些变量实际上是和x不同名称的同一个ndarray数组。可以看下面的例子理解一下。

x= np.arange(20).reshape(4,5)

z=x[1:4,2:5]
print('z = \n',z)

z[2,2]=555
print('x =\n',x)

z = 
 [[ 7  8  9]
 [12 13 14]
 [17 18 19]]
x =
 [[  0   1   2   3   4]
 [  5   6   7   8   9]
 [ 10  11  12  13  14]
 [ 15  16  17  18 555]]

为了解决这个问题，我们可以使用np.copy()函数，当然这个函数也可以当方法使用。利用这个函数可以创造出独立的ndarray数组。

x = np.arange(20).reshape(4,5)

z = np.copy(x[1:4,2:5])
w = x[1:4,2:5].copy()

z[2,2]=555
w[2,2]=444

print('z=\n',z)
print('w=\n',w)
print('x=\n',x)

z=
 [[  7   8   9]
 [ 12  13  14]
 [ 17  18 555]]
w=
 [[  7   8   9]
 [ 12  13  14]
 [ 17  18 444]]
x=
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]

我们也可以使用一个ndarray当作一些函数的参数。

x = np.arange(20).reshape(4,5)
indices = np.array([1,3])

y = x[indices,:]
print('y=\n',y)

y=
 [[ 5  6  7  8  9]
 [15 16 17 18 19]]

numpy可以使用np.diag(ndarray,k=n)来提取对角线上的元素。当k=0时，代表的是主对角线上的元素，k>0提取主对角线上面的对角线，k<0代表下面的。

np.unique(ndarray)函数可以去重，将数组中的元素只提取一个。

x = np.array([[1,2,3],[5,2,8],[1,2,3]])

print(np.unique(x))

[1 2 3 5 8]

布尔索引

NumPy还支持布尔索引，可以更方便的选择需要的元素。

比如说选取特定大小范围的元素。

x = np.arange(25).reshape(5,5)

x[(x>10)& (x<17)] = -1

print('x =\n',x)

x =
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 -1 -1 -1 -1]
 [-1 -1 17 18 19]
 [20 21 22 23 24]]

NumPy还有排序的函数sort，如果将sort当作函数使用，那么ndarray的值是不会改变的，如果当作方法来使用，那么排序好的值会代替原来的值。

x = np.random.randint(1,11,size=(10,))

print('x=\n',x)

print('x =\n',np.sort(x))

print('x =\n',x)
x.sort()
print('x =\n',x)

x=
 [3 3 3 6 5 3 2 5 8 1]
x =
 [1 2 3 3 3 3 5 5 6 8]
x =
 [3 3 3 6 5 3 2 5 8 1]
x =
 [1 2 3 3 3 3 5 5 6 8]

sort函数不会删除重复的元素，如果想要删除重复出现的元素。可以使用np.unique(x)函数。

print(np.sort(np.unique(x)))

[1 2 3 5 6 8]

如果是二维数组，我们可以使用关键字axis来确定是按行还是按列排序。用法和之前一样。

计算和广播机制

numpy支持元素层次上的操作，这一操作依赖于numpy的广播机制。ndarray支持加，减，乘，除操作。可以使用+或者函数np.add()的方式操作。

x = np.array([1,2,3,4])
y = np.array([5.5,6.5,7.5,8.5])

print('x+y= ',x+y)
print('add(x,y)=',np.add(x,y))

x+y=  [ 6.5  8.5 10.5 12.5]
add(x,y)= [ 6.5  8.5 10.5 12.5]

其他的操作类似，函数分别为np.add(),np.subtract(x,y),np.multiply(x,y),np.divide(x,y)。二维数组同样适用，不过必须形状一样或者符合被广播的要求。

当然，还有其他的函数，比如说，sqrt（）函数，可以计算平方根。

NumPy还有许多数据统计共嫩的函数，有兴趣可以自己了解。

X = np.array([[1,2], [3,4]])

print()
print('X = \n', X)
print()

print('Average of all elements in X:', X.mean())
print('Average of all elements in the columns of X:', X.mean(axis=0))
print('Average of all elements in the rows of X:', X.mean(axis=1))
print()
print('Sum of all elements in X:', X.sum())
print('Sum of all elements in the columns of X:', X.sum(axis=0))
print('Sum of all elements in the rows of X:', X.sum(axis=1))
print()
print('Standard Deviation of all elements in X:', X.std())
print('Standard Deviation of all elements in the columns of X:', X.std(axis=0))
print('Standard Deviation of all elements in the rows of X:', X.std(axis=1))
print()
print('Median of all elements in X:', np.median(X))
print('Median of all elements in the columns of X:', np.median(X,axis=0))
print('Median of all elements in the rows of X:', np.median(X,axis=1))
print()
print('Maximum value of all elements in X:', X.max())
print('Maximum value of all elements in the columns of X:', X.max(axis=0))
print('Maximum value of all elements in the rows of X:', X.max(axis=1))
print()
print('Minimum value of all elements in X:', X.min())
print('Minimum value of all elements in the columns of X:', X.min(axis=0))
print('Minimum value of all elements in the rows of X:', X.min(axis=1))

X = 
 [[1 2]
 [3 4]]

Average of all elements in X: 2.5
Average of all elements in the columns of X: [2. 3.]
Average of all elements in the rows of X: [1.5 3.5]

Sum of all elements in X: 10
Sum of all elements in the columns of X: [4 6]
Sum of all elements in the rows of X: [3 7]

Standard Deviation of all elements in X: 1.118033988749895
Standard Deviation of all elements in the columns of X: [1. 1.]
Standard Deviation of all elements in the rows of X: [0.5 0.5]

Median of all elements in X: 2.5
Median of all elements in the columns of X: [2. 3.]
Median of all elements in the rows of X: [1.5 3.5]

Maximum value of all elements in X: 4
Maximum value of all elements in the columns of X: [3 4]
Maximum value of all elements in the rows of X: [2 4]

Minimum value of all elements in X: 1
Minimum value of all elements in the columns of X: [1 2]
Minimum value of all elements in the rows of X: [1 3]

NumPy还支持加（减，乘，除）一个数，效果就是ndarray中每一个元素都加（减，乘，除）这个数。这个用到的就是numpy的广播机制。

numpy数组还可以这样相加。

x = np.array([1,2,3])
y = np.array([[1,2,3],[4,5,6],[7,8,9]])

print('x+y=\n',x+y)

x+y=
 [[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]]

如果还想了解更多广播机制，可以点这个了解链接

参考文档：
udacity教程