numpy用法小结

前言

　　个人感觉网上对numpy的总结感觉不够详尽细致，在这里我对numpy做个相对细致的小结吧，在数据分析与人工智能方面会有所涉及到的东西在这里都说说吧，也是对自己学习的一种小结！

numpy用法的介绍

　　安装部分我就不说了，装个pip，使用命令pip install numpy就可以安装了，在Ubuntu中可能会出现没有权限的提示，直接加上sudo即可，以下讲解都是建立在python3平台的讲解，python2类似，python3中安装的时候使用sudo pip3 install numpy即可。

　　首先，numpy是个求解数学矩阵，做矩阵计算

1.genfromtxt

　　numpy numpy.genfromtxt("")，这里我们讲解下，genfromtxt函数的意思是读取文件信息，用来处理数据信息，可以处理数据文件

举个例子：

import numpy

world_alcohol = numpy.genfromtxt("world_alcohol.txt",delimiter = ",",dtype = str)

print(type(world_alcohol))
print(world_alcohol)
print(help(numpy.genfromtxt))

打印结果如下：

<class 'numpy.ndarray'>
[['Year' 'WHO region' 'Country' 'Beverage Types' 'Display Value']
 ['1986' 'Western Pacific' 'Viet Nam' 'Wine' '0']
 ['1986' 'Americas' 'Uruguay' 'Other' '0.5']
 ...,
 ['1987' 'Africa' 'Malawi' 'Other' '0.75']
 ['1989' 'Americas' 'Bahamas' 'Wine' '1.5']
 ['1985' 'Africa' 'Malawi' 'Spirits' '0.31']]
Help on function genfromtxt in module numpy.lib.npyio:

genfromtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=None, replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None)
    Load data from a text file, with missing values handled as specified.

    Each line past the first `skip_header` lines is split at the `delimiter`
    character, and characters following the `comments` character are discarded.

    Parameters
    ----------
    fname : file, str, pathlib.Path, list of str, generator
        File, filename, list, or generator to read.  If the filename
        extension is `.gz` or `.bz2`, the file is first decompressed. Note
        that generators must return byte strings in Python 3k.  The strings
        in a list or produced by a generator are treated as lines.
    dtype : dtype, optional
        Data type of the resulting array.
        If None, the dtypes will be determined by the contents of each
        column, individually.
    comments : str, optional
        The character used to indicate the start of a comment.
        All the characters occurring on a line after a comment are discarded
    delimiter : str, int, or sequence, optional
        The string used to separate values.  By default, any consecutive
        whitespaces act as delimiter.  An integer or sequence of integers
        can also be provided as width(s) of each field.
-- More  --

我解释一下上面的用法，genfromtxt传入了三个参数，第一个参数是数据文件，名为world_alcohol.txt，该数据文件有需要的同学可以加我好友私聊我，或者把你的请求发邮箱至i_love_sjtu@qq.com

然后delimiter是分隔符，由于数据集中的数据是用逗号分隔的，所以设定参数delimiter=','，dtype是获取数据类型，数据集中的类型为str

print(type(world_alcohol))打印数据文件的数据类型

print(world_alcohol)打印数据集

print(help(numpy.genfromtxt))打印genfromtxt用法

加入skip_header，跳转至以1开头的数据

 

import numpy
world_alcohol = numpy.genfromtxt("world_alcohol.txt",delimiter=",",dtype=str,skip_header=1)
print(world_alcohol)

 

打印结果如下：

[['1986' 'Western Pacific' 'Viet Nam' 'Wine' '0']
 ['1986' 'Americas' 'Uruguay' 'Other' '0.5']
 ['1985' 'Africa' "Cte d'Ivoire" 'Wine' '1.62']
 ...,
 ['1987' 'Africa' 'Malawi' 'Other' '0.75']
 ['1989' 'Americas' 'Bahamas' 'Wine' '1.5']
 ['1985' 'Africa' 'Malawi' 'Spirits' '0.31']]

2.shape

　　xxx.shape 显示的功能是查看矩阵或者数组的维数

举个例子：

import numpy

vector = numpy.array([5,10,15,20])
matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])

print(vector)
print(matrix)
print(vector.shape)
print(matrix.shape)

打印结果如下：

[ 5 10 15 20]
[[ 5 10 15]
 [20 25 30]]
(4,)
(2, 3)
[Finished in 0.6s]

显示出当前vector的维度是一维矩阵
matrix的维度是2行3列

3.索引

一维数组的索引：与Python的列表索引功能相似

先举个例子：

