Numpy的基本使用

￡神魔★判官ぃ 2024-04-17 15:15 57阅读 0赞

### 下载 ###

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的外形，比如将一个1*6的数组改变成2*3.但是无法改变成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]]

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

参考文档：  
udacity教程

[Link 1]: https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html