NumPy从入门到放弃

刘兆卓

看前建议：
本文以jupyter notebook为编辑器进行示例，建议有一定python基础后再进行学习。
python的安装：https://www.cnblogs.com/scfssq/p/17478132.html
jupyter notebook的安装：https://www.cnblogs.com/kohler21/p/18349764

NumPy简介

公众号：愚生浅末
Numeric Python（简称NumPy）是使用Python进行科学计算的基本包，它是一个Python库，提供了多维数组对象，使用NumPy相较于直接编写Python代码实现，性能更加高效、代码更加简洁。NumPy广泛应用于各类场合，例如在机器学习、数值处理、爬虫等。NumPy主要是围绕Ndarray对象展开，通过NumPy的线性代数库对其进行一系列操作如切片索引、广播、修改数组（形状、维度、元素的增删改）、连接数组等，以及对多维数组的点积等。除了数组，Numpy还有很多函数包括三角函数、统计函数等。
NumPy的重要特点之一就是 n 维数组对象，即 ndarray。
在使用Numpy之前需要线导入Numpy：

1. import numpy as np

复制代码

生成数组

• 生成0\1数组
  

生成0/1数组，利用np.ones(shape, dtype)或np.ones_like(a, shape)、np.zeros(shape, dtype)或np.zeros_like(a, shape)

1. one_matrix = np.ones([3, 3]) # 生成一个3x3的矩阵，矩阵元素都为1
2. one_matrix

复制代码

效果：

生成一个3x3的矩阵，矩阵元素都为0

1. zero_matrix = np.zeros_like(one_matrix)
2. zero_matrix

复制代码

效果：

• 从现有数据生成数组，通过np.array(object, dtype)或np.asarray(a, dtype)
  

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

复制代码

效果：

1. arr1 = np.array(arr)
2. arr1

复制代码

效果：

1. arr2 = np.asarray(arr)
2. arr2

复制代码

可以发现，arr1和arr2与arr1完全一直，但是采用了不同的函数，实际上这两个复制函数是不同的，对于arr1采用的是np.array()，而arr2采用的是np.asarray()。当修改arr的元素值时候，arr1的元素值不会改变，而arr2的元素值会随着arr的元素值的改变而改变，示例如下：

1. # 修改原数组arr的元素值，对比arr1与arr2的变化
2. arr[1, 1] = 6

复制代码

• 生成固定范围的数组，利用np.arange()
  

通过np.linspace(start,stop,num=50)、np.arange([start=None],stop=None,[stop=None])、np.logspace(start,stop,num=50)均可以生成指定范围的数字，以np.arange()示例如下：

1. arr = np.arange(0, 13, 2)

复制代码

可以发现生成的数组不包含指定的最后一个数字，因为这个区间设定是左闭右开的。
公众号：愚生浅末
4. 生成随机数组
生成随机数组有多种方法。
rand基本用法

numpy.randon.rand(d0,d1,...dn),产生[0,1)之间均匀分布的随机浮点数，其中d0,d1,...dn标识传入的数组形状。

1. np.random.rand(2)#产生形状为(2,)的数组，也就是相当于有两个元素的一维数组
2. np.random.rand(2,4)#产生一个形状为(2,4)的数组，数组中的每个元素是[0,1)之间均匀分布的随机浮点数

复制代码

random基本用法

numpy.random.random(size),产生[0,1)之间的随机浮点数，非均匀分布
numpy.random.random_sample、numpy.random.ranf、numpy.random.sample用法与该函数类似
注意：该函数和rand()的区别
(1)random()参数只有一个参数"size",有3种取值：None,int型整数,int型元组。而在之前的numpy.random.rand()中可以有多个参数。例如，如果要产生一个3*3的随机数组（不考虑服从什么分布)，那么在rand()中的写法是：numpy.random.rand(3,3),而在random中的写法是numpy.random.random((3,3)),这里面是个元组，是有小括弧的。
(2)random()产生的随机数的分布为非均匀分布，numpy.random.rand()产生的随机数的分布为均匀分布

1. #产生一个[0,1)之间的形状为(3,3)的数组
2. np.random().random((3,3))
3. #产生[-5,0)之间的形状为(3,3)的随机数组，即5*[0,1)-5
4. 5*np.random.random_sample((3,3))-5
5. #产生[5,10)之间的形状为(3,3)的随机数组，即10*[0,1)-5[0,1)+5
6. (10-5)*np.eandom.random_sample((3,3))+5

复制代码

numpy.random.uniform