import numpy
world_alcohol = numpy.genfromtxt("world_alcohol.txt",delimiter=",",dtype=str,skip_header=1)

uruguay_other_1986 = world_alcohol[1,4]

third_country = world_alcohol[2,2]

print(uruguay_other_1986)

print(third_country)

打印结果如下：

0.5
Cte d'Ivoire

uruguay_other_1986取值的时候取的是第一个列表中的第四个值(从0开始算)
third_country取值的时候取的是第二个列表中的第二个值(从0开始算)

4.切片

举例子：

import numpy
vector = numpy.array([5,10,15,20])
print(vector[0:3])

打印结果如下：

[ 5 10 15]

这个和python中切片效果一样，取的是左闭右开的界线

下一个例子：

import numpy
matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])
print(matrix[:,1])

打印结果如下：

[10 25 40]

:表示选取所有的行 逗号隔开 然后取列 取第一列(从0开始计算)

下一个例子：

import numpy
matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])
print(matrix[:,0:2])

打印结果如下：

[[ 5 10]
 [20 25]
 [35 40]]

这个意思是:表示选取所有的行 逗号隔开 然后取列 这里用到了切片 取的是从第零列开始到第二列(小于2) 实际上取的就是前两列

下一个例子：

import numpy
matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])
print(matrix[1:3,0:2])

打印结果如下：

[[20 25]
 [35 40]]

这个意思是我们选取的行是第一行到第三行(小于3) 这里用到了切片 然后取列 这也用到了切片 取的是从第零列开始到第二列(小于2) 实际上取的就是前两列

5.布尔类型的相关判断

举个例子：

import numpy
vector = numpy.array([5,10,15,20])
vector == 10

打印结果如下：

>>array([False,  True, False, False], dtype=bool)

返回一个布尔型结果 判断了该矩阵中是否有值等于10

== 相当于对矩阵中的每一个元素都进行了一个判断

下一个例子：

import numpy
matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])

matrix == 25

打印结果如下：

array([[False, False, False],
       [False,  True, False],
       [False, False, False]], dtype=bool)

解释的原理和上述一样

下一个例子：

import numpy 
vector = numpy.array([5,10,15,20])

equal_to_ten = (vector == 10)

print(equal_to_ten)

print(vector[equal_to_ten])

打印结果如下：

[False  True False False]
[10]

意思是 vector == 10 直接对矩阵的值做了个判断 把布尔类型的矩阵传递给equal_to_ten
然后的话打印结果为布尔类型的矩阵 这个布尔类型是一个索引 我们打印这个vector[布尔类型的索引]即可找回原值 返回真实值

下一个例子：

import numpy
matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])

second_conlumn_25 = (matrix[:,1] == 25)
print(second_conlumn_25)
print(matrix[second_conlumn_25, :])

打印结果如下：

[False  True False]
[[20 25 30]]

意思是 :表示选取所有的行 逗号隔开 然后取列 取的是第一列(从0开始) 然后直接对这一列的值进行判断 判断这一列
中的元素是否等于25 并将其布尔类型的值传递给second_conlumn_25

然后打印出的second_conlumn_25的结果为一个布尔类型的列表

而把second_conlumn_25当作索引值 我们去寻找有25的这一行 逗号隔开 :表示直接选取这一行的数据 然后打印出来

下一个例子：

import numpy
vector = numpy.array([5,10,15,20])
equal_to_ten_and_five = (vector == 10) & (vector == 5)
print(equal_to_ten_and_five)

打印结果如下：

[False False False False]

意思是查找当前的这个矩阵中的数既等于10又等于5的数 显然不存在 所以全部输出False

下一个例子：

import numpy
vector = numpy.array([5,10,15,20])
equal_to_ten_or_five = (vector == 10) | (vector == 5)
print(equal_to_ten_or_five)

打印结果如下：

[ True  True False False]

意思是查找当前的这个矩阵中的数等于10或者等于5的数 显然不存在 所以输出True True  False  False

6.dtype与astype

　　dtype 输出的是矩阵中的数据类型 

举个例子：

import numpy
vector = numpy.array([5,10,15,20])
print(vector.dtype)

打印结果如下：

int32

如果我们想转换矩阵中的数据类型 我们应该使用astype进行转换

举个例子：

import numpy

vector = vector.astype(float)

print(vector.dtype)

打印结果如下：

float64

这样就OK了！！！

7.min与max

min求解该矩阵中的最小值

举个例子：

import numpy
vector = numpy.array([5,10,15,20])
vector.min()

打印结果如下：

>>5

max求解该矩阵中的最大值

