Numpy快速入门（np）！看这一篇就够了

基本信息：

全称：Numerical Python

特点：开源科学计算库，代码简洁高效！

基本操作：

（1）导入numpy并查看版本信息

import numpy as np

np.__version__

（2）python原生代码与numpy之间性能的对比

①代码对比

我们以求“1-50之间平方和”这个问题为例：

1.python原生代码

n=50
list1 =[i for i in range(n+1)]
sum=0
for i in list1:
    sum+=i**2
sum

2.numpy

n=50
array1=np.arange(n+1)
sum_result=np.sum(array1**2)
sum_result

直观感受：

numpy快读定义一个长度为50的数组，而不需要for循环；

numpy加和不需要for循环，自带sum函数。

②执行效率对比

在代码最前面加上：

%%timeit

1.python原生代码

2.numpy

当n更大的时候，差距会更明显！

（3）Numpy数组创建

①一维数组（向量）

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

②二维数组（矩阵）

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

③输出数组维度ndim函数

举例：

arr_Dimension1.ndim

arr_Dimension2.ndim

④查看数组的形状shape

⑤输出数组中元素的总个数

arr_Dimension1.size

arr_Dimension2.size

⑥输出数组元素的数据类型

arr_Dimension1.dtype

arr_Dimension2.dtype

⑦创建便捷数组--全是1的数组ones

1.基础使用

np.ones(10)

默认创建的是浮点数。

2.指定数据类型（int）:

np.ones(10,dtype='int32')

3.创建二维ones数组：

np.ones(shape=(2,4))

也可以写成（可以去掉shape）：

np.ones((2,4))

4.根据已有数组创建相同形状的新数组（默认内容全是1）

np.ones_like(arr_Dimension2)

