数据分析与可视化PPT完整全套教学课件

第1章NumPy数值计算基础全套可编辑PPT课件2Numpy数据集的读取与存储方法1Numpy环境配置3Numpy数据选择4Numpy数据集生成5Numpy切片6Numpy矩阵运算1.1：Numpy环境配置认识Numpy下载安装什么是numpyNumPy的全称是“NumericPython”，它是Python的第三方扩展包，主要用来计算、处理一维或多维数组。在数组算术计算方面，NumPy提供了大量的数学函数。NumPy的底层主要用C语言编写，因此它能够高速地执行数值计算。NumPy还提供了多种数据结构，这些数据结构能够非常契合的应用在数组和矩阵的运算上。NumPy的前身是Numeric程序包，该包由JimHugunin开发，在这之后，他还开发了另一个类似的的程序包Numarray，相比前者而言Numarray具有更加全面的功能。在2005年，TravisOliphant通过整合Numarray与Numeric软件包的功能，从而集成了NumPy。NumPy的最新版本1.19.2已于2020年9月10日发布。认识numpyNumPy使用需求随着数据科学（DataScience，简称DS，包括大数据分析与处理、大数据存储、数据抓取等分支）的蓬勃发展，像NumPy、SciPy（Python科学计算库）、Pandas（基于NumPy的数据处理库）等数据分析库都有了大量的增长，它们都具有较简单的语法格。在矩阵乘法与数组形状处理上，NumPy有着非常不错的性能，再加上NumPy的计算速度很快，这些都是NumPy成为一款数据分析工具的重要原因。NumPy可以很便捷高效地处理大量数据，那么使用NumPy做数据处理有哪些优点呢？NumPy是Python科学计算基础库；NumPy可以对数组进行高效的数学运算；NumPy的ndarray对象可以用来构建多维数组；NumPy能够执行傅立叶变换与重塑多维数组形状；NumPy提供了线性代数，以及随机数生成的内置函数。认识numpyNumPy应用场景NumPy通常与SciPy（Python科学计算库）和Matplotlib（Python绘图库）等软件包组合使用，这种组合方式被用来广泛地代替MatLab的使用。MatLab是一款强大的数学计算软件，广泛应用在数据分析、电子通信、深度学习、图像处理、机器视觉、量化金融等领域，但近些年随着Python语言的迅猛发展，Python被看作是一种更适合代替MatLab的编程语言。您可以使用NumPy、SciPy与Matplotlib等Python工具包搭建科学计算环境，比如Anaconda就是是一个开源的Python发行版本，它包含了Python、NumPy等180多个科学包及其依赖项。认识numpyNumPy是Python的第三方扩展包，但它并没有包含在Python标准库中，因此需要单独安装它。Windows系统安装使用Python包管理器pip来安装NumPy，是一种最简单、最轻量级的方法。只需执行以下命令即可：

pipinstallnumpy

以上命令是在安装了python安装包，进入cmd下输入命令执行