举个例子：

import numpy
vector = numpy.array([5,10,15,20])
vector.max()

打印结果如下：

>>20

8.sum

　　sum 可以指定了一个维度 对行或者列求和

举个例子：

import numpy

matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])

matrix.sum(axis=1)

打印结果如下：

>>array([ 30,  75, 120])

指定了一个维度 对行求和

下个例子：

import numpy

matrix = numpy.array([[5,10,15],[20,25,30],[35,40,45]])

matrix.sum(axis=0)

打印结果如下：

>>array([60, 75, 90])

指定了一个维度 axis = 0 行号为0 相当于对列求和

9.reshape

　　reshape给数组一个新的形状而不改变其数据

举个例子：

import numpy as np

print(np.arange(15))

a = np.arange(15).reshape(3,5)

print(a)

打印结果如下：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

np是指定了numpy的别名，np.arange依次造出十五个元素 变成了一个向量的形式，reshape函数表明，我们要生成一个3行5列这样的矩阵

此时我们输入如下语句：

print(a.shape)

将会打印出如下结果：

(3, 5)

10.ndim

　　ndim中的dim是英文dimension维度的缩写，表示打印出矩阵的维度

举个例子：

import numpy as np
a = np.arange(15).reshape(3,5)
print(a.ndim)

打印结果如下：

>>2

打印出当前矩阵的维度为2

11.size

　　size打印出矩阵的元素个数

举个例子：

import numpy 
a = np.arange(15).reshape(3,5)
print(a.size)

打印结果如下：

>>15

12.zeros

　　初始化一个矩阵,可以传入参数行和列，生成一个零矩阵

举个例子：

import numpy as np
np.zeros((3,4))

打印结果如下：

array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])

初始化一个矩阵，生成一个三行四列的零矩阵

13.ones

　　初始化一个矩阵，可以传入参数行和列，还可以传入数据类型dtype

举个例子：

import numpy as np
np.ones((2,3,4),dtype=np.int32)

打印结果如下：

array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

构造出一个三维矩阵 矩阵中的元素均为1 然后我们用dtype指定元素类型为int32

14.arange

　　arange通过定义起点 终点 步长 然后我们构造出了一个数组 右边界不可以取等号，取的是左闭右开区间

举个例子：

import numpy as np
np.arange(10,30,5)

打印结果如下：

array([10, 15, 20, 25])

15.random

　　random构造出一个矩阵 产生的值默认在-1-1之间

举个例子：

import numpy as np 
np.random.random((2,3))

打印结果如下：

array([[ 0.77296788,  0.00748236,  0.59905565],
       [ 0.05577331,  0.08520327,  0.58034632]])

16.linspace

举个例子：

from numpy import pi
np.linspace(0,2*pi,100)

打印结果如下：

array([ 0.        ,  0.06346652,  0.12693304,  0.19039955,  0.25386607,
        0.31733259,  0.38079911,  0.44426563,  0.50773215,  0.57119866,
        0.63466518,  0.6981317 ,  0.76159822,  0.82506474,  0.88853126,
        0.95199777,  1.01546429,  1.07893081,  1.14239733,  1.20586385,
        1.26933037,  1.33279688,  1.3962634 ,  1.45972992,  1.52319644,
        1.58666296,  1.65012947,  1.71359599,  1.77706251,  1.84052903,
        1.90399555,  1.96746207,  2.03092858,  2.0943951 ,  2.15786162,
        2.22132814,  2.28479466,  2.34826118,  2.41172769,  2.47519421,
        2.53866073,  2.60212725,  2.66559377,  2.72906028,  2.7925268 ,
        2.85599332,  2.91945984,  2.98292636,  3.04639288,  3.10985939,
        3.17332591,  3.23679243,  3.30025895,  3.36372547,  3.42719199,
        3.4906585 ,  3.55412502,  3.61759154,  3.68105806,  3.74452458,
        3.8079911 ,  3.87145761,  3.93492413,  3.99839065,  4.06185717,
        4.12532369,  4.1887902 ,  4.25225672,  4.31572324,  4.37918976,
        4.44265628,  4.5061228 ,  4.56958931,  4.63305583,  4.69652235,
        4.75998887,  4.82345539,  4.88692191,  4.95038842,  5.01385494,
        5.07732146,  5.14078798,  5.2042545 ,  5.26772102,  5.33118753,
        5.39465405,  5.45812057,  5.52158709,  5.58505361,  5.64852012,
        5.71198664,  5.77545316,  5.83891968,  5.9023862 ,  5.96585272,
        6.02931923,  6.09278575,  6.15625227,  6.21971879,  6.28318531])