np.random.uniform(0.0, 1.0,size=None),从指定范围内产生均匀分布的随机浮点数，如果在seed()中传入的数字相同，那么接下来生成的随机数序列都是相同的，仅作用于最接近的那句随机数产生语句

1. #默认产生一个[0,1)之间随机浮点数
2. np.random.uniform()
3. #默认产生一个[1,5)之间的形状为(2,4)的随机浮点数
4. np.random.uniform(1,5,size=(2,4))

复制代码

randn基本用法

np.random.randn(d0,d1,...,dn),产生服从于标准正态分布（均值为0，方差为1）的随机浮点数，使用方法和rand()类似

1. # 产生形状为(2,)的数组
2. np.random.rand(2)
3. # 产生形状为(2,4)的数组
4. np.random.rand(2,4)

复制代码

如果要指定正态分布的均值和方差，则可以使用这个公式：

1. sigma * np.random.randn(...) + mu:2.5 *np.random.randn(2,4) + 3

复制代码

注意：2.5是标准差（不是方差），3是期望
normal基本用法

numpy.random.normal(loc=0.0, scale=1.0, size=None)，产生服从正态分布（均值为loc，标准差为scale）的随机浮点数

1. #产生均值为1标准差为10形状为(1000,)的数组
2. np.random.normal(1,10,100)
3. #产生均值为3标准差为2形状为(2,4)的数组
4. np.random.normal(3,2,size=(2,4))

复制代码

randint基本用法

numpy.random.randint(low[,high,size,dtype]),产生[low,high)之间的随机数，如果high不知名，则产生[0,low)之间的随机整数，size可以是int整数，或者int型的元组，标识产生随机数的个数，或者随机数组的形状。dtype标识具体随机数的类型，默认是int，可以指定成int64.

1. #产生一个[0,10)之间的随机整数
2. np.random.randint(10)
3. #产生一个[0,10)之间的随机整数8个，以数组的形式返回
4. np.random.randint(10,size=8)
5. #产生一个[5,10)之间的形状为(2,4)的随机整数8个，以数组的形式返回
6. np.random.randint(5,10,size=(2,4))

复制代码

choice基本用法

numpy.random.choice(a, size=None, replace=True, p=None),从一维arrary a中按概率p选择size个数组，若a为int，则从np.arrange(a)中选择，若a为array，则直接从a中选择。