下载安装安装成功打开Python交互解释器(或Jupyter，推荐！），并导入NumPy模块，如下图所示如果未出现错误提示，则表示已安装成功。下载安装In[1]:import

numpy

as

np

#导入NumPy并指定别名npIn[2]:print(np.__version__) #输出NumPy的版本号1.19.5如果安装的是Anaconda点击ancondaprompt直接执行piplist或者condalist查看numpy，一般都有安装，不用从新安装下载安装1.2：N维数组的本质

NumPy数组的两种视图1.3

N维数组的本质ndarray对象数组类型数组属性创建ndarray对象通过NumPy的内置函数array()可以创建ndarray对象，其语法格式如下：numpy.array(object,dtype=None,copy=True,order=None,ndmin=0)ndarray对象数组的常用属性

ndarray对象：dtype

In[1]:import

numpy

as

np

#导入Numpy软件包In[2]:my_array=np.arange(0,10) #创建一个取值范围为0～9的一维数组序列In[3]:my_array.dtype#查看数组元素的类型Out[3]:dtype('int64')查看数组类型ndarray对象

In[4]:type(my_array) #查看对象的类型Out[4]:numpy.ndarrayIn[5]:my_array.__class__ #等价于查看构建对象所用的类的名称Out[5]:numpy.ndarrayndarray.ndim属性返回的是数组的维数代码如下：

数组属性In[6]:my_array.ndim

#显示数组的维度Out[6]:1ndarray.shape数组属性In[7]:my_array.shape

#查看数组的尺寸Out[7]:(10,)

数组的reshapeIn[8]:arr=np.arange(15) #创建一个包含15个元素的一维数组In[9]:arr #查看一维数组的数据Out[9]:array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14])In[10]:arr=arr.reshape(3,5) #改变数组尺寸为3行5列In[11]:arr #显示二维数组元素Out[11]:array([[0,1,2,3,4],[5,6,7,8,9],[10,11,12,13,14]])In[12]:arr.ndim

#查看数组的维度信息Out[12]:2

#这是一个二维数组或称2D张量In[13]:arr.shape

#查看数组的形状信息Out[13]:(3,5)我们也可以直接对数组的shape属性进行赋值，来“重构”数组的形状。例如，b.shape=3,5。需要注意的是，等号右边的两个离散的尺寸“3,5”被Python自动打包为元组，变为(3,5)。因此前面的语句等价为b.shape=(3,5)。二维数组In[16]:arr=arr.astype('float32')

#将数组arr强制转为32位浮点数In[17]:arr #验证输出Out[17]:array([[0.,1.,2.,3.,4.],[5.,6.,7.,8.,9.],[10.,11.,12.,13.,14.]],dtype=float32)In[18]:arr.itemsize

#再次验证数组arr中每个元素占用的字节数Out[18]:4读者可对比Out[3]处的输出。3维数组In[19]:arr2=np.arange(30).reshape(2,3,5) #重构数组为2通道3行5列In[20]:arr2 Out[20]:array([[[0,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,26,27,28,29]]])In[21]:arr2.shape #输出验证arr2的尺寸Out[21]:(2,3,5)

1.4如何生成NumPy数组创建数组方法数组操作数组的增删改查利用序列生成In[1]:import

numpy

as

np

#导入NumPy软件包In[2]:data1=[6,8.5,9,0] #构建一个列表In[3]:arr1=np.array(data1) #列表充当数组的数据源In[4]:arr1 #输出验证Out[4]:array([6.,8.5,9.,0.])In[5]:arr1.dtype #默认保存为双精度（64bit）浮点数Out[5]:dtype('float64')利用序列生成In[6]:arr1_int=arr1.astype(np.int32) #转换为32位整型数In[7]:arr1_int #输出验证Out[7]:array([6,8,9,0],dtype=int32)In[10]:data2=[[1,2,3,4],[5,6,7,8]]#这是一个两层嵌套列表In[10]:arr2=np.array(data2)#转换为一个二维数组In[11]:arr2Out[11]:array([[1,2,3,4],[5,6,7,8]])利用序列生成In[1]:import

numpy

as

np

#导入NumPy软件包In[2]:data1=[6,8.5,9,0] #构建一个列表In[3]:arr1=np.array(data1) #列表充当数组的数据源In[4]:arr1 #输出验证Out[4]:array([6.,8.5,9.,0.])In[5]:arr1.dtype #默认保存为双精度（64bit）浮点数Out[5]:dtype('float64')numpy.arange()在NumPy中，您可以使用arange()来创建给定数值范围的数组，语法格式如下：numpy.arange(start,stop,step,dtype)创建数组的方法利用特定方法生成

1.

arange(start,stop,step,dtype)arange根据start与stop指定的范围及step设定的步长生成一个ndarray对象。start为起始值，默认为0；stop为终止值。取值区间是左闭右开的，即stop这个终止值是不包括在内的。step为步长，如果不指定，默认值为1。

In[1]:import

numpy

as

npIn[2]:arr3=np.arange(10)#生成从0～9的ndarray数组In[3]:print(arr3)[0

1

2

3

4

5

6

7

8

9]rang和arange（np）In[8]:np.arange(0,10,0.5) #步长设置为0.5Out[8]:array([0.,0.5,1.,1.5,2.,2.5,3.,3.5,4.,4.5,5.,5.5,6.,

6.5,7.,7.5,8.,8.5,9.,9.5])

In[9]:range(0,10,0.5)

#错误，range的步长必须是整数----------------------------------------------------------------------TypeErrorTraceback(mostrecentcalllast)<ipython-input-9-eeb741842f02>

in

<module>---->

1

range(0,10,.5)TypeError:'float'

objectcannotbeinterpretedasaninteger利用linspace