指定一个区间 我们要生成100个数 指定了一个值 起点值为0 终点值为2*pi
linspace意思就是在区间里面造出100个值 这100个值间隔是平均的

再举一个例子：

from numpy import pi
np.sin(np.linspace(0,2*pi,100))

打印结果如下：

array([  0.00000000e+00,   6.34239197e-02,   1.26592454e-01,
         1.89251244e-01,   2.51147987e-01,   3.12033446e-01,
         3.71662456e-01,   4.29794912e-01,   4.86196736e-01,
         5.40640817e-01,   5.92907929e-01,   6.42787610e-01,
         6.90079011e-01,   7.34591709e-01,   7.76146464e-01,
         8.14575952e-01,   8.49725430e-01,   8.81453363e-01,
         9.09631995e-01,   9.34147860e-01,   9.54902241e-01,
         9.71811568e-01,   9.84807753e-01,   9.93838464e-01,
         9.98867339e-01,   9.99874128e-01,   9.96854776e-01,
         9.89821442e-01,   9.78802446e-01,   9.63842159e-01,
         9.45000819e-01,   9.22354294e-01,   8.95993774e-01,
         8.66025404e-01,   8.32569855e-01,   7.95761841e-01,
         7.55749574e-01,   7.12694171e-01,   6.66769001e-01,
         6.18158986e-01,   5.67059864e-01,   5.13677392e-01,
         4.58226522e-01,   4.00930535e-01,   3.42020143e-01,
         2.81732557e-01,   2.20310533e-01,   1.58001396e-01,
         9.50560433e-02,   3.17279335e-02,  -3.17279335e-02,
        -9.50560433e-02,  -1.58001396e-01,  -2.20310533e-01,
        -2.81732557e-01,  -3.42020143e-01,  -4.00930535e-01,
        -4.58226522e-01,  -5.13677392e-01,  -5.67059864e-01,
        -6.18158986e-01,  -6.66769001e-01,  -7.12694171e-01,
        -7.55749574e-01,  -7.95761841e-01,  -8.32569855e-01,
        -8.66025404e-01,  -8.95993774e-01,  -9.22354294e-01,
        -9.45000819e-01,  -9.63842159e-01,  -9.78802446e-01,
        -9.89821442e-01,  -9.96854776e-01,  -9.99874128e-01,
        -9.98867339e-01,  -9.93838464e-01,  -9.84807753e-01,
        -9.71811568e-01,  -9.54902241e-01,  -9.34147860e-01,
        -9.09631995e-01,  -8.81453363e-01,  -8.49725430e-01,
        -8.14575952e-01,  -7.76146464e-01,  -7.34591709e-01,
        -6.90079011e-01,  -6.42787610e-01,  -5.92907929e-01,
        -5.40640817e-01,  -4.86196736e-01,  -4.29794912e-01,
        -3.71662456e-01,  -3.12033446e-01,  -2.51147987e-01,
        -1.89251244e-01,  -1.26592454e-01,  -6.34239197e-02,
        -2.44929360e-16])

指定一个区间 我们要生成100个数 指定了一个值 起点值为0 终点值为2*pi
linspace意思就是在区间里面造出100个值 这100个值间隔是平均的 然后最后我们对这个值取正弦即可

17.floor与ravel

举个例子：

import numpy as np
a = np.floor(10*np.random.random((3,4)))
print(a)
print('------')
print(a.ravel())
print('------')
a.shape = (6,2)
print(a)
print('------')
print(a.T)

打印结果如下：

[[ 4.  9.  0.  4.]
 [ 8.  5.  4.  9.]
 [ 1.  9.  2.  6.]]
------
[ 4.  9.  0.  4.  8.  5.  4.  9.  1.  9.  2.  6.]
------
[[ 4.  9.]
 [ 0.  4.]
 [ 8.  5.]
 [ 4.  9.]
 [ 1.  9.]
 [ 2.  6.]]
------
[[ 4.  0.  8.  4.  1.  2.]
 [ 9.  4.  5.  9.  9.  6.]]

random.random((3,4))是建立一个3行4列的一个区间范围在-1~1的矩阵
然后我们如果觉得值太小了 就可以在np这里*10 floor操作是向下取整

ravel 是将一个矩阵拉平成一个向量 即用向量的形式表示这个矩阵

而a.shape(6,2)又将一个向量转换为一个6*2的矩阵 

a.T表示求矩阵a的一个转置矩阵 行和列进行变换