arr_Dimension2是前面我设置的二维数组(2行5列）。

⑧创建便捷数组--全是0的数组zeros

和⑦中完全一样，只需要将ones改成zeros

⑨生成相同元素的数组full

例如：

1：生成10个全是9999的一维数组

np.full(10,9999)

2：生成10个全是9999的二维数组（2行5列）

np.full((2,5),9999)

3.根据已有数组创建相同形状的新数组(内容我们自定义）

arr_Dimension2是前面我设置的二维数组(2行5列）。

⑩创建等差数组arange

1.创建0-9的数组

np.arange(10)

2.加上起始点以及步长

从下标1开始，10结束（包含1不包含10），步长为2

3.等差数组+reshape函数

np.arange(1,20,2).reshape(2,5)

⑪创建等差数组linspace

np.linspace(1,9,10)

第一个数必须是1，最后一个数必须是9，然后必须是10个数的数组。

⑫创建随机数组random

1.创建一个0-1之间的随机数

np.randaom.random()

2.创建多个0-1之间的随机数组成的一维数组

np.random.random(5)

创建5个0-1之间的随机数组成的一维数组。

3.创建多个0-1之间的随机数组成的二维数组

np.random.random((2,4))

⑬创建随机数组rand

rand与random的区别如下：

np.randaom.random()	np.randaom.rand()
np.randaom.random(5)	np.randaom.rand(5)
np.random.random((2,4))	np.random.rand(2,4)

前两个完全一样，但是第三个，也就是创建二维数组的时候，random必须是传入的元组，也就是有2个括号，而rand是直接传数字，也就是只有一个括号。

⑭创建随机“整数”数组randint

1.生成一个0-10之间的整数

np.random.randint(10)

2.生成一个10-20之间的随机整数(包含5不包含10）

np.random.randint(10,20)

3.生成10-20之间的多个随机数组成一维数组（以5个为例）

np.random.randint(10,20,size=5)

也可以把size简化掉：

np.random.randint(10,20,5)

3.生成10-20之间的多个随机数组成二维数组

生成2行5列的二维数组：

np.random.randint(10,20,size=(2,5))

也可以把size简化掉：

np.random.randint(10,20,(2,5))

⑮返回具有标准正态分布的随机数randn（均值为0，标准差为1）

1.生成一维数组

np.random.randn(5)

2.生成二维数组

np.random.randn(2,5)

⑯生成高斯分布的数组（均值和方差自己可以设置）

1.设置均值为2

np.random.normal(2)

没有指定标准差，所以值不固定。

2.设置均值2，标准差为5

np.random.normal(2,5)

可能是比2大也可能是比2小，最终计算出来的标准差是2就可以。

np.random.normal(2,0)

只有自己一个数，所以也只能是自己。

3.设置均值2，标准差为5多个数组成的一维数组

np.random.normal(2,5,10)

均值为2，标准差为5，10个数。

4.生成二维数组

np.random.normal(2,5,size=(2,5))

规定生成的是均值为2，标准差为5，（2行5列的二维数组）

同样，这个size也可以省略：

np.random.normal(2,5,(2,5))

⑰随机数种子seed(让random随机的数再次运行能和之前一样)

1.设置随机数种子

np.random.seed(999)

这个999也可以换成别的。

2.然后把这个随机数种子加在前面random代码的上面

之后每次random都具有“可再现性”了！

⑱返回具有均匀分布的随机数据uniform

1.没有参数默认返回0-1之间的随机数

np.random.uniform()

2.生成1~5之间的一个随机数

np.random.uniform(1,5)

3.生成一维数组(1~5之间,5个数）

np.random.uniform(1,5,5)

4.生成二维数组（1~5之间，2行5列）

np.random.uniform(1,5,(2,5))

（4）numpy的数组元素访问

一维数组：

拿之前创建好的一维数组为例：

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

①访问第0个元素

arr_Dimension1[0]

②访问第i（i<n）个元素

arr_Dimension1[2]

③访问最后一个元素

arr_Dimension1[-1]

④取出多个数据

1.基础操作

arr_Dimension1[0:5]

注意：包含左索引，不包含右索引。

2.对于第一个数索引0，左边可以省略不写

arr_Dimension1[:5]

3.从索引为5取到最后，则右边可以省略不写

arr_Dimension1[5:]

4:取倒数后几个数

arr_Dimension1[-3:]

这里代表的是倒数后3个数。

5：从头开始取到最后（取全部）

arr_Dimension1[:]

6：从头开始取到最后（取全部）步长为2

arr_Dimension1[::2]

7:数组倒序取值

arr_Dimension1[::-1]

二维数组：

二维数组如下：

arr_Dimension2=np.array([
    [1,2,3,4,5],
    [6,7,8,9,10],
    [11,12,13,14,15],
    [16,17,18,19,20],
    [21,22,23,24,25]
])
arr_Dimension2

注意下列操作中间右逗号！

①第一行第一列的元素

arr_Dimension2[0,0]

②取第一行的所有元素

arr_Dimension2[0]

③取最后一行元素

arr_Dimension2[-1]

④取第一列元素

arr_Dimension2[:,0]

⑤取最后一列元素

arr_Dimension2[:,-1]

⑥取前两行，前四列所有数据

arr_Dimension2[:2,:4]

⑦将所有的行倒序，所有的列也倒序

arr_Dimension2[::-1,::-1]

⑧切片操作的性质

与python中不同的是，numpy中切片中的值如果修改的话，原本数组的值也会被修改，反之亦然！

获取前两行前四列的值给arr_temp数组：

arr_temp=arr_Dimension2[:2,:4]
arr_temp

将arr_temp的第一个值修改为100：

arr_temp[0,0]=100
print(arr_temp)
print(arr_Dimension2)

可以发现：临时数组和原数组的第一个值都发生了变化，都变成了100。

⑨copy方法避免切片产生的绑定关系

使用copy的话，修改临时数组，原数组就不会受到影响了！

先恢复到原先的值：

arr_Dimension2[0,0]=1

1.使用copy方法

2.验证效果

arr_temp2[0,0]=100
print(arr_temp2)
print(arr_Dimension2)

可以发现，arr_Dimension2不受arr_temp2的影响了！

（5）numpy数组的合并与拆分操作

概念：

样本：每一行代表一个样本

特征：每一列代表一个特征

类别标记：每一行的最后一个单元格代表结果，也就是类别标记

①数组的合并方法1：concatenate（水平合并）

axis=0，代表的是按照行，这个时候axis可以不写。

使用concatenate进行的数组合并必须是同维度的，也就是一维合并一维，多维合并多维，要想让一维与多维合并，必须先将一维转化为多维！

举例两个数组：

arr1=np.array([
    [1,2,3,4,5],
    [6,7,8,9,10],
    [11,12,13,14,15],
    [16,17,18,19,20],
    [21,22,23,24,25]
])
arr1

arr2=np.array(
    [26,27,28,29,30]
)
arr2

1.先将一维数组arr2转换为二维数组并用arr3接收：

arr3=arr2.reshape(1,5)
arr3

2.arr1和arr3进行合并

np.concatenate((arr1,arr3))

可以发现，合并成功!

②数组的合并方法2：vstack（水平合并）

使用vstack合并数组的话，一维数组不需要转换为二维数组！

np.vstack((arr1,arr2))

注意：要是两个小括号！

③数组的合并方法2：hstack（竖直合并）

1.先创建一个行数与arr1一样的数组arr4

arr4=np.arange(1,6).reshape(5,1)
arr4

2.开始将arr1和arr4进行合并

np.hstack((arr1,arr4))

合并成功！

④数组的合并方法4：concatenate（竖直合并）

axis=1，代表的是按照列。

np.concatenate((arr1,arr4),axis=1)

可以发现，合并成功!

⑤数组的拆分split（按行拆分）axis=0

1.将最后一行拆掉，将arr1拆分成X1和X2：

X1,X2=np.split(arr1,[-1],axis=0)

2.将第i行(i=1第二行为例)拆掉，将arr1拆分成X1和X2：

X1,X2=np.split(arr1,[1],axis=0)

⑥数组的拆分split（按列拆分）axis=1

1.将最后一列拆掉，arr1拆分成X1和X2：

X1,X2=np.split(arr1,[-1],axis=1)

⑦数组的拆分vsplit（按行拆分）

1.拆分成2个数组X1，和X2，第一个索引范围是[0,2]，第二个索引范围是[2:]

X1,X2=np.vsplit(arr1,[2])

2.拆分成3个数组X1，X2和X3，第一个索引范围是[0,2]，第二个索引范围是[2:3]，第三个是[3:]

X1,X2,X3=np.vsplit(arr1,[2,3])

⑧数组的拆分hsplit（按列拆分）

 1.拆分成2个数组X1，和X2，第一个索引范围是[0,2]，第二个索引范围是[2:]

X1,X2=np.hsplit(arr1,[2])

2.拆分成3个数组X1，X2和X3，第一个索引范围是[0,2]，第二个索引范围是[2:3]，第三个是[3:]

X1,X2,X3=np.hsplit(arr1,[2,3])

（6）numpy数组矩阵运算（一元运算，二元运算与矩阵运算）

①一元运算

先创建一个numpy矩阵/数组：

arr1=np.linspace(1,9,6)
arr1

1.绝对值

np.abs(arr1)

2.开方

np.sqrt(arr1)

3.平方

np.square(arr1)

4.自然常数e的指数运算

np.exp(arr1)

5.对数运算（以e为底的自然对数ln）

np.log(arr1)

6.对数运算（以2为底的对数运算）

np.log2(arr1)

7.对数运算（以10为底的对数运算）

np.log10(arr1)

8.向上取整

np.ceil(arr1)

9.向下取整

np.floor(arr1)

10.四舍五入

np.round(arr1)

这个四舍五入并非传统意义上的四舍五入“奇进偶不进”，也就是1.5能进到2，但是2.5由于小数点前面是偶数，则2.5还是2，不能进位到3

验证：

arr_temp = np.array([1.5, 2.5, 4.3, 6.7, 8.9])
rounded_arr = np.round(arr_temp)
rounded_arr

11.正弦函数

np.sin(arr1)

12.余弦函数

np.cos(arr1)

12.正切函数

np.tan(arr1)

②二元运算

数组中的所有元素都参与运算！

1.加法

arr1+1

2.减法

arr1-1

3.乘法

arr1*2

4.除法

arr1/2

5.整除

arr1//2

6.取余

arr1%2

7.幂运算

以3次方为例：

arr1**3

③三元运算（矩阵运算）

先定义两个矩阵，arr1和arr2:

arr1=np.arange(0,16).reshape(4,4)
arr2=np.arange(16,32).reshape(4,4)

1.矩阵的加法

arr1+arr2

2.矩阵的减法

arr1-arr2

3.矩阵的乘法（对应元素相乘）

arr1*arr2

4.矩阵的点乘（线性代数的矩阵相乘）

arr1.dot(arr2)

5.矩阵相除

6.矩阵的转置

arr1.T

7.逆矩阵

注：逆矩阵和原矩阵相乘之后得到单位矩阵。

np.linalg.inv(arr1)

8.矩阵行列式

如果一个矩阵的行列式不为零，则该矩阵可逆；如果为零，则矩阵不可逆。

np.linalg.det(arr1)

9.矩阵的特征值和特征向量

特征值是矩阵的特征多项式的根，而特征向量是与对应特征值相对应的非零向量，当矩阵作用于这个向量时，结果是该特征向量的标量倍数。

np.linalg.eig(arr1)

10.创建单位矩阵

创建一个3x3的单位矩阵：

arr_temp=np.eye(3)
arr_temp

（7）numpy中的arg运算（取最值时候的自变量）

生成0-100之间的10个随机数：

arr1=(np.random.random(10))*100
arr1

①数组元素最小值及其索引

1.求最小值

np.min(arr1)

2.求最小值对应的索引

np.argmin(arr1)

②数组元素最大值及其索引

1.求最大值

np.max(arr1)

2.求最大值对应的索引

np.argmax(arr1)

（8）数组排序

1.创建有序数组

array1=np.arange(10)
array1

2.将有序数组打乱

np.random.shuffle(array1)
array1

3.对无序数组升序排序1

array2=np.sort(array1)

注意：我们可以发现，使用sort方法不能修改原先的数组，只能将他赋值给新数组array2才可以。

4.对无序数组升序排序2

使用np.sort()不会改变原数组，但是直接调用soet可以改变原数组。

5.降序排列

array1[::-1]

6.二维数组的排序

创建一个二维数组：

array1 = np.array(([1.5, 2.5, 4.3, 6.7, 8.9],[12, 25, 13, 17, 89]))
array1

对二维数组进行排序：

np.sort(array1)

对每一行分别进行从小到大的顺序排序。

对二维数组按照列进行排序：

np.sort(array1,axis=1)

（9）数组排序+arg运算

 ①生成0-100之间的10个随机数

arr1=(np.random.random(10))*100
arr1

②对数据进行排序，并返回索引值

arr1.argsort()

这里的第一个8代表的是最小值14.29007739的索引下标。

（10）partition分区

设置一个标志位置，小于这个值的都在左边，大于这个值的都在右边。

  ①生成50-60之间的10个数

arr1=np.arange(50,60)
arr1

②设置“有序状态下”下标为6的索引对应的元素作为标志位置

np.partition(arr1,6)

输出partion对应的索引：

np.argpartition(arr1,6)

(11)索引以数组的向数组中取值

①一维数组

1.定义一个一维数组

arr1=np.arange(15)*10
arr1

2.创建索引数组并获取值

index=[2,4,6]
arr_get=arr1[index]
arr_get

②二维数组

1.创建二维数组

arr1=np.arange(15).reshape(3,5)*10
arr1

2.设置x数组和y数组

index_x=[1,2]
index_y=[0,1]

2.获取第0行，特定数组下的y（数组index_y）列

arr_get1=arr1[0,index_y]
arr_get1

3.获取第x(数组index_x)行，特定数组下的0列

arr_get2=arr1[index_x,0]
arr_get2

（12）数组比较

①单纯数组比较，返回值为布尔值

创建一个数组：

arr1=np.arange(10)
arr1

找出元素值小于5的数组元素：

arr1<5

②获取对应布尔值为true的数组元素

arr1[arr1<5]

好啦！我持续更新，继续总结，希望能够帮助到大家！