1. numpy.random.choice(5,3)#从np.arrange(a)中等概率选择3个，等价于np.random.randint(0,5,3)
2. numpy.random.choice(5,3,p=[0.1,0,0.3,0.6,0])#从np.arrange(a)中按概率p选择3个
3. numpy.random.choice(5,3,p=[0.1,0,0.3,0.6,0]
4. numpy.random.choice(5,3,replace=False,p=[0.1,0,0.3,0.6,0])
5. aa_milne_arr = ['pooh','rabbit','piglet','Christopher']
6. np.random.choice(aa_milne_arr,5,p=[0.5,0.1,0.1,0.3])

复制代码

numpy.random.shuffle

numpy.random.shuffle(x)按x的第一个维度进行打乱，x只能是array

1. np.random.shuffle(np.arange(9).reshape((3,3)))#对np.arange(9).reshape((3,3))打乱

复制代码

numpy.random.permutation

numpy.random.permutation(x),按x的第一个维度进行打乱，若a为int，则对np.arrange(a)打乱，若a为array,则直接对a打乱

1. np.random.permutation(10)#对np.arange(10)打乱
2. np.random.permutation(np.arange(9).reshape((3,3)))#对np.arange(9).reshape((3,3))打乱

复制代码

numpy.random.seed

若果在seed()中传入的数字相同，那么接下来生成的随机数序列都是相同的，仅作用于最接近的那句随机数产生语句

1. np.random.seed(10)
2. temp1 = np.random.rand(4)
3. np.random.seed(10)
4. temp2=np.random.rand(4)
5. temp3=np.random.rand(4)

复制代码

上述temp1和temp2是相同的，temp3是不同的，因为seed仅作用于最接近的那句随机数产生语句。
numpy.linspace

numpy.linspace(start,stop,num=50,endpoint = True,retstep = False,dtype = None,axis = 0),区间均等分

1. np.linspace(2.0,3.0,num=5) #array([2.,2.25,2.5,2.75,3.])
2. np.linspace(2.0,3.0,num=5,endpoint=False) #array([2.,2.2,2.4,2.6,2.8])
3. np.linspace(2.0,3.0,num=5,retstep=True) #(array([2.,2.25,2.5,2.75,3.]),0.25)

复制代码

zeros(),ones(),empty(),eye(),identity(),diag()

• zeros(),ones(),empty()三者用法一样，np.zeros(3,dtype=int) np.zeros((2,3))
  
• 使用empty()时需要对生成的每一个数进行重新赋值，否则即为随机数，所以慎重使用
  
• np.eye(2,3,k=1)he np.identity(3) : np.identity只能创建方形矩阵，np.eye可以创建矩形矩阵，且k值可以调节，为1 的对角线的位置偏离度，0居中，1向上偏离1,2向上偏离2，以此类推，-1向下偏离。值的绝对值过大就偏离出去了，整个矩阵就全是0了。np.diag可以创建对角矩阵。
  

数组的索引、切片

ndarray的索引、切片与list稍不同，他只有一个'[]'代码如下：

1. arr = np.array([ [[1, 2, 3],[4, 5, 6]], [[7, 8, 9],[10, 11, 12]] ])
2. list1 = [ [[1, 2, 3],[4, 5, 6]], [[7, 8, 9],[10, 11, 12]] ]
3. # 以下两种方法取值相同
4. a1 = arr[0, :]
5. b1 = arr[0][:]
6. print(list1[0][:])  # list只能用两个中括号来取值
7. print(a1, b1) # [[1, 2, 3][4, 5, 6]]

复制代码

1. a2 = arr[0, 0, 0]
2. print(a2) # 1

复制代码

可以看到ndarray的切片索引方法就是：对象[x, y, z, …]先行后列,依据对象的纬度输入的参数也不同。对于ndarray来说，以下两种索引方式均可以。

1. a = [[1, 2, 3],[4, 5, 6]], [[7, 8, 9],[10, 11, 12]]
2. b = np.array(a)
3. print(b[0, 1])  # array([4, 5, 6])
4. print(b[0][1])  # array([4, 5, 6])

复制代码

而对于二维的list而言，只能使用[][][] []索引

1. a = [[1, 2, 3],[4, 5, 6]], [[7, 8, 9],[10, 11, 12]]
2. # b = np.array(a)
3. # print(a[0, 1]), 该种索引方式会报错
4. print(a[0][1])  # [4, 5, 6]

复制代码

形状修改

通过ndarray.T可以实现一个矩阵的转置，代码如下：

1. arr = np.array([[1, 2],[3, 4]])
2. arr.T  # [[1, 3],[2, 4]]

复制代码

可以通过ndarray.reshapre()将arr变成一个1行4列的数组，reshape()实际上是将原来的数组压平成一维数组，然后再重新排序成目标形状，但不改变原数组。代码如下：

1. new_arr = arr.reshape([1, 4])
2. new_arr  # [[1, 2, 3, 4]]

复制代码

也可以通过ndarray.resize()实现改变结构，但是resize()会改变原数组，而不是直接返回一个新数组。代码如下：

1. arr.resize([1, 4])
2. arr  # [[1, 2, 3, 4]]

复制代码

通过np.repeat(a,reps,axis)，可以实现对原数组的复制、重构。其中a是目标数组，reps是重复的次数，axis标识沿某个方向复制。若axis=0，则沿第0个维度变化的方向复制，即增加了行数，若axis=None，则原数组会展平成一维数组，代码如下：

1. arr = np.array([[1, 2], [3, 4]])
2. flat_arr = np.repeat(arr, 2)
3. flat_arr  # [1, 1, 2, 2, 3, 3, 4, 4]

复制代码

1. re_arr = np.repeat(arr, 2, axis = 1)
2. re_arr  # [[1, 1, 2, 2], [3, 3, 4, 4]]

复制代码

通过np.tile(a, reps)，以可以实现对通过复制原数组构建新的数组，其中a是目标数组，reps是重复的次数。相较于np.repeat()，np.tile()的参数更少，但而这实现的功能是类似的，但其复制的规则不同，np.tile()是对整个array进行复制，np.repeat()是对其中的元素进行复制代码如下：

1. arr = np.array([[1, 2], [3, 4]])
2. flat_arr = np.tile(arr, 2)
3. flat_arr  # [1, 1, 2, 2, 3, 3, 4, 4]

复制代码

1. tile_arr = np.tile(arr, (2, 1))
2. tile_arr  # [[1, 2], [3, 4], [1, 2], [3, 4]]

复制代码

通过np.concatenate((a, b), axis)可以实现对数组的连接,其中a、b分别标识两个数组；axis表示沿着第几个维度叠加，例如，axis=0时，即沿第0个维度变化的方向相加，代码如下：

1. a = [[1, 2], [3, 4]]
2. b = [[10, 11], [12, 13]]
3. res1 = np.concatenate((a, b), axis = 0)
4. res1  # [[1, 2], [3, 4], [10, 11], [12, 13]]

复制代码

1. res2 = np.concatenate((a, b), axis = 1)
2. res2  # [[1, 2, 10, 11], [3, 4, 12, 13]]

复制代码

此外，np.vstack((a, b))的作用与np.concatenate((a, b), axis = 0)相似，np.hstack((a, b))的作用与np.concatenate((a, b), axis = 1)相似,代码如下：

1. v_res = np.vstack((a, b))
2. v_res  # [[1, 2], [3, 4], [10, 11], [12, 13]]

复制代码

1. h_res = np.hstack((a, b))
2. h_res  # [[1, 2, 10, 11], [3, 4, 12, 13]

复制代码

类型修改

首先生成一个数组，代码如下：

1. # 生成数组
2. arr = np.array([[1, 2], [3, 4]])

复制代码

可以通过ndarray.astype(str)将这个数组中的每个元素都变成string类型，该方法不改变原数组，而是返回一个新数组，代码如下：

1. arr1 = arr.astype(str)
2. arr1  # [['1' '2'], ['3' '4']]

复制代码

数组的通用函数

通过np.unique()可以实现对一个现有数组，除去其中重复的元素，返回一个没有重复元素的一维数组，且这个方法不会改变原数组，代码如下：

1. arr = np.array([[1, 1, 2, 3],[1, 22, 34, 5]])
2. unique = np.unique(arr)
3. unique  # [1, 2, 3, 5, 22, 34]

复制代码

如果按某个维度去重，则使用axis指定去重维度即可，代码如下：

1. a = [[1, 2, 3],[4, 5, 6]], [[1, 2, 3],[4, 5, 6]]
2. b = np.array(a)
3. c = np.unique(b, axis=0)
4. print(c)  # array([[[1, 2, 3], [4, 5, 6]]])

复制代码

通过np.intersect1d()和np.union1d()，可以分别实现求两个矩阵的交集和并集。代码如下：

1. a = [1, 2, 3, 4]
2. b = [3, 4, 5, 6]
3. print(np.intersect1d(a, b))  # [3, 4]
4. print(np.union1d(a, b))  # [1, 2, 3, 4, 5, 6]

复制代码

Numpy中还有一些常用的一元函数、二元函数，在原数组进行操作，直接修改原数组的元素。np.abs()，可以实现计算浮点数、整数或复数的绝对值.

1. a = [-1, 2, -3, 4]
2. print(np.abs(a))  # [1, 2, 3, 4]

复制代码

np.sqrt()，可以实现计算元素的平方根，相当于Python中的“ ** ”的反函数

1. b = [3, 4, 5, 6]
2. print(np.sqrt(b))  # [1.73205081, 2, 2.23606798, 2.44948974]
3. print(2**2)

复制代码

np.square()计算各元素的平方，np.exp()可以计算各元素的e指数，np.power(arr, t)可以计算数组中各元素t次方

1. # np.square()计算各元素的平方，np.exp()可以计算各元素的e指数，np.power(arr, t)可以计算数组中各元素t次方
2. a = [-1, 2, -3, 4]
3. print(np.square(a))  # [1, 4, 9, 16]
4. print(np.exp(a))  # [3.67879441e-01, 7.38905610e+00, 4.97870684e-02, 5.45981500e+01]
5. print(np.power(a, 3)) # [ -1, 8, -27, 64]

复制代码

np.isnan()用于判断数组中哪些元素是空值

1. c = [1, np.nan, 3, 5]
2. print(np.isnan(c))  # [False, True, False, False]
3. np.sum(np.isnan(c))

复制代码

np.where()可以对数组进行筛选，有两种用法：
1、np.where(condition, x, y)：x, y是两个数组，condition指选择条件，若满足条件则输出x，否则，输出y；
2、np.where(condition)：condition是一个条件，输出数组中满足条件的下标。

1. a = [[1, 2], [3, 0]]
2. b = [[7, 8], [9, 1]]
3. c = [1, 2, 3, 4]
4. print(np.where([[True, False], [False, False]], a, b))  # [[1, 2], [9, 0]]
5. np.where(np.array(c)>2)

复制代码

1. c = np.array(a)
2. np.where(c > 1)

复制代码

输出结果：

1. (array([0, 1], dtype=int64), array([1, 0], dtype=int64))

复制代码

Numpy也实现了三角函数的计算，np.sin()，np.cos()，np.tan()

1. a = [-1, 2, -3, 4]
2. print(np.sin(a))  # [-0.84147098, 0.90929743, -0.14112001, -0.7568025 ]
3. print(np.cos(a))  # [ 0.54030231, -0.41614684, -0.9899925, -0.65364362]
4. print(np.tan(a))  # [-1.55740772, -2.18503986, 0.14254654, 1.15782128]

复制代码

线性代数

NumPy的中的np.linalg模块实现了许多矩阵的基本操作，如：求对角线元素，求对角线元素的和（求迹）、矩阵乘积、求解矩阵行列式等。
首先生成两个数组，代码如下：

1. # 生成两个数组
2. a = [1, 2, 3]
3. b = [[1, 3, 9], [2, 7, 0], [4, 3, 2]]

复制代码

通过np.diag(matrix)，matirx为一个矩阵，当matrix为二维数组时，以一维数组的形式返回方阵的对角线；当matrix为一维数组时，则返回非对角线元素均为0的方阵。

1. print(np.diag(a))  # [[1, 0, 0], [0, 2, 0], [0, 0, 3]]

复制代码

1. print(np.diag(b))  # [1, 7, 2]

复制代码

通过np.trace()，可以计算矩阵对角线元素的迹

1. print(np.trace(b))  # 10

复制代码

通过np.dot()可以实现矩阵乘积

1. print(np.dot(b, a))  # [34, 16, 16]

复制代码

通过np.det()可以计算矩阵的行列式

1. np.linalg.det(b)  # -196.00000000000009

复制代码

np.linalg.eig()可以计算方阵的特征值、特征向量

1. eig = np.linalg.eig(b)

复制代码

1. array([-4.40641364,  9.92452468,  4.48188896])
2. # 特征值
3. eig[0]  # [-4.40641364, 9.92452468, 4.48188896]

复制代码

1. # 特征向量
2. eig[1]  # [[0.86881121, -0.6982852, 0.69750503], [-0.15233731,  -0.47753756, -0.55399068], [-0.47112676, -0.53325009, 0.4545119]]

复制代码

np.linalg.inv()可以计算矩阵的逆

1. np.linalg.inv(b)  # [[-0.07142857, -0.10714286, 0.32142857], [0.02040816, 0.17346939, -0.09183673], [0.1122449, -0.04591837, -0.00510204]]

复制代码

np.linalg.solve(A，b)可以求解线性方程组Ax=b，A为一个方阵

1. np.linalg.solve(b,a)  # [0.67857143, 0.09183673, 0.00510204]

复制代码

np.linalg.svd(a, full_matrices = 1, compute_uv = 1)可以用于矩阵的奇异值分解，返回该矩阵的左奇异值（u）、奇异值（s）、右奇异值（v）

1. svd = np.linalg.svd(b)
2. svd

复制代码

统计分析

1） 通过np.sum(a, axis)计算数组a沿指定轴的和；
2） np.mean(a,axis)计算数组a沿指定轴的平均值；
3） min(axis)和a.max(axis)用于获取数组a，沿指定轴的最小值和最大值；
4） np.std(a,axis)计算数组a沿指定轴的标准差；
5） np.var(a,axis)计算数组a沿指定轴的方差；
6） np.argmin(a,axis)和np.argmax(a,axis)分别用于获取数组a，沿指定轴的最小值和最大值的索引。
注：axis=None时，会返回所有元素的和；axis=0时，会沿着第0个维度（也就是列）的变化方向进行计算，即按列求和；axis=1时，则为按行求和，以此类推。

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

复制代码

1. # 通过np.sum(a, axis)计算数组a沿指定轴的和
2. print(np.sum(a))  # 21
3. print(np.sum(a, axis=0))  # [5, 7, 9]

复制代码

1. #  np.mean(a,axis)计算数组a沿指定轴的平均值
2. print(np.mean(a, axis=1))  # [2, 5]

复制代码

1. # min(axis)和a.max(axis)用于获取数组a，沿指定轴的最小值和最大值
2. print(a.min(axis=0))  # [1, 2, 3]

复制代码

1. #  np.std(a,axis)计算数组a沿指定轴的标准差
2. print(np.std(a, axis=1))  # [0.81649658, 0.81649658]

复制代码

1. #  np.argmin(a,axis)和np.argmax(a,axis)分别用于获取数组a，沿指定轴的最小值和最大值的索引
2. print(np.argmax(a, axis=1))  # [2, 2]

复制代码

公众号：愚生浅末

欢迎关注公众号：愚生浅末

来源:https://www.cnblogs.com/kohler21/p/18349772
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！