如果一个向量中的元素个数已知 我们已经确定了其中的行数或者列数 其实此时另外一个数已经默认确定了 我们不想去计算那个列数或者行数
是多少时 我们应该怎么办呢 我们如果已经确定了其中的行数或者列数 我们只需要在另外一个位置写上-1就好了 此时计算机会自动帮你计算好这个值

18.hstack与vstack

　　np.hstack((a,b)) 将a矩阵和b矩阵进行横向拼接

　　np.vstack((a,b))将a矩阵和b矩阵进行纵向拼接

举个例子：

import numpy as np
a = np.floor(10*np.random.random((2,12)))
print(a)
print('------')
print(np.hsplit(a,3))
print('------')
print(np.hsplit(a,(3,4)))
a = np.floor(10*np.random.random((12,2)))
print('------')
print(a)
np.vsplit(a,3)

打印结果如下：

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

[array([[ 1.,  8.],
        [ 7.,  4.],
        [ 0.,  5.],
        [ 9.,  1.]]), array([[ 6.,  5.],
        [ 4.,  5.],
        [ 1.,  2.],
        [ 0.,  1.]]), array([[ 3.,  6.],
        [ 2.,  7.],
        [ 7.,  8.],
        [ 7.,  6.]])]

hsplit是对行进行切分 a表示待切分的行参数 3表示切分成三份

np.hsplit(a,(3,4)) 传入元组 指定位置进行切割

vsplit是对列进行切分 a表示待切分的行参数 3表示切分成三份

19.view与copy

　　view是浅复制

举个例子：

import numpy as np
a = np.arange(12)

b = a

print(b is a)

b.shape = 3,4

print(a.shape)

print(id(a))

print(id(b))

打印结果如下：

True
(3, 4)
3144967327792
3144967327792

我们可以发现a与b的地址是相同的，这个就是所谓的深复制

让我再看看下面这个例子：

import numpy
a = np.arange(12)
c = a.view()
print(c is a) 
c.shape = 2,6
print(a.shape)
c[0,4] = 1234
print(a)
print(id(a))
print(id(c))

打印结果如下：

False
(12,)
[   0    1    2    3 1234    5    6    7    8    9   10   11]
2391025174608
2391025175008

我们可以看出浅复制不会复制a的地址到c，改变c的值不会影响到a

再看下一个写法：

import numpy as np
a = np.arange(12)
d = a.copy()
d is a

打印结果如下：

False

从结果我们可以看出，copy也是属于浅拷贝

20.argmax

　　argmax 索引最大值的位置

举个例子：

import numpy as np
data = np.sin(np.arange(20)).reshape(5,4)
print(data)
ind = data.argmax(axis=0)
print(ind)
data_max = data[ind,range(data.shape[1])]
print(data_max)

打印结果如下：

[[ 0.          0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
 [ 0.98935825  0.41211849 -0.54402111 -0.99999021]
 [-0.53657292  0.42016704  0.99060736  0.65028784]
 [-0.28790332 -0.96139749 -0.75098725  0.14987721]]
[2 0 3 1]
[ 0.98935825  0.84147098  0.99060736  0.6569866 ]

argmax 索引最大值的位置

data.argmax(axis=0) axis=0意思是指定列去索引 找出最大值返回索引值的位置

21.tile

　　tile 对当前的行和列进行扩展

举个例子：

import numpy as np
a = np.arange(0,40,10)
print(a)
b = np.tile(a,(3,5))
print(b)

打印结果如下：

[ 0 10 20 30]
[[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
 [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
 [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]]

我们可以看出，矩阵由原来的一维扩展到了三行五列

22.sort与argsort　

　　sort 对当前的数组按照行的维度进行排序(因为axis=1)

　　argsort 是对值的索引进行排序 默认是值从小到大 然后按照值排序获取索引 输出索引

举个例子：

import numpy as np
a = np.array([[4,3,5],[1,2,4]])
print(a)
print('------')
b = np.sort(a,axis=1)
print(b)
a.sort(axis=1)
print('------')
print(a)
a = np.array([4,3,1,2])
j = np.argsort(a)
print('------')
print(j)
print('------')
print(a[j])

打印结果如下：

[[4 3 5]
 [1 2 4]]
------
[[3 4 5]
 [1 2 4]]
------
[[3 4 5]
 [1 2 4]]
------
[2 3 1 0]
------
[1 2 3 4]

以上是我在运用中所用到的一些函数及用法，欢迎大家指正批评，如果有需要改进的地方，还希望不吝赐教，如果觉得本文对你有用，别忘记关注订阅推荐博主，谢谢大家的支持！！！