In[10]:array=np.linspace(1,10,20)In[11]:print(array)[1.

1.47368421

1.94736842

2.42105263

2.89473684

3.36842105

3.84210526

4.31578947

4.78947368

5.26315789

5.73684211

6.21052632

6.68421053

7.15789474

7.63157895

8.10526316

8.57894737

9.05263158

9.52631579

10.]numpy.linspace(start,

stop,

num=50,

endpoint=True,

retstep=False,

dtype=None,

axis=0)[source]Returnevenlyspacednumbersoveraspecifiedinterval.Returns

num

evenlyspacedsamples（区间等分）,calculatedovertheinterval[start,

stop].Theendpointoftheintervalcanoptionallybeexcluded.numpy.zeros()该函数用来创建元素均为0的数组，同时还可以指定被数组的形状，语法格式如下：numpy.zeros(shape,dtype=float,order="C")创建数组的方法创建数组的方法：zeros创建ndarray数组的基本方法，除了使用array()方法外，NumPy还提供了其他创建ndarray数组的方法。numpy.empty()numpy.empty()创建未初始化的数组，可以指定创建数组的形状（shape）和数据类型（dtype），语法格式如下：numpy.empty(shape,dtype=float,order='C')它接受以下参数：shape：指定数组的形状；dtype：数组元素的数据类型，默认值是值float；order：指数组元素在计算机内存中的储存顺序，默认顺序是“C”(行优先顺序)。利用特定方法生成代码如下：创建数组的方法importnumpyasnparr=np.empty((3,2),dtype=int)print(arr)输出结果：[[2003134838175335712][538976288538976288][19705624181684369010]]可以看到，numpy.empty()返回的数组带有随机值，但这些数值并没有实际意义。切记empty并非创建空数组。numpy.ones()返回指定形状大小与数据类型的新数组，并且新数组中每项元素均用1填充，语法格式如下：numpy.ones(shape,dtype=None,order='C')创建数组的方法importnumpyasnparr1=np.ones((3,2),dtype=int)print(arr1)输出结果如下：[[11][11][11]1.5

NumPy中的随机数生成范例1-1NumPy中的random模块01importnumpyasnp

#导入NumPy03rdm=np.random.RandomState() #定义种子类04#np.random.seed(19680101) #定义全局种子，与上面的取一种即可06#生成2×3的二维随机数组，随机数均匀分布，有几个参数就生成几维数据07rand=np.random.rand(2,3)08print("rand(d0,d1,...,dn):产生服从均匀分布的随机数\n",rand)10randn=np.random.randn(2,3) #生成2×3的二维随机数组，随机数服从标准正态分布11print("randn(d0,d1,...,dn):产生标准正态分布的随机数\n",randn)13randint=np.random.randint(1,10,(2,3)) #生成2×3的1～10范围内的随机整数14print("randint(low,high,size,dtype):产生随机整数\n",randint)16random=np.random.random((2,3))17print("random(size):在[0,1)内产生随机数\n",random)运行结果rand(d0,d1,...,dn):产生均匀分布的随机数[[0.87057637

0.05929263

0.3380323][0.40045436

0.83160874

0.57788488]]randn(d0,d1,...,dn):产生标准正态分布的随机数[[-1.45930643

-0.5270492

0.75118004][0.88328798

-0.63944759

0.77902815]]randint(low,high,size,dtype):产生随机整数[[9

8

2][4

6

5]]random(size):在[0,1)内产生随机数[[0.10403689

0.58242245

0.52686065][0.43098811

0.9953507

0.61691354]]1.6NumPy数组中的运算

向量运算In[1]:list1=[1,2,3,4,5,6,7,8,9,10]In[2]:list2=[11,12,13,14,15,16,17,18,19,20]列表推导式

对应元素的和

In[3]:list3=[item1+item2foritem1,item2in

zip(list1,list2)]In[4]:list3Out[4]:[12,14,16,18,20,22,24,26,28,30]NumPy对列表元素求和In[5]:list1_arr=np.array(list1) #将list1转换成ndarrayIn[6]:list2_arr=np.array(list2) #将list2转换成ndarrayIn[7]:list_sum=list1_arr+list2_arr #求和In[8]:print(list_sum)Out[8]:[12,14,16,18,20,22,24,26,28,30]1.6.2

NumPy中的通用函数表1-1NumPy中部分常用的通用函数

函数名称函数功能add、subtract、multiplydivide逐元素进行两个序列对应的加、减、乘、除操作matmul计算两个数组的矩阵积sqrt以元素方式返回数组的非负平方根power第一个数组元素从第二个数组提升为幂，按元素排序sin、cos、tan计算三角函数的正弦、余弦、正切abs计算序列化数据的绝对值log、log2、logl0 计算输入数组的对数，分别为自然对数、以2为底的对数、以10为底的对数exp、exp2计算输入数组中所有元素的指数cumsum、cumproduct累计求和、求积sum 对一个序列化数据进行求和mean、median计算均值、计算中位数std、var 计算标准差、计算方差corrcoef计算相关系数tensor

in，tensor

outufunc函数的相关示例

In[1]:import

numpy

as

np

In[2]:A=np.ones(3)*

1 #张量A的值为[1.,1.,1.]In[3]:B=np.ones(3)*

2 #张量B的值为[2.,2.,2.]In[4]:C=np.add(A,B)In[5]:print(C) #验证张量C的值[3.

3.

3.]In[6]:np.add(A,B,out=B)In[7]:print(B)[3.

3.

3.]NumPy数组的“加减乘除”算术运算add()、subtract()函数multiple()、divide()函数注意：做算术运算时，输入数组必须具有相同的形状，或者符合数组的广播规则，才可以执行运算。算术运算逐元素矩阵乘法multiple()函数用于两个矩阵的逐元素乘法，如下：矩阵算法importnumpyasnparray1=np.array([[1,2,3],[4,5,6],[7,8,9]],ndmin=3)array2=np.array([[9,8,7],[6,5,4],[3,2,1]],ndmin=3)result=np.multiply(array1,array2)result输出结果：array([[[9,16,21],[24,25,24],[21,16,9]]])逐元素运算与点乘运算

In[1]:import

numpy

as

np

In[2]:a=np.arange(10) #生成一维ndarray数组，长度为10In[3]:b=np.linspace(1,10,10) #生成一维ndarray数组，长度为10In[4]:a #输出验证Out[4]:array([0,1,2,3,4,5,6,7,8,9])In[5]:b #输出验证Out[5]:array([1.,2.,3.,4.,5.,6.,7.,8.,9.,10.])In[6]:a+b #对数组做加法运算Out[6]:array([1.,3.,5.,7.,9.,11.,13.,15.,17.,19.])In[7]:a-b #对数组做减法运算Out[7]:array([-1.,-1.,-1.,-1.,-1.,-1.,-1.,-1.,-1.,-1.])In[8]:a*b #对数组做乘法运算Out[8]:array([0.,2.,6.,12.,20.,30.,42.,56.,72.,90.])NumPy数组的“加减乘除”算术运算add()、subtract()函数multiple()、divide()函数注意：做算术运算时，输入数组必须具有相同的形状，或者符合数组的广播规则，才可以执行运算。算术运算逐元素运算与点乘运算

In[9]:a/b #对数组做除法运算Out[9]:array([0.,0.5,0.66666667,0.75,0.8,

0.83333333,0.85714286,0.875,0.88888889,0.9])In[10]:a%b #对数组做取余运算Out[10]:array([0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])In[11]:a**

2

#对数组做平方运算Out[11]:array([0,1,4,9,16,25,36,49,64,81])1.6.4向量的内积与矩阵乘法矩阵乘法是将两个矩阵作为输入值，并将A矩阵的行与B矩阵的列对应位置相乘再相加，从而生成一个新矩阵.矩阵乘法运算被称为向量化操作，向量化的主要目的是减少使用的for循环次数或者根本不使用。这样做的目的是为了加速程序的计算。矩阵乘法注意：必须确保第一个矩阵中的行数等于第二个矩阵中的列数，否则不能进行矩阵乘法运算。向量的内积与矩阵乘法

In[12]:a=np.array([1,2,3])In[13]:b=np.array([4,5,6])In[14]:np.dot(a,b)Out[14]:32矩阵乘法In[15]:a=np.arange(9).reshape(3,3)In[16]:a #输出验证Out[16]:array([[0,1,2],[3,4,5],[6,7,8]])In[17]:b=np.ones(shape=(3,2))In[18]:b #输出验证Out[18]:array([[1.,1.],[1.,1.],[1.,1.]])In[19]:np.dot(a,b)#矩阵乘积Out[19]:array([[3.,3.],[12.,12.],[21.,21.]])1.7NumPy中的广播机制

NumPy中的广播机制（Broadcast）旨在解决不同形状数组之间的算术运算问题。我们知道，如果进行运算的两个数组形状完全相同，它们直接可以做相应的运算。广播机制但如果两个形状不同的数组呢？它们之间就不能做算术运算了吗？当然不是！为了保持数组形状相同，NumPy设计了一种广播机制，这种机制的核心是对形状较小的数组，在横向或纵向上进行一定次数的重复，使其与形状较大的数组拥有相同的维度。广播机制当进行运算的两个数组形状不同，Numpy会自动触发广播机制。代码如下：importnumpyasnpa=np.array([[0,0,0],[10,10,10],[20,20,20],[30,30,30]])#b数组与a数组形状不同b=np.array([1,2,3])print(a+b)输出结果为：[[123][111213][212223][313233]]“低维有1”情况下的广播In[1]:import

numpy

as

npIn[2]:x=np.array([1,2,3])In[3]:y=

2In[4]:x.shapeOut[4]:(3,)In[5]:x+yOut[5]:array([3,4,5])“后缘相符”情况下的广播In[6]:a=np.array([[0,0,0],

[1,1,1],

[2,2,2],

[3,3,3]])In[7]:b=np.array([1,2,3])In[8]:a.shapeOut[8]:(4,3)In[9]:b.shapeOut[9]:(3,)In[10]:a+bOut[10]:array([[1,2,3],

[2,3,4],

[3,4,5],

[4,5,6]])“后缘不符但低维有1”情况下的广播In[11]:c=np.arange(3).reshape((3,1))In[12]:c.shapeOut[12]:(3,1)In[13]:d=np.arange(3)In[14]:d.shapeOut[14]:(3,)In[15]:c+dOut[15]:array([[0,1,2],

[1,2,3],

[2,3,4]])思考：广播失败的原因In[16]:arr1=np.array([[0.0,0.0,0.0],#shape：(4,3)[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])In[17]:arr2=np.array([0,1,2,3]) #shape：(4,)In[18]:arr1+arr2

#是否会广播成功？小结：广播的特征

后缘相符：如果两个向量在维度上不相符，只要维度尾部对齐相符，则广播就可以得以发生。

低维有1：如果两个向量的尺寸在维度上不匹配，但有一个向量后缘维度为1，则需要将维度低的向量进行拉伸，以匹配另一个较大向量的尺寸。

扩展维度：在符合广播条件的前提下，广播机制会为尺寸较小的向量添加一个轴（广播轴），使其维度信息与较大向量的维度信息相同。

复制数据：尺寸较小的向量沿着新添加的轴不断重复之前的元素，直至尺寸与较大的向量相同。1.8NumPy中的轴认识轴的概念基于轴的约减操作In[1]:import

numpy

as

np

In[2]:a=np.ones((2,3)) #创建形状为2×3、元素值均为1的矩阵In[3]:a#显示该矩阵Out[3]:array([[1.,1.,1.],[1.,1.,1.]])In[4]:a.sum()#将6个矩阵元素求和后转换成一个元素Out[4]:6.0In[5]:a.sum(axis=

0)#垂直方向约减Out[5]:array([2.,2.,2.])In[6]:a.sum(1)

#垂直方向约减Out[6]:array([3.,3.])基于轴的各种运算In[7]:a=np.array([[[1,1,1],[2,2,2]],[[3,3,3],[4,4,4]]])In[8]:a#输出验证Out[8]:array([[[1,1,1],

[2,2,2]],[[3,3,3],

[4,4,4]]])In[9]:a.sum(axis=

0)#在第0个轴方向进行约减求和Out[9]:array([[4,4,4],

[6,6,6]])In[10]:a.sum(axis=

1)Out[10]:array([[3,3,3],

[7,7,7]])In[11]:a.ndim#查看张量a的维度Out[11]:3In[12]:b=a.sum(axis=

2) #在第2个轴上约减In[13]:bOut[13]:array([[3,6],

[9,12]])In[14]:b.ndim#查看被约减后张量b的维度Out[14]:2

1.9操作数组元素在NumPy中，如果想要访问，或修改数组中的元素，您可以采用索引或切片的方式，比如使用从0开始的索引依次访问数组中的元素，这与Python的list列表是相同的。NumPy提供了多种类型的索引方式，常用方式有两种：基本切片与高级索引（第二章讲解）。切片1.9.1通过索引访问数组元素In[1]:import

numpy

as

npIn[2]:one_dim=np.linspace(-0.5,0.6,5)In[3]:print(one_dim)[-0.5

-0.225

0.05

0.325

0.6]In[4]:one_dim[0] #访问第1个元素Out[4]:-0.5In[5]:one_dim[-1] #访问倒数第1个元素Out[5]:0.6In[6]:one_dim[0]=

1

#对第1个元素赋值二维数组的索引下标访问In[8]:two_dim=np.array([[1,2,3],#构造一个二维数组[4,5,6],[7,8,9]])In[9]:two_dim[0][2]

#访问第1行第3列对应的元素Out[9]:3In[10]:two_dim[0,2]

#NumPy风格的二维数组访问Out[10]:3在NumPy中，如果想要访问，或修改数组中的元素，您可以采用索引或切片的方式，比如使用从0开始的索引依次访问数组中的元素，这与Python的list列表是相同的。NumPy提供了多种类型的索引方式，常用方式有两种：基本切片与高级索引。切片一维数组的切片NumPy内置函数slice()可以用来构造切片对象，该函数需要传递三个参数值分别是start（起始索引）、stop（终止索引）和step（步长），通过它可以实现从原数组的上切割出一个新数组。1.9.2

NumPy中的切片访问importnumpyasnpa=np.arange(10)#生成切片对象s=slice(2,9,3)#从索引2开始到索引9停止，间隔时间为2print(a[s])输出结果：[258]1.9.2

NumPy中的切片访问In[1]:import

numpy

as

np

In[2]:a=np.arange(10)In[3]:s=

slice(0,9,2) #创建切片对象In[4]:b=a[s] #按照切片规则提取数据In[5]:bOut[5]:array([0,2,4,6,8])In[6]:a#验证：原始数组并不受切片影响Out[6]:array([0,1,2,3,4,5,6,7,8,9])一维数组的切片也可以通过冒号来分割切片参数，最终也能获得相同结果切片importnumpyasnpa=np.arange(10)b=a[2:9:2]print(b)输出结果：[258]1.9.2

NumPy中的切片访问In[7]:a[0:9:2]Out[7]:array([0,2,4,6,8])In[8]:a#验证：原始数组并不受切片影响Out[8]:array([0,1,2,3,4,5,6,7,8,9])切片语法：数组名[start:end:step]。start表示起始索引（从0计数），end表示结束索引（-1表示结束），step表示步长，步长为正时表示从左向右取值，步长为负时则反向取值。

1.9.2

NumPy中的切片访问In[9]:a[2:]#从第2到结尾的所有元素Out[9]:array([2,3,4,5,6,7,8,9])In[10]:a[2:-2]#从第2个元素开始，到倒数第2个元素结束（但不包括倒数第2个元素）Out[10]:array([2,3,4,5,6,7])一维数组的切片下面对冒号切片做简单地说明：如果仅输入一个参数，则将返回与索引相对应的元素。对于上述示例来说[3]就会返回3。如果在其前面插入“:”如[:9]，则会返回0-8的所有数字（不包含9）。如是[2:]则会返回2-9之间的数字。如果在两个参数之间，如[2:9]，则对两个索引值之间的所有元素进行切片（不包括停止索引）。切片多维数组切片切片importnumpyasnpa=np.array([[1,2,3],[3,4,5],[4,5,6]])print(a)#从[1:]索引处开始切割print(a[1:])输出结果：[[123][345][456]]#切割后的新数组[[345][456]]表1-2切片操作的省略方式

切片参数含义描述start:end:step从start开始读取，到end(不包含end)结束，步长为stepstart:end从start开始读取，到end(不包含end)结束，步长为1start:从start开始读取后续所有元素，步长为1start::step从start开始读取后续所有元素，步长为step:end:step从0开始读取，到end(不包含end)结束，步长为step:end从0开始读取，到end(不包含end)结束，步长为1::step从0开始读取后续所有元素，步长为step::读取所有元素:读取所有元素In[11]:a[::-1]#从开始到结束，步长为-1Out[11]:array([9,8,7,6,5,4,3,2,1,0])#对数组进行翻转输出实例：切片1.9.3

二维数组的转置与展平

NumPy中包含了一些处理数组的常用方法，大致可分为以下几类：1、数组变维操作2、数组转置操作3、修改数组维度操作4、连接与分割数组操作二维数组的转置与展平

数组变维操作数组操作numpy.ndarray.flatnumpy.ndarray.flat返回一个数组迭代器，代码如下:数组操作importnumpyasnpa=np.arange(9).reshape(3,3)forrowina:print(row)#使用flat属性：foreleina.flat:print(ele,end="，")输出结果如下：#原数组[012][345][678]#输出元素0，1，2，3，4，5，6，7，8，numpy.ndarray.flatten()numpy.ndarray.flatten返回一份数组副本，对副本修改不会影响原始数组，其语法格式如下：数组操作ndarray.flatten(order='C')importnumpyasnpa=np.arange(8).reshape(2,4)print(a)#默认按行C风格展开的数组print(a.flatten())#以F风格顺序展开的数组print(a.flatten(order='F'))输出结果：#数组a[[0123][4567]]#默认c顺序站看数组[01234567]#F顺序站看数组[04152637]numpy.ravel()numpy.ravel()将多维数组中的元素以一维数组的形式展开，该方法返回数组的视图（view），如果修改，则会影响原始数组。numpy.ravel(a,order='C')数组操作importnumpyasnpa=np.arange(8).reshape(2,4)print('原数组：')print(a)print('调用ravel函数后：')print(a.ravel())print('F风格顺序调用ravel函数之后：')print(a.ravel(order='F'))输出结果如下：原数组：[[0123][4567]]调用ravel函数后：[01234567]F风格顺序调用ravel函数之后：[04152637]数组转置操作

数组操作numpy.transpose()numpy.transpose()用于对换多维数组的维度，比如二维数组使用此方法可以实现矩阵转置，语法格式如下：numpy.transpose(arr,axes)参数说明如下：arr：要操作的数组axes：可选参数，元组或者整数列表，将会按照该参数进行转置。数组操作代码如下：数组操作importnumpyasnpa=np.arange(12).reshape(3,4)print(a)print(np.transpose(a))输出结果：原数组：[[0123][4567][891011]]对换数组：[[048][159][2610][3711]]1.10

实战：张量思维的养成——利用NumPy计算π

蒙特卡洛

计算π【范例1-3】利用循环思维求解π（loop-pi.py）

01import

math02import

random03from

time

importperf_counter05n=

1000

*

1000

*

1006hits=

007start=perf_counter()08for_in

range(n):09x=random.random()#产生一个0~1的随机数x作为X轴坐标10y=random.random()#产生一个0~1的随机数y作为Y轴坐标11ifmath.sqrt(x**

2

+y**

2)<

1:#判定（x,y）是否在1/4圆内12hits+=

1

13pi=(hits/n)*

415now=perf_counter()16print('Pi={0:1.5f},time={1:1.5f}s'.format(pi,now-start))【运行结果】Pi=3.1421204,time=4.366808561004291s

利用NumPy中的张量思维求解π（tensor-pi.py）

01import

numpy

as

np02from

time

importperf_counter04n=

1000

*

1000

*

1005hits=

007start=perf_counter()08X,Y=np.random.rand(n),np.random.rand(n)09dist=np.sqrt(X**

2

+Y**

2)10pi=

4

*np.sum(dist<=

1)/n11now=perf_counter()13print(f'Pi={pi},time={now-start}s')【运行结果】Pi=3.1409008,time=0.3604922960003023s谢谢《数据分析与可视化》第2章NumPy数值计算进阶2张量的堆叠操作与分割1NumPy数组的高级索引3NumPy张量的升维与降维4数据的去重与铺叠5张量的排序6常用的统计方法2.1NumPy数组的高级索引花式”索引好用的布尔索引

2.1NumPy数组的高级索引In[1]:import

numpy

as

npIn[2]:normal_array=np.array([34,45,56,69,9,11,22,71,82,10,123])In[3]:normal_array#输出验证Out[3]:array([34,45,56,69,9,11,22,71,82,10,123])In[4]:fancy_index_array=normal_array[[0,8,7,7]]In[5]:fancy_index_arrayOut[5]:array([34,82,71,71])In[6]:index=[0,8,7,7] #这是一个装满索引的列表In[7]:normal_array[index] #将列表用作索引，这次可读性强多了Out[7]:array([34,82,71,71])In[8]:two_dim_array=np.arange(20).reshape(4,5)#将a变形为一个4行5列的二维数组In[9]:two_dim_array #输出验证

Out[9]:array([[0,1,2,3,4],

[5,6,7,8,9],

[10,11,12,13,14],

[15,16,17,18,19]])In[10]:two_dim_array[[0,2,1,0]] #内层方括号为花式索引Out[10]:array([[0,1,2,3,4], #第0行数据（以0为计数起点，下同）

[10,11,12,13,14], #第2行数据

[5,6,7,8,9], #第1行数据

[0,1,2,3,4]]) #第0行数据（重复）In[11]:row_index=[0,2,1,0] #这是一个行索引坐标In[12]:two_dim_array[row_index] #花式访问行数据Out[12]:array([[0,1,2,3,4],

[10,11,12,13,14],

[5,6,7,8,9],

[0,1,2,3,4]])2.1.2好用的布尔索引布尔数组索引

当输出的结果需要经过布尔运算（如比较运算）时，此时会使用到另一种高级索引方式，即布尔数组索引。索引In[6]:a=np.arange(10).reshape(2,5)In[7]:a#输出验证Out[7]:array([[0,1,2,3,4],[5,6,7,8,9]])In[8]:a[a>

5]Out[8]:array([6,7,8,9])布尔索引的应用对比np.where1.np.where(condition,x,y)满足条件(condition)，输出x，不满足输出y。>>>aa=np.arange(10)#非0即为真#array([0,1,2,3,4,5,6,7,8,9])>>>np.where(aa,1,-1)array([-1,1,1,1,1,1,1,1,1,1])#0为False，所以第一个输出-1

>>>np.where(aa>5,1,-1)array([-1,-1,-1,-1,-1,-1,1,1,1,1])对比np.where2.np.where(condition)只有条件(condition)，没有x和y，则输出满足条件(即非0)元素的坐标(等价于numpy.nonzero)。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。>>>a=np.array([2,4,6,8,10])>>>np.where(a>5)#返回的是数组的索引

(array([2,3,4]),)>>>a[np.where(a>5)]#等价于a[a>5]

array([6,8,10])对比numpy.clipnumpy.clip(a,a_min,a_max,out=None)其中a是一个数组，后面两个参数分别表示最小和最大值

#设定返回的上下界，在上下界之内的数据返回原来的值，小于下界值，则用下界值a_min代替原值。反之，大于下界值，则用上界值a_max代替原值。clip

夹子，别针；修剪；案例测试importnumpyasnptemperatures=[85.6,75.4,81.3,75.4,81.3]print(temperatures)print(np.clip(temperatures,78,82))原始数据：

[85.6,75.4,81.3,75.4,81.3]截断（上下界）数据：[82.

78.

81.3

78.

81.3]对比神经网络中ReLU函数实现：np.clipPyTorch用clamp测试：arr=np.array([-1,3,-2.1,-6,5,7])np.clip(arr,0,None)array([0.,3.,0.,0.,5.,7.])2.2张量的堆叠操作与分割连接与分割数组操作连接与分割数组是数组的两种操作方式，现将它们的方法整合在一起。数组操作连接数组操作numpy.concatenate()沿指定轴连接相同形状的两个或多个数组，格式如下：numpy.concatenate((a1,a2,...),axis)参数说明：a1,a2,...：表示一系列相同类型的数组；axis：沿着该参数指定的轴连接数组，默认为0。数组操作2.2.1水平方向堆叠hstackIn[1]:arr1=np.zeros(shape=(2,2),dtype=np.int32)In[2]:arr1 #输出验证Out[2]:array([[0,0],[0,0]])In[3]:arr2=np.ones(shape=(2,3),dtype=np.int32)In[4]:arr2 #输出验证Out[4]:array([[1,1,1],[1,1,1]])In[5]:np.hstack((arr1,arr2))#内部括号表示元组一个元组对象Out[5]:array([[0,0,1,1,1],[0,0,1,1,1]])垂直方向堆叠vstackIn[7]:arr2=np.ones(shape=(2,3),dtype=np.int32)In[8]:arr3=np.zeros(shape=(3,3),dtype=np.int32)In[9]:np.vstack((arr2,arr3))Out[9]:array([[1,1,1],[1,1,1],[0,0,0],[0,0,0]])垂直方向堆叠vstackIn[7]:arr2=np.ones(shape=(2,3),dtype=np.int)In[8]:arr3=np.zeros(shape=(3,3),dtype=np