【文档说明】Python基础与大数据应用第九章-数据分析基础-课件.pptx，共(107)页，2.017 MB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-2407.html

以下为本文档部分文字说明：

第九章数据分析基础北京西普阳光教育科技股份有限公司中国IT教育解决方案专家2018年10月制作：丁辉1目录Contents01numpy模块02pandas模块030407项目训练小结2numpy模块01numpy模块numpy是一个用Python实现的科学计算包，专为进行严格的数值

处理而产生，尤其是对大型多维数组和矩阵的支持，并且有一个大型的高级数学函数库来操作这些数组。numpy提供了许多高级的数值编程工具，如矩阵数据类型、矢量处理，以及精密的运算库。numpy多为很多大型金融公司和核心的科学计算组

织使用，具有运算速度快、效率高、节省空间等特点。45numpy中最重要的对象就是ndarray的多维数组，它是一组相同类型元素的集合，元素可用从零开始的索引来访问。多维数组ndarray中的每个元素在内存中连续存放并占同样大小存储空间。

多维数组ndarray有以下几个属性：ndarray.size：数组中全部元素的数量；ndarray.dtype：数组中数据元素的类型（int8,uint8,int16,uint16,int32,uint32,int64,uint64

,float16,float32,float64,float128,complex64,complex128,complex256,bool,object,string,unicode等）；ndarray.itemsize：每个元素占的字节数；nda

rray.ndim：数组的维度；ndarray.shape：数组各维度大小。ndarray类型数组6◆创建一维数组（1）用array()函数创建一维数组创建数组最简单的方法就是使用array()函数。它将输入的数据（元组、列表、数组或其它序列的对象）转换成多维数组

ndarray，数组元素类型自动推断出或显式制定dtype类型，默认直接复制输入的数据，然后产生一个新的多维数组ndarray。>>>importnumpyasnp#导入numpy模块，重命名为np>>>x=np.array((1,2,3,4))#创建一维数组x>>>xarray

([1,2,3,4])#一维数组[1,2,3,4]>>>print(x)#输出x值[1234]>>>print(x.size)#输出x全部元素的数量4>>>print(x.dtype)#输出x中每个元数

的类型int64>>>print(x.itemsize)#输出x中每个元素占几个字节8>>>x.ndim#显示x的维度1>>>x.shape#显示x的形状，行上共4个元素(4,)#array()函数参数为列表，创建数组，指定类型为float64>>>y=np.array([1

,2,3,4,5],dtype='float64')>>>yarray([1.,2.,3.,4.,5.])#[1.,2.,3.,4.,5.]中的点表示数组中元素类型是浮点型>>>print(y)[1.2.3.4.5.]>>

>y.dtypedtype('float64')>>>y.ndim1ndarray类型数组7◆创建一维数组（2）用arange()函数创建一维数组arrange()函数用于创建等差数组，使用频率非常高，arange()非常类似Python中range()函数，两者的区别在于，a

range()返回的是一个数组，而range()返回的是list，并且是整型。>>>importnumpyasnp>>>np.arange(5)#arange()输出的是含有0~4，5个元素的数组array([0,1,2,3,4])>>>np.arange(1,5

)array([1,2,3,4])>>>np.arange(2,5)array([2,3,4])>>>np.arange(1,10,2)#第一个参数起点，第二个参数终点，第三个参数步长array([1,3,5,7,9])>>>np.arange(1,10,2,

dtype=np.int16)#指定数据元素的类型为int16array([1,3,5,7,9],dtype=int16)ndarray类型数组8◆创建N维数组（1）使用array()函数创建>>>importn

umpyasnp>>>x1=np.array([1,2,3,4])#创建一维数组>>>x1array([1,2,3,4])>>>print(x1.ndim)#输出x1的维度1>>>print(x1.shape)(4,)>>>x2=np.array([[1,2,3,4]]

)#创建二维数组，注意参数的形式>>>x2array([[1,2,3,4]])>>>print(x2.ndim)#输出x2的维度2>>>print(x2.shape)(1,4)>>>x3=np.array([[1,2,3,4],[5,6,7,8]])#创建二维数组>>>print(x3)[

[1234][5678]]>>>print(x3.dtype)int64>>>print(x3.ndim)#输出x3的维度2ndarray类型数组>>>print(x3.shape)#输出x3各维度大小，(2,4)表示2行4列(2,4)>>>y=np.array([[[1,2,3,4],[

5,6,7,8]],[[0,0,0,0],[9,9,9,9]]])#创建三维数组>>>print(y)[[[1234][5678]][[0000][9999]]]>>>print(y.dtype)int64>>>print(y.ndim)#输出y的维度3>>>print(y.shape)#输出y

各维度大小，(2,2,4)表示2维2行4列(2,2,4)9◆创建N维数组（2）使用reshape()函数创建reshape()函数可以实现给数组一个新的形状而不改变其数据，通过reshape()生成的新数组和原始数组公用一个内存，也就是说，假如更改一个数组的元素，另一个数组也将发

生改变。常与arange()函数一起使用来构造多维数组。>>>importnumpyasnp>>>yo=np.arange(1,9)>>>print(yo)[12345678]#创建由1~8，8个元素组成的一维数组，并改变形状为2行4列二维数组>>>y1=np.arange(1,9).resha

pe(2,4)>>>print(y1)[[1234][5678]]#reshape(x,y,z)中任意1参数值用-1替换，此轴长度自动计算>>>y2=np.arange(1,9).reshape(-1,4)>>>print(y2)[[1234][5

678]]>>>y3=np.arange(1,9).reshape(2,-1)>>>print(y3)[[1234][5678]]>>>y4=np.arange(1,9).reshape(1,-1)#1行，自动计算为8列>>>print(y4)[[12345678]]>>>y5=

np.arange(1,5).reshape(-1,1)#1列，自动计算为4行>>>print(y5)[[1][2][3][4]]ndarray类型数组>>>y6=np.arange(1,9).reshape(-1)>>>print(y6)[12345678]>>>

y7=np.arange(1,25).reshape(2,3,4)>>>print(y7)[[[1234][5678][9101112]][[13141516][17181920][21222324]]]>>>print(y7.

dtype)#数组中数据元素的类型是64位整型int64>>>print(y7.ndim)#3维数组3>>>print(y7.shape)#数组各维度大小(2,3,4)>>>print(y7.size)#数组中全

部元素的数量24个24>>>print(y7.itemsize)#每个元素占8个字节8>>>print(y7.reshape(-1))#输出y7数组变形为1维的结果[123456789101112131415161718192021222324]10◆创建数组的其它常用函数ndarray类型数组

函数名称功能说明np.ones()根据指定的形状和类型生成全1的数组np.zeros()生成全0的数组np.empty()创建空数组，只分配存储空间，不填充数据，随机值np.random.randint(x,y,(m,n))创建x起始值，y

截止值，m行n列的随机整数数组np.linspace(x,y,z)等间距生成x起始值，y截止值，z个数的一维数组>>>importnumpyasnp>>>print(np.ones((2,3,4),dtype=np

.int8))#2维3行4列全1数组，指定数据类型为int8[[[1111][1111][1111]][[1111][1111][1111]]]>>>print(np.zeros((2,3,4),dtype=np.i

nt8))#2维3行4列全0数组，指定数据类型为int8[[[0000][0000][0000]][[0000][0000][0000]]]>>>print(np.empty((2,3,4),dtype=np.int8))#2维3行4列全空数组，

数据类型为int8[[[0000][0000][0000]][[0000][0000][0000]]]>>>print(np.random.randint(0,9,(3,4)))#大于等于0小于9，3行4列的随机整数数组[[0343][2550][3645]

]>>>print(np.random.randint(0,9,size=(3,4)))[[4512][7178][0486]]>>>print(np.random.randint(9,size=(3,4)))[[4143][1664][2857]]>>>pr

int(np.random.rand(3,4))#随机样本位于[0,1)，生成3行4列的随机实数数组[[0.962541650.562349310.333054270.61655296][0.619701550.981799230.663141030.16168549][0.89

9329540.466380020.387409380.61592195]]>>>print(np.random.randn(3,4))#从标准正态分布中返回样本值，生成3行4列的随机实数数组[[-1.309775450.476684670.11

0541810.93487926][-0.49593833-0.648461040.25832515-1.82852527][-0.868078991.25805438-0.163114220.7520

0323]]>>>print(np.linspace(-2,2,5))#起点为-2，终点为2，取5个点[-2.-1.0.1.2.]>>>print(np.linspace(-2,8,5))#起点为-2，终点为8，取5个点[-2.0.53.5.58.]11◆数组

的运算ndarray类型数组(1)数组的基本运算#数组的+、-、*、/四则运算，要求参与运算的数组要同样大小，即维度和元素个数相同>>>a=np.array(np.arange(1,5))>>>b=a>>>aarray

([1,2,3,4])>>>barray([1,2,3,4])>>>print(a+b)#对应元素进行运算[2468]>>>print(a-b)[0000]>>>print(a*b)[14916]>>>print(a/b)[1111]>>>print(a+2)#每个元素都进行同样

的运算[3456]>>>print(a-2)[-1012]>>>print(a*2)[2468]>>>print(a/2)[0112]>>>c=np.array(np.arange(1,9).reshape(2,4))>>>d=c>>>carray([[1,2,3,4],[5,6,7,8]])>>

>darray([[1,2,3,4],[5,6,7,8]])>>>print(c+d)[[2468][10121416]]>>>print(c-d)[[0000][0000]]>>>print(c*d)[[14916][253

64964]]>>>print(c/d)[[1111][1111]]>>>print(c+2)[[3456][78910]]>>>print(c-2)[[-1012][3456]]>>>print(c*2)[[2468][101214

16]]>>>print(c/2)[[0112][2334]]12◆数组的运算ndarray类型数组（2）数组运算的基本函数数组运算的基本函数是指能同时对数组中所有元素进行运算的函数，主要包括一元函数和二元函数。一元函数有平方square()、平方根sqrt()、绝对值abs()/fabs()

、对数log()/log10/log2()、符号sign()、是否为NaNisnan()、是否是有穷isinf()、三角函数cos()/cosh()/sin()/sinh()/tan()/tanh()、四舍五入rint()、整数和小数分离，作两个数组返回modf()；二元函数有元

素级加法add(array1,array2)、元素级减法subtract(array1,array2)、元素级乘法multiply(array1,array2)、元素级除法divide(array1,array2)、元素级指数po

wer(array1,array2)、元素级最大/最小值maximum/minimum(array1,aray2)等函数。>>>importnumpyasnp>>>a=np.array(np.arange(1,9).reshape(2,4))>>>aarray([[

1,2,3,4],[5,6,7,8]])>>>b=np.square(a)#一元函数square()，计算平方>>>print(b)[[14916][25364964]]>>>c=np.sqrt(b)#一元函数sqrt()，计算平方根>>>print(c)[[1.2.3

.4.][5.6.7.8.]]>>>d=np.array([[1.22,3.44,5,6.21],[8.99,7,4,.82]])>>>print(d)[[1.223.445.6.21][8.997.4.0.82]]13◆数组的运算ndarray类型数组（2）数组运算的基本函数

>>>print(np.add(a,a))#二元函数add(array1,array2)，计算和[[2468][10121416]]>>>print(np.subtract(a,a))#二元函数subtract(array1,array2)，计算差[[0000][0000]]>>>pr

int(np.multiply(a,a))#二元函数multiply(array1,array2)，计算积[[14916][25364964]]>>>print(np.divide(a,a))#二元函数divide(array1,array2)，计算商[[1111

][1111]]14◆数组的运算ndarray类型数组（3）数学和统计函数numpy中有一组数学函数可以实现对整个数组或某个轴向的数据进行统计计算，如求和sum()、求平均数mean()、标准差std()等函

数，同时mean()和sum()这类函数可以接受一个axis参数（用于计算该轴向上的统计值），最终结果是一个少一维的数组。其它的常用函数还有求方差var()、最小值min()、最大值max()、最小值索引argmin()、最大值索引argmax()等。>>>

importnumpyasnp>>>a=np.array(np.arange(1,9).reshape(2,4))>>>aarray([[1,2,3,4],[5,6,7,8]])>>>np.sum(a)#数组所有元素和36>>>a.sum()36>>>a.sum(ax

is=1)#“axis=1”对行上的数据进行汇总求和，即数组每行所有元素和array([10,26])>>>np.sum(a,axis=1)array([10,26])>>>a.sum(1)array([10,26])>>>a.sum(axis=0

)#“axis=0”对列上的数据进行汇总求和，即数组每列所有元素和array([6,8,10,12])>>>np.sum(a,axis=0)array([6,8,10,12])>>>a.sum(0)array([6,8,10,12])>>>np.mean(a)#数组所有元素

和平均值4.5>>>a.mean()4.515◆数组的运算ndarray类型数组（3）数学和统计函数#axis=1对行上的数据进行汇总求平均值，即数组每行所有元素平均值>>>a.mean(axis=1)array([2.5,6.

5])#axis=0对列上的数据进行汇总求平均值，即数组每列所有元素平均值>>>a.mean(axis=0)array([3.,4.,5.,6.])>>>aarray([[1,2,3,4],[5,6,7,8]])>>>a.cumsum()#数组所有元素累积和array([1,3,6,1

0,15,21,28,36])>>>a.cumsum(1)#数组行累积和array([[1,3,6,10],[5,11,18,26]])>>>a.cumsum(0)#数组列累积和array([[1,2,3

,4],[6,8,10,12]])>>>a.cumprod()#数组所有元素累积积array([1,2,6,24,120,720,5040,40320])>>>a.cumprod(1)#数组行累积积array([[1

,2,6,24],[5,30,210,1680]])>>>a.cumprod(0)#数组列累积积array([[1,2,3,4],[5122132]])16matrix类型矩阵N维数组ndarray和矩阵类型matrix是numpy中两个最重要的数据类型，它们是很多基于numpy数值计算的基础，

因此学习并理清两者的关系非常重要，特别是程序中同时混杂这两种类型，还夹带着一些加减乘除的运算时，就更容易混淆。N维数组ndarry，简称数组array。而矩阵类型matrix其实也是一种array，只不过是维数为2的特殊array，因此，可以说在numpy中二维数组就是

矩阵，矩阵也有与数组一样常见的几个属性，但二者分别是两种类型。matrix的维数是固定的永远是2，这点和一般array显著不同，即便加减乘除各种运算，matrix的维数不会发生变化，而array在运算时特别是归约时维数会发生变化。array转变成matrix用np.mat()、np.matr

ix()或者np.asmatrix()，而matrix转array用np.asarray或者matrix的A属性（mat1.getA()），再看行向量或者列向量对应的array和matrix的实际维数。17

matrix类型矩阵◆创建矩阵（1）利用mat()、matrix()或asmatrix()函数创建>>>importnumpyasnp>>>list1=[[1,2,3,4],[5,6,7,8]]>>>list1[[1,2,3,4],[5,6,7,8]]>>>m

at1=np.mat(list1)#mat()对列表创建矩阵>>>mat1matrix([[1,2,3,4],[5,6,7,8]])>>>print(mat1)[[1234][5678]]>>>mat2=np.matrix(list1)#matrix()对列表创建矩阵>>>mat2matri

x([[1,2,3,4],[5,6,7,8]])>>>print(mat2)[[1234][5678]]>>>mat3=np.asmatrix(list1)#asmatrix()对列表创建矩阵>>>mat3matrix([[1,2,3,4],[5,6,7,8]])>>>print(

mat3)[[1234][5678]]>>>array1=np.array(list1)#array()对列表创建数组>>>array1array([[1,2,3,4],[5,6,7,8]])>>>mat4=np.mat(array1)#mat()

对数组创建矩阵>>>mat4matrix([[1,2,3,4],[5,6,7,8]])>>>print(mat4.ndim)#mat4维数是二维2>>>print(mat4.shape)#mat4是2行4列(2,4)>>>print(t

ype(mat4))#mat4类型，矩阵类型<class'numpy.matrixlib.defmatrix.matrix'>>>>array2=np.arange(1,5)#创建一维数组>>>array2#显示array2arra

y([1,2,3,4])>>>print(array2)#输出array2[1234]>>>print(array2.ndim)#输出array2的维数为11>>>print(array2.shape)#输出arra

y2的形状，行为4元素，列无(4,)>>>print(type(array2))#输出array2的类型，N维数组类型<type'numpy.ndarray'>>>>mat5=np.mat(array2)#利用mat()对一维数组创建矩阵mat5>>>mat5#显示

mat5matrix([[1,2,3,4]])>>>print(mat5)#输出mat5[[1234]]>>>print(mat5.ndim)#输出mat5的维数为22>>>print(mat5.shape

)#输出mat5的形状，1行4列(1,4)>>>print(type(mat5))#输出mat5的类型，矩阵类型<class'numpy.matrixlib.defmatrix.matrix'>18matri

x类型矩阵◆创建矩阵(2)特殊矩阵的创建>>>importnumpyasnp>>>x=np.zeros((3,3),dtype=np.int8)#创建3*3全0二维数组>>>xarray([[0,0,0],[0,0,0]

,[0,0,0]],dtype=int8)>>>mat1=np.mat(x)#创建3*3全0矩阵>>>mat1matrix([[0,0,0],[0,0,0],[0,0,0]],dtype=int8)>>>print(mat1)[[000][000][000]]

>>>mat2=np.mat(np.ones((3,3),dtype=np.int8))#创建3*3全1矩阵>>>mat2matrix([[1,1,1],[1,1,1],[1,1,1]],dtype=int8)>>>mat3=np.mat(np.eye(3,3,dtype=i

nt))#创建3*3对角矩阵,即单位矩阵>>>mat3matrix([[1,0,0],[0,1,0],[0,0,1]])>>>y=[1,2,3]>>>mat4=np.mat(np.diag(y))#创建对角线为1,2,3的3*3对角矩阵>>>mat4matr

ix([[1,0,0],[0,2,0],[0,0,3]])19matrix类型矩阵◆创建矩阵（3）列表、数组、矩阵间的相互转换>>>importnumpyasnp>>>list1=[[0,1,2,3,4],[5,6,7,8]]>>>array1=np.array(list1)#列

表list1→数组array1，array()实现>>>array1array([[0,1,2,3],[4,5,6,7]])>>>print(array1)[[0123][4567]]>>>mat1=np.mat(array1)#数组array1→矩阵mat1，mat()实现

>>>mat1matrix([[0,1,2,3],[4,5,6,7]])>>>print(mat1)[[0123][4567]]>>>array2=np.array(mat1)#矩阵mat1→数组array2，array2=a

rray1，array()实现>>>array2array([[0,1,2,3],[4,5,6,7]])>>>array3=mat1.getA()#矩阵mat1→数组array3，array3=array1，getA()实现>>>array3array([[0,1,2,3],[4,5,6,7]])

>>>list2=mat1.tolist()#矩阵mat1→列表list2，list2=list1，tolist()实现>>>list2[[0,1,2,3],[4,5,6,7]]>>>list3=array3.tolist()#数组array3→

列表list3，list3=list1，tolist()实现>>>list3[[0,1,2,3],[4,5,6,7]]20matrix类型矩阵◆矩阵的运算两个矩阵相加减，即它们相同位置的元素相加减。只有对于两个行数、列数分别相

等的矩阵（即同型矩阵），加减法运算才有意义，这一点与二维数组的加减运算规则一致。当矩阵A的列数等于矩阵B的行数时，A与B两矩阵才可以相乘，两矩阵相乘按照矩阵的乘法运算规则，这一点与二维数组的乘法运算规则不同，二维数组的乘法运算规则同加减规则一致，按位相乘。一般

不进行两个矩阵直接相除，矩阵的除法是通过逆矩阵实现的。（1）矩阵的加减乘运算>>>importnumpyasnp>>>a=np.mat(np.arange(1,7).reshape(2,3))>>>amatrix(

[[1,2,3],[4,5,6]])>>>b=a>>>bmatrix([[1,2,3],[4,5,6]])>>>print(a+b)#矩阵相加，同型矩阵[[246][81012]]>>>print(a-b)#矩阵相减，同型矩阵[[000][000]]>

>>c=np.mat(np.arange(1,7).reshape(3,2))>>>cmatrix([[1,2],[3,4],[5,6]])>>>print(a*c)#矩阵相乘，a的列数等于矩阵c的行数[[2228][4964]]>>>print(np.dot(a,c))#矩阵点乘，a的列数等于矩

阵c的行数[[2228][4964]]>>>print(2*a)#数乘矩阵[[246][81012]]>>>print(a*2)#矩阵乘数[[246][81012]]21matrix类型矩阵◆矩阵的运算（2）矩阵的转置和求逆>>>pr

int(a.T)#矩阵转置[[14][25][36]]>>>print(a.I)#求逆矩阵[[-0.944444440.44444444][-0.111111110.11111111][0.72222222-0.22222222]]>>>print(a)[[123][456]]（3

）矩阵的求和及索引>>>print(a.sum(axis=0))#计算矩阵每一列的和[[579]]>>>print(a.sum(axis=1))#计算矩阵每一行的和[[6][15]]>>>print(a.max(axis=0))#计算矩

阵每一列的最大值[[456]]>>>print(a.max(axis=1))#计算矩阵每一行的最大值[[3][6]]>>>print(a.argmax(axis=0))#计算矩阵每一列的最大值索引[[111]]>>>print(a.argmax(a

xis=1))#计算矩阵每一行的最大值索引[[2][2]](4)矩阵的分割和合并>>>mat1=np.mat(np.arange(20).reshape(4,5))>>>print(mat1)[[01234][567

89][1011121314][1516171819]]#分割出行，2行（含）到最后行；列，3列（含）到最后列，所有元素>>>mat2=mat1[2:,3:]>>>print(mat2)[[1314][1819]]>>>mat3=mat1[:2,:]#分割出行，开始到2行（不含）

；列，所有列，所有元素>>>mat3matrix([[0,1,2,3,4],[5,6,7,8,9]])>>>mat4=mat1[2:,:]#分割出行，2行（含）到最后行；列，所有列，所有元素>>>ma

t4matrix([[10,11,12,13,14],[15,16,17,18,19]])>>>mat4=mat1[2:]#分割出行，2行（含）到最后行；列，所有列，所有元素>>>mat4matrix([[10,11,12,13,14],[15,16,17,18,19]])>>>mat

5=np.vstack((mat3,mat4))#按列合并，即列数不变>>>print(mat5)[[01234][56789][1011121314][1516171819]]>>>mat6=np.hstack((mat3,mat4))#

按行合并，即行数不变>>>print(mat6)[[012341011121314][567891516171819]]22matrix类型和array类型的区别numpy的matrix必须是2维的，但是numpy的array(ndarrays)可以是多维的（1D，2D，3D…ND

）；matrix是array的一个小的分支，包含于array，所以matrix拥有array的所有特性。但是numpy里面数组array遵循逐个元素的运算规则，而矩阵matrix遵循矩阵运算的规则。在二者做乘法运算和规约运算时要注意其区别。（1）矩阵和矩阵相乘>>>a=np.mat([

[1,2,3,4],[5,6,7,8]])#mat()函数将列表生成矩阵>>>print(a)#输出矩阵a的值[[1234][5678]]>>>print(type(a))#输出矩阵a的类型<class'numpy.matrixlib.defmatrix.matrix'>>>>prin

t(a.ndim)#输出矩阵a维数，维数2，矩阵必须是二维2>>>print(a.shape)#输出矩阵a形状，2行4列(2,4)>>>b=np.mat(np.arange(1,9).reshape(4,2))

#mat()函数将二维数组生成矩阵b>>>print(b)#输出矩阵b的值[[12][34][56][78]]>>>print(type(b))#输出矩阵b的类型<class'numpy.matrixlib.defmatrix.matrix'>>>>print(b.ndim)#

输出矩阵b维数，维数2，矩阵必须是二维2>>>print(b.shape)#输出矩阵b形状，4行2列(4,2)#矩阵a和b满足相乘的规则，用a*b求矩阵的乘>>>a*bmatrix([[50,60],[114,140]])>>>print(a*b)#输出矩阵a和矩阵b相乘

的结果，结果还是二维的矩阵[[5060][114140]]#用dot(a,b)求矩阵的乘>>>print(np.dot(a,b))[[5060][114140]]23matrix类型和array类型的区别(2)数组和数组相乘#

数组c和数组d相乘，也可用c*d>>>c=np.array([[1,2,3,4],[5,6,7,8]])#array()函数将列表生成2行4列数组>>>print(c)#输出数组c的值[[1234][5678]]>>>print(

type(c))#输出c的类型，数组类型<type'numpy.ndarray'>>>>print(c.ndim)#输出数组c维数，维数22>>>print(c.shape)#输出数组c形状，2行4列(2,4)#reshape()函数将arange()生成的一维数组重塑成4行2列数组>>

>d=np.arange(1,9).reshape(4,2)>>>print(d)#输出数组d的值，4行2列数组[[12][34][56][78]]>>>print(type(d))#输出d的类型，数组类型<type'numpy.ndarr

ay'>#二维数组c和d相乘，是对应元素相乘，两二维数组形状要一样>>>c*d#形状不一样，抛出异常Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>ValueError:operandscouldnotbe

broadcasttogetherwithshapes(2,4)(4,2)#reshape()函数将arange()生成的一维数组#重塑成2行4列数组>>>d=np.arange(1,9).reshape(2,4

)>>>print(d)#输出数组d的值，2行4列数组[[1234][5678]]>>>print(type(d))#输出d的类型，数组类型<type'numpy.ndarray'>#c和d形状一致，对应元素相乘>>>c*darray([[

1,4,9,16],[25,36,49,64]])24matrix类型和array类型的区别（3）归约运算数组array与矩阵matrix最大的不同是在做归约运算时，array的维数会发生变化，但matrix总是保持

为2维。#矩阵matrix做归约运算时，总是保持为2维>>>a=np.mat(np.arange(4).reshape(2,2))>>>amatrix([[0,1],[2,3]])>>>b=a.mean(1)#按行规约

，求平均值，矩阵维数2不变>>>bmatrix([[0.5],[2.5]])>>>b.shape(2,1)>>>b.ndim2#数组array做归约运算时，维数会发生变化>>>c=np.arange(4).reshape(2,2)>>>carray([[0

,1],[2,3]])>>>d=c.mean(1)#按行规约，求平均值，数组维数变为1>>>darray([0.5,2.5])>>>d.shape(2,)>>>d.ndim1pandas模块02pandas简介pandas是Python的

一个数据分析包，最初由AQRCapitalManagement于2008年4月开发，并于2009年底开源出来，目前由专注于Python数据包开发的PyData开发项目组继续开发和维护。pandas最初被作为金融数据分析工具而开发出来，因此，pandas为时间序列分析提供了很好的支持。P

ython中的所有数据类型在pandas中依然适用，pandas自己主要有一维Series、二维的表格型DataFrame和三维的Panel三种类型。一维Series与Numpy中的一维array类似，二者与Python基本的数据结构list也很相近，字符串、bool值、

数字等都能保存在Series中，其中Time-Series是以时间为索引的Series。二维的表格型数据结构DataFrame可以理解为Series的容器；三维的Panel可以理解为DataFrame的容器。这些数据类型让pandas操作数据显得更

加方便和高效，而三种类型中以DataFrame类型最为常用。26pandas基础1.Series类型>>>importnumpyasnp>>>importpandasaspd#用Series()创建Series类型对象#np.n

an的值为NaN，表示数据值缺失>>>s=pd.Series([1,3,4,5,6,np.nan,8,np.nan,10])>>>print(s)#输出s，显示成一列，有索引，元素类型默认是float6401132435465NaN687NaN810dtype:float64>>>print

(s.dtype)#输出s中元素类型，默认是float64float64>>>print(s.ndim)#输出s维数1>>>print(s.shape)#输出s形状(9,)>>>print(s.info())#Series无该属性，DataFr

ame有该属性Traceback(mostrecentcalllast):File"<stdin>",line1,in<module>File"/usr/lib/Python2.7/dist-packag

es/pandas/core/generic.py",line2360,in__getattr__(type(self).__name__,name))AttributeError:'Series'ob

jecthasnoattribute'info’27>>>print(type(s))#输出s的类型，是Series类型<class'pandas.core.series.Series'>>>>print(s.values)#输出s的v

alues值[1.3.4.5.6.nan8.nan10.]>>>s.values#输出s的values值，值是数组类型array([1.,3.,4.,5.,6.,nan,8.,nan,10.])>>>print(type(s.val

ues))#输出s.values的类型是ndarray数组类型<type'numpy.ndarray'>>>>print(s.index)#输出s的index值Int64Index([0,1,2,3,4,5,6,7,8],dty

pe='int64')>>s.index#输出s的index值，值是Int64Index类型Int64Index([0,1,2,3,4,5,6,7,8],dtype='int64')>>>print(type(s.index))#输出s.index的类型是Int64Index<cl

ass'pandas.core.index.Int64Index'>>>>print(s.sum())#输出s的各元素的和37.0pandas基础#输出s每个元素对应是否为空值NaN，False表示非空值，True表示是空值>>>print(s.isnull())0Fals

e1False2False3False4False5True6False7True8Falsedtype:bool#查看列是否存在空值，True表示有空值,False表示无空值>>>print(s.isnul

l().any(axis=0))True>>>print(s.isnull().any())#省略any()参数axis=0，功能同上True#计算有空值列的数量，要么是1，要么是0，因为只有1列>>>print(s.isnull().any(axis=0).sum())128pan

das基础2.DataFrame类型>>>importnumpyasnp>>>importpandasaspd（1）字典作为DataFrame()输入创建二维表格>>>df=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006],"dat

e":pd.date_range('20180101',periods=6),"city":['Beijing','shanghai','guangzhou','Shenzhen','nanjing','chang

zhou'],"age":[18,26,28,36,42,52],"category":['2018-A','2018-B','2018-C','2018-D','2018-E','2018-F'],"price":[1200,np.nan,2500,5500,

np.nan,4300]},columns=['id','date','city','category','age','price'])>>>df#显示df的值，带索引列（自动添加）和column行iddatecitycategoryage

price010012018-01-01Beijing2018-A181200.0110022018-01-02shanghai2018-B26NaN210032018-01-03guangzhou2018-C282

500.0310042018-01-04Shenzhen2018-D365500.0410052018-01-05nanjing2018-E42NaN510062018-01-06changzhou2018-F524300.0#查看二维表格类型DataFrame信息>>

>print(type(df))#输出df的类型<class'pandas.core.frame.DataFrame'>>>>print(df.ndim)#输出df的维数2>>>print(df.shape)#输出df的形状(6,6)>>>print(df

.dtypes)#输出df各列数据类型idint64datedatetime64[ns]cityobjectcategoryobjectageint64pricefloat64dtype:object29pandas基础2.DataFrame类型#输出df基本信息（类型

、行数、列数、列名称、每列数据类型、所占空间）>>>print(df.info())<class'pandas.core.frame.DataFrame'>Int64Index:6entries,0to5

Datacolumns(total6columns):id6non-nullint64date6non-nulldatetime64[ns]city6non-nullobjectcategory6non-nullobjectage6n

on-nullint64price4non-nullfloat64dtypes:datetime64[ns](1),float64(1),int64(2),object(2)memoryusage:336.0+bytesNone>>>print(df['date'])#输出DataFram

e某一列的值02018-01-0112018-01-0222018-01-0332018-01-0442018-01-0552018-01-06Name:date,dtype:datetime64[ns]>>>print(df[['age','price']]

)#输出DataFrame某几列的值ageprice0181200126NaN22825003365500442NaN552430030>>>print(df.isnull())#以二维表格形式，输出每个元素对应是否为空值N

aNiddatecitycategoryageprice0FalseFalseFalseFalseFalseFalse1FalseFalseFalseFalseFalseTrue2FalseFalseFalseFalseFalseFalse3FalseF

alseFalseFalseFalseFalse4FalseFalseFalseFalseFalseTrue5FalseFalseFalseFalseFalseFalse#查看各列是否存在空值，True表示有空值,False表示无空值>>>print(df.isnull().

any(axis=0))idFalsedateFalsecityFalsecategoryFalseageFalsepriceTruedtype:boolpandas基础2.DataFrame类型>>

>df.values#df.values的类型是二维数组类型array([[1001,Timestamp('2018-01-0100:00:00'),'Beijing','2018-A',18,1200.0],[1002,Ti

mestamp('2018-01-0200:00:00'),'shanghai','2018-B',26,nan],[1003,Timestamp('2018-01-0300:00:00'),'guangzhou','2018-C',28,2500.0],[1004

,Timestamp('2018-01-0400:00:00'),'Shenzhen','2018-D',36,5500.0],[1005,Timestamp('2018-01-0500:00:00'),'nanjing','2018-E',42,nan],[1006,Timestamp('2

018-01-0600:00:00'),'changzhou','2018-F',52,4300.0]],dtype=object)>>>print(df.columns)#输出df的列名称，df.columns的类型是Index类型Index([u'id',u'date',u'ci

ty',u'category',u'age',u'price'],dtype='object')>>>df.columnsIndex([u'id',u'date',u'city',u'category',u'age',u'price'],dtype='object')>>>pri

nt(df.index)#输出df的索引，是Int64Index类型Int64Index([0,1,2,3,4,5],dtype='int64')>>>print(type(df.index))#输出df.ind

ex的类型，是Int64Index类型<class'pandas.core.index.Int64Index'>>>>print(df.head())#查看前5行数据iddatecitycategoryageprice01

0012018-01-01Beijing2018-A181200.0110022018-01-02shanghai2018-B26NaN210032018-01-03guangzhou2018-C282500.0310042018-01-04Sh

enzhen2018-D365500.0410052018-01-05nanjing2018-E42NaN>>>print(df.tail())#查看后5行数据iddatecitycategoryageprice110022018-01-02sha

nghai2018-B26NaN210032018-01-03guangzhou2018-C282500.0310042018-01-04Shenzhen2018-D365500.0410052018-01-05nanjing20

18-E42NaN510062018-01-06changzhou2018-F524300.031pandas基础2.DataFrame类型（2）二维数组作为DataFrame()输入创建二维表格#创建5行4列成正态分布二维数组，作为DataFra

me的values>>>print(np.random.randn(5,4))[[-1.561647680.23250797-0.60714462-0.34239522][1.38752891-0.887990060.34465538-0.71466392][-0.21680858-0.7357

44510.64413335-0.63590005][-0.574225740.35862263-1.13393719-1.55768979][-0.8067230.218436851.05660182-0.19729089]]#创建日期型索引

，作为作为DataFrame的index>>>dates=pd.date_range('20180101',periods=5)>>>print(dates)DatetimeIndex(['2018-01-01','2018-

01-02','2018-01-03','2018-01-04','2018-01-05'],dtype='datetime64[ns]',freq='D')#指定DataFrame的values、index和columns，用pandas的DataFrame()

创建二维表格>>>df=pd.DataFrame(np.random.randn(5,4),index=dates,columns=list('ABCD'))>>>print(df)ABCD2018-01-011.1586882.20477

11.027239-0.6735522018-01-02-0.9390680.170598-1.367631-1.0079762018-01-031.5185612.3058930.899330-1.2883552018-01-04-0.265

7872.0611180.2140482.4764142018-01-05-1.390000-1.8462060.418815-0.170965>>>df=pd.DataFrame(np.random.randn(5,4

),index=dates,columns=['A','B','C','D'])>>>print(df)ABCD2018-01-010.410627-0.0538080.9534410.4677232018-01-02-0.193324-0.4478910

.7852820.2537612018-01-031.5409000.0850000.894841-0.6110102018-01-04-1.5803780.2309950.523364-0.7657422018-01-051.497

622-0.0657090.894580-0.07945832#省略索引和列名称，采用默认的索引和列名称>>>df=pd.DataFrame(np.random.randn(5,4))>>>print(df)012300.481351-1.335567-0

.9477190.69018511.833256-1.3452760.7465581.4805332-0.0729620.9824861.311147-0.6715663-1.171508-0.631660-1.1337720.8577774-

1.505808-1.2549981.716109-0.921805pandas基础3.panel类型(1)创建面板#从3Dndarry类型的对象创建>>>data=np.random.rand(2,4,5)>>>p=pd.Panel(data)>>>p<class'

pandas.core.panel.Panel'>Dimensions:2(items)x4(major_axis)x5(minor_axis)Itemsaxis:0to1Major_axisaxis:0to

3Minor_axisaxis:0to4#Items-axis0，每个项目对应于内部包含的数据帧(DataFrame)。#Major_axis-axis1，它是每个数据帧(DataFrame)的索引(行)。#Mnor_axis-axis2，它是每个数据帧(DataFr

ame)的列。#从字典类型的对象创建>>>data={'Item1':pd.DataFrame(np.random.randn(4,3)),'Item2':pd.DataFrame(np.random.randn(4,2))}>>>p=pd.Panel(data)

>>>p<class'pandas.core.panel.Panel'>Dimensions:2(items)x4(major_axis)x3(minor_axis)Itemsaxis:Item1toItem2Major_axisaxis:0to3Minor_axis

axis:0to233(2)数据选择#要从面板中选择数据，可以使用：Items、Major_axis、Minor_axis>>>p['Item1']0120-0.9530240.9646191.6429651-1.0261791.9462680.5027872-0.

3923960.1647570.1146923-1.5287662.8200330.204405>>>p.major_xs(1)#panel.major_axis(index)格式Item1Item20-1.0261

79-1.45553911.946268-1.59811920.502787NaN>>>p.minor_xs(1)#panel.minor_axis(index)格式Item1Item200.9646190.07975111.946268-1.59811920.164757-0

.25508432.8200330.072696pandas模块数据清洗可靠正确的数据才具备分析出可靠正确结果的前提，但用于分析的原始数据往往存在较多问题，因此数据清洗必不可少。数据清洗是整个数据分析过程中一项非常重要，但又复杂且繁琐

的工作，有分析称清洗数据约占整个项目80%的时间。数据清洗的目的是通过清洗让数据可用，便于后续的分析工作。在数据清洗之前必须首先理解数据，理解数据的列/行、记录、数据格式、语义错误、缺失的条目以及错误的格式等，这样就可以大概了解数据分析之前要做哪些“清洗”工作。数据清洗主要是

对数据中的重复值、异常值、空值、多余的空格和大小写错误等的处理。本节将介绍几种常用的数据清洗方法。34pandas模块数据清洗1.空值/缺失值处理（1）检查数据表中的空值数量>>>importnumpyasnp>>>importpandasaspd>>>df=pd.DataFrame(

{"id":[1001,1002,1002,1003,1004,1004,1005,1006,np.nan],"date":pd.date_range('20180101',periods=9),"city":['BeiJing','ShangHai','ShangHai'

,'GuangZhou','ShenZhen','ShenZhen','NanJing','ChangZhou',np.nan],"city":['BeiJing','ShangHai','ShangHai','GuangZhou','ShenZhen','ShenZhen','NanJing'

,'ChangZhou',np.nan],"age":[-18,20,20,28,36,36,42,152,np.nan],"category":['2018-A','2018-B','2018-B'

,'2018-C','2018-D','2018-D','2018-E','2018-F',np.nan],"age":[18,20,20,28,36,36,42,152,np.nan],"price":[1200,np.nan,np.nan,25

00,5500,5500,np.nan,4300,np.nan],"na":[np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan,np.nan]},columns=['id','date','city','

city','age','category','age','price','na'])>>>dfiddatecitycityagecategoryagepricena01001.02018-01-01BeiJingBeiJing18.0201

8-A18.01200.0NaN11002.02018-01-02ShangHaiShangHai20.02018-B20.0NaNNaN21002.02018-01-03ShangHaiShangHai20.02018-B20.0NaNNaN31003.

02018-01-04GuangZhouGuangZhou28.02018-C28.02500.0NaN41004.02018-01-05ShenZhenShenZhen36.02018-D36.05500.0NaN51004.0

2018-01-06ShenZhenShenZhen36.02018-D36.05500.0NaN61005.02018-01-07NanJingNanJing42.02018-E42.0NaNNaN71006.02018-01-08ChangZhouChangZhou152.02018

-F152.04300.0NaN8NaN2018-01-09NaNNaNNaNNaNNaNNaNNaN>>>df.shape#df的形状9行9列(9,9)>>>df.isnull().any(axis=0).sum(

)#df有空值列的列数量共计8列8>>>df.isnull().all(axis=0).sum()#df有全部是空值列的列数量共计1列135pandas模块数据清洗1.空值/缺失值处理（2）处理缺失数据的方法典型的处理缺失数据的方法一般是使用初始值、均值或高频值填充代替或删除数据缺失的记录

。填充代替使用fillna()函数对空值进行填充，可以选择填充0值或者其它合适的值。删除使用dropna()函数直接将包含空值的数据删除。①填充0值或均值>>>df1=df>>>df1#用0进行填充，当然

填的值要根据具体处理对象进行选择>>>df1.fillna(value=0)iddatecitycityagecategoryagepricena01001.02018-01-01BeiJingBeiJing18.02018-A18.01200.00.011002.02018

-01-02ShangHaiShangHai20.02018-B20.00.00.021002.02018-01-03ShangHaiShangHai20.02018-B20.00.00.031003.02018-01-0

4GuangZhouGuangZhou28.02018-C28.02500.00.041004.02018-01-05ShenZhenShenZhen36.02018-D36.05500.00.051004.02018-01-06

ShenZhenShenZhen36.02018-D36.05500.00.061005.02018-01-07NanJingNanJing42.02018-E42.00.00.071006.02018-01-08ChangZhouChangZho

u152.02018-F152.04300.00.080.02018-01-09000.000.00.00.0#对price列所有值的均值填充>>>df1['price']=df1['price'].fillna(value=df1['price'].mean())>>>df1

iddatecitycityagecategoryagepricena01001.02018-01-01BeiJingBeiJing18.02018-A18.01200.0NaN11002.02018-01-02ShangHaiShangHai20.02018-B2

0.03800.0NaN21002.02018-01-03ShangHaiShangHai20.02018-B20.03800.0NaN31003.02018-01-04GuangZhouGuangZhou28.02018-C28.02500.

0NaN41004.02018-01-05ShenZhenShenZhen36.02018-D36.05500.0NaN51004.02018-01-06ShenZhenShenZhen36.02018-D36.05500.0NaN61005

.02018-01-07NanJingNanJing42.02018-E42.03800.0NaN71006.02018-01-08ChangZhouChangZhou152.02018-F152.04300.0NaN8NaN20

18-01-09NaNNaNNaNNaNNaN3800.0NaN36pandas模块数据清洗1.空值/缺失值处理（2）处理缺失数据的方法②删除不完整的列和行#使用dropna()方法删除不完整的行或者列>>>df1iddatecitycityagecate

goryagepricena01001.02018-01-01BeiJingBeiJing18.02018-A18.01200.0NaN11002.02018-01-02ShangHaiShangHai20.02018-B20.03800.

0NaN21002.02018-01-03ShangHaiShangHai20.02018-B20.03800.0NaN31003.02018-01-04GuangZhouGuangZhou28.02018-C28.0250

0.0NaN41004.02018-01-05ShenZhenShenZhen36.02018-D36.05500.0NaN51004.02018-01-06ShenZhenShenZhen36.02018-D36.05500.0NaN61

005.02018-01-07NanJingNanJing42.02018-E42.03800.0NaN71006.02018-01-08ChangZhouChangZhou152.02018-F152.04300.0NaN8N

aN2018-01-09NaNNaNNaNNaNNaN3800.0NaN>>>df1.dropna(axis=1,how='all')#删除一整列全为空值NaN的列iddatecitycityagecategoryagep

rice01001.02018-01-01BeiJingBeiJing18.02018-A18.01200.011002.02018-01-02ShangHaiShangHai20.02018-B20.03800

.021002.02018-01-03ShangHaiShangHai20.02018-B20.03800.031003.02018-01-04GuangZhouGuangZhou28.02018-C28.0250

0.041004.02018-01-05ShenZhenShenZhen36.02018-D36.05500.051004.02018-01-06ShenZhenShenZhen36.02018-D36.05500.061005.02018-01-07NanJin

gNanJing42.02018-E42.03800.071006.02018-01-08ChangZhouChangZhou152.02018-F152.04300.08NaN2018-01-09NaNNaNNaNNaN

NaN3800.037pandas模块数据清洗1.空值/缺失值处理（2）处理缺失数据的方法②删除不完整的列和行>>>df1.dropna(axis=1,how='any')#删除任何包含空值NaN的列，行不删除dateprice02018-01-011200.012018-

01-023800.022018-01-033800.032018-01-042500.042018-01-055500.052018-01-065500.062018-01-073800.072018-01-084300.082018-01-093800.0#删除全为空值NaN的列和有空

值NaN的行>>>df1.dropna(axis=1,how='all').dropna(axis=0,how='any')iddatecitycityagecategoryageprice01001.02018-01-01BeiJingBeiJin

g18.02018-A18.01200.011002.02018-01-02ShangHaiShangHai20.02018-B20.03800.021002.02018-01-03ShangHaiShangHai20.02018-B20.0

3800.031003.02018-01-04GuangZhouGuangZhou28.02018-C28.02500.041004.02018-01-05ShenZhenShenZhen36.02018-D36.05500.0

51004.02018-01-06ShenZhenShenZhen36.02018-D36.05500.061005.02018-01-07NanJingNanJing42.02018-E42.03800.071006.02018

-01-08ChangZhouChangZhou152.02018-F152.04300.038pandas模块数据清洗1.空值/缺失值处理（2）处理缺失数据的方法③其它处理方法>>>df1iddatecitycityagecategoryagep

ricena01001.02018-01-01BeiJingBeiJing18.02018-A18.01200.0NaN11002.02018-01-02ShangHaiShangHai20.02018-B20.03800.0NaN21002.0201

8-01-03ShangHaiShangHai20.02018-B20.03800.0NaN31003.02018-01-04GuangZhouGuangZhou28.02018-C28.02500.0NaN41004.02018-01-05ShenZhenShen

Zhen36.02018-D36.05500.0NaN51004.02018-01-06ShenZhenShenZhen36.02018-D36.05500.0NaN61005.02018-01-07NanJingNanJing42.02018-E42.03800.

0NaN71006.02018-01-08ChangZhouChangZhou152.02018-F152.04300.0NaN8NaN2018-01-09NaNNaNNaNNaNNaN3800.0NaN#用iloc和loc选取DataFrame中的数据>>>df1.i

loc[8,1]#选取8行1列元素Timestamp('2018-01-0900:00:00')#时间戳类型值为2018-01-0900:00:0>>>df1.iloc[1:4,3]#选取1、2、3行，第3列的数据1ShangHai2ShangHai3GuangZhouName:city,d

type:object>>>df1.loc[1:3,"city"]#选取1、2、3行，“city”列的数据citycity1ShangHaiShangHai2ShangHaiShangHai3GuangZhouGuangZhou39pandas模块数据清洗1.空值/缺失值

处理（2）处理缺失数据的方法③其它处理方法#iloc是根据行号来索引的，从0行开始，loc是根据行的索引号来索引的>>>df1.iloc[8,1]=np.nan#给df1的8行1列元素赋空值NaN，由于该字段是时间类

型因此是NaT>>>df1iddatecitycityagecategoryagepricena01001.02018-01-01BeiJingBeiJing18.02018-A18.01200.0NaN11002.02018-01-02S

hangHaiShangHai20.02018-B20.03800.0NaN21002.02018-01-03ShangHaiShangHai20.02018-B20.03800.0NaN31003.02018-01-04GuangZhouGuangZhou28.02018-C28.02

500.0NaN41004.02018-01-05ShenZhenShenZhen36.02018-D36.05500.0NaN51004.02018-01-06ShenZhenShenZhen36.020

18-D36.05500.0NaN61005.02018-01-07NanJingNanJing42.02018-E42.03800.0NaN71006.02018-01-08ChangZhouChangZhou152.02018-F152.04300.0NaN8NaNNaTNaNNaNNaN

NaNNaN3800.0NaN#删除price列；用del也可以删除列deldf1['price']>>>df2=df1.drop(['price'],axis=1)>>>df2iddatecitycityagecategoryagena01001.02018-01-0

1BeiJingBeiJing18.02018-A18.0NaN11002.02018-01-02ShangHaiShangHai20.02018-B20.0NaN21002.02018-01-03ShangHaiShangH

ai20.02018-B20.0NaN31003.02018-01-04GuangZhouGuangZhou28.02018-C28.0NaN41004.02018-01-05ShenZhenShenZhen36.02018-D36.0NaN51004.02018

-01-06ShenZhenShenZhen36.02018-D36.0NaN61005.02018-01-07NanJingNanJing42.02018-E42.0NaN71006.02018-01

-08ChangZhouChangZhou152.02018-F152.0NaN8NaNNaTNaNNaNNaNNaNNaNNaN40pandas模块数据清洗1.空值/缺失值处理（2）处理缺失数据的方法③其它处理方法#删除任何包含空值的行，列不删除>>>d

f3.dropna(axis=0,how='any')iddatecitycityagecategoryagena01001.02018-01-01BeiJingBeiJing18.02018-A18.099.011

002.02018-01-02ShangHaiShangHai20.02018-B20.088.0>>>df3.dropna(thresh=2)#一行中至少要有2非空值的数据是可以保留下来iddatecitycityagecategoryagena01001.02018-01-01BeiJin

gBeiJing18.02018-A18.099.011002.02018-01-02ShangHaiShangHai20.02018-B20.088.021002.02018-01-03ShangHaiShangHai20.02018-B20.0NaN31003.02018-01-04

GuangZhouGuangZhou28.02018-C28.0NaN41004.02018-01-05ShenZhenShenZhen36.02018-D36.0NaN51004.02018-01-06ShenZhenShenZhen36.02018-D36.0NaN61

005.02018-01-07NanJingNanJing42.02018-E42.0NaN71006.02018-01-08ChangZhouChangZhou152.02018-F152.0NaN>>>df

3.dropna(thresh=8)#一行中至少要有8非空值的数据是可以保留下来iddatecitycityagecategoryagena01001.02018-01-01BeiJingBeiJing18.02018-A18.099.011002.

02018-01-02ShangHaiShangHai20.02018-B20.088.041pandas模块数据清洗1.空值/缺失值处理（2）处理缺失数据的方法③其它处理方法#删除一整行全为空值的行，参数axis可以省咯，默认是axis=0>>>df3=df2.dropna(axis=0,ho

w='all')>>>df3iddatecitycityagecategoryagena01001.02018-01-01BeiJingBeiJing18.02018-A18.0NaN11002.02018-0

1-02ShangHaiShangHai20.02018-B20.0NaN21002.02018-01-03ShangHaiShangHai20.02018-B20.0NaN31003.02018-01-04Guan

gZhouGuangZhou28.02018-C28.0NaN41004.02018-01-05ShenZhenShenZhen36.02018-D36.0NaN51004.02018-01-06ShenZhenShenZhen36.02018-D36.0NaN610

05.02018-01-07NanJingNanJing42.02018-E42.0NaN71006.02018-01-08ChangZhouChangZhou152.02018-F152.0NaN>>>df3.iloc[0,7]

=99#修改最后一列前两个元素值为99,88>>>df3.iloc[1,7]=88>>>df3iddatecitycityagecategoryagena01001.02018-01-01BeiJingBeiJing18.02018-A18.099.011002.02018-01-02Sha

ngHaiShangHai20.02018-B20.088.021002.02018-01-03ShangHaiShangHai20.02018-B20.0NaN31003.02018-01-04GuangZhouGuangZhou28.02018-C28.0NaN41004.02018-01

-05ShenZhenShenZhen36.02018-D36.0NaN51004.02018-01-06ShenZhenShenZhen36.02018-D36.0NaN61005.02018-01-07NanJingNanJing42.020

18-E42.0NaN71006.02018-01-08ChangZhouChangZhou152.02018-F152.0NaN42pandas模块数据清洗2.去重DataFrame中存在重复的行或者行中某几列的值重复，一般使用drop()和drop_duplicates()方法

，其结果是产生一个新的DataFrame，如果inplace参数赋值是True，则在原来DataFrame上进行修改。>>>dfqc=pd.DataFrame({'a':[1,1,4,3,3],'b':[2,2,3

,2,2],'c':[3,3,2,2,4]})>>>dfqc1=dfqc>>>dfqc1abc01231123243233224324#a列元素有重复第一行保留其余行去除>>>dfqc1.drop_duplicates(subset=['a'],keep='first

',inplace=False)abc012324323322#a列元素有重复，最后一行保留其余行去除>>>dfqc1.drop_duplicates(subset=['a'],keep='last')abc11232432432443#a列元素有重

复的行全部去除，inplace省略>>>dfqc1.drop_duplicates(subset=['a'],keep=False)abc2432#a、b、c列元素都有重复，第一行保留其余行去除>>>dfqc1.drop_duplicates(subset

=['a','b','c'])abc0123243233224324#subset=None所有列元素相同的行去除>>>dfqc1.drop_duplicates(subset=None,keep='

first',inplace=False)abc0123243233224324#dfqc1值经过以上操作未变，因inplace默认为False，即生成一个副本未在原DataFrame上删除>>>dfqc1abc0

1231123243233224324#inplace=True在原DataFrame上删除重复行，默认False生成副本>>>dfqc1.drop_duplicates(inplace=True)>>>dfqc1abc0

123243233224324>>>dfqc#dfqc的值一起变化，原因是“dfqc1=dfqc”是浅复制，如果深复制可用copy()abc0123243233224324pandas模块数据清洗2.去重>>>dfqc1.drop_du

plicates(subset=['a'],keep=False)abc2432#a、b、c列元素都有重复，第一行保留其余行去除>>>dfqc1.drop_duplicates(subset=['a','b','c'])abc012324323

3224324#subset=None所有列元素相同的行去除>>>dfqc1.drop_duplicates(subset=None,keep='first',inplace=False)abc01232432332243

24#dfqc1值经过以上操作未变，因inplace默认为False，即生成一个副本，未在原DataFrame上删除>>>dfqc1abc01231123243233224324#inplace=True在原Data

Frame上删除重复行，默认False生成副本44pandas模块数据清洗2.去重45>>>dfqc1.drop_duplicates(inplace=True)>>>dfqc1abc0123243233224324#dfqc的值一起变化，原因是“dfqc1=dfqc”是

浅复制，如果深复制可用copy()>>>dfqcabc0123243233224324pandas模块数据清洗463.删除数据间的空格数据中的空格会影响后续数据的统计和计算，Python中去除空格的方法有三种，第一种是去除数据两边的空格，第二种是单独去除左边的空格，第三种是单独去除右边的空格。>

>>df=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006],"date":pd.date_range('20180101',periods=6),"city":['B

eiJing','ShangHai','GuangZhou','ShenZhen','NanJing','ChangZhou'],"age":[-18,20,28,36,36,152],"category":['2018-A','2018-B','

2018-C','2018-D','2018-E','2018-F'],"price":[1200,2500,5500,5500,4300,6200]},columns=['id','date','city','age','category','price'])>>>dfiddateci

tyagecategoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B2500210032018-01-03GuangZhou282018-C5500310

042018-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4300510062018-01-06ChangZhou1522018-F6200>>>df1=df.copy()

>>>df1iddatecityagecategoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B2500210032018-01-03Guan

gZhou282018-C5500310042018-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4300510062018-01-06ChangZhou1522018-F6200pandas模块数据清洗4

73.删除数据间的空格>>>df1['city']=df1['city'].map(str.lstrip)#单独去除左边空格>>>df1iddatecityagecategoryprice010012018-01-01BeiJing-182018-A

1200110022018-01-02ShangHai202018-B2500210032018-01-03GuangZhou282018-C5500310042018-01-04ShenZhen362018-D5500410052018-01-05NanJi

ng362018-E4300510062018-01-06ChangZhou1522018-F6200>>>df1['city']=df1['city'].map(str.rstrip)#单独去除右边空格>>>d

f1iddatecityagecategoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B2500210032018-01-03GuangZhou282018-C5500310042018-01-04

ShenZhen362018-D5500410052018-01-05NanJing362018-E4300510062018-01-06ChangZhou1522018-F6200>>>df1=df>>>df1idda

tecityagecategoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B2500210032018-01-0

3GuangZhou282018-C5500310042018-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4300510062018-01-06ChangZhou1522018-F620

0pandas模块数据清洗484.大小写字母转换#大小写转换的方法也有三种可以选择，分别为全部转换为大写、全部转换为小写、转换为首字母大写>>>df1['city']=df1['city'].str.lower()#转换成小写字母>>>df

1iddatecityagecategoryprice010012018-01-01beijing-182018-A1200110022018-01-02shanghai202018-B2500210032018-01-03guangzhou282018-C5

500310042018-01-04shenzhen362018-D5500410052018-01-05nanjing362018-E4300510062018-01-06changzhou1522018-F6200

>>>df1['city']=df1['city'].str.upper()#转换成大写字母>>>df1iddatecityagecategoryprice010012018-01-01BEIJING-182018-A1200110

022018-01-02SHANGHAI202018-B2500210032018-01-03GUANGZHOU282018-C5500310042018-01-04SHENZHEN362018-D5500410052018-01-05NANJING362018-

E4300510062018-01-06CHANGZHOU1522018-F6200>>>df1['city']=df1['city'].map(str.lower)#转换成小写字母>>>df1iddatecityagecategoryprice010012018-01-01beijin

g-182018-A1200110022018-01-02shanghai202018-B2500210032018-01-03guangzhou282018-C5500310042018-01-04shenzhen362018-D5500410052018-0

1-05nanjing362018-E4300510062018-01-06changzhou1522018-F6200pandas模块数据清洗494.大小写字母转换>>>df1['city']=df1['cit

y'].map(str.upper)#转换成大写字母>>>df1iddatecityagecategoryprice010012018-01-01BEIJING-182018-A1200110022018-01-02SHANGHAI202018-B2500

210032018-01-03GUANGZHOU282018-C5500310042018-01-04SHENZHEN362018-D5500410052018-01-05NANJING362018-E430

0510062018-01-06CHANGZHOU1522018-F6200>>>df1['city']=df1['city'].map(str.title)#转换成首字母大写>>>df1iddatecit

yagecategoryprice010012018-01-01Beijing-182018-A1200110022018-01-02Shanghai202018-B2500210032018-01-03Guangzhou282018-C5500310042018-01-04Shenzhen362

018-D5500410052018-01-05Nanjing362018-E4300510062018-01-06Changzhou1522018-F6200pandas模块数据清洗505.关键字段内容统

一性检查数据表中关键字段的内容还需要进行检查，确保关键字段中内容统一。主要包括数据是否全部为字符、数字、字符数字组合，如果不符合标准则可能存在问题。>>>df=pd.DataFrame({'a':[18,88,92,22,200],'b':[2

2,'a',100,90,42],'c':['a','c','d','e','f'],'d':['d','e','a',66,'k'],'e':['q','z','#','e','r']},columns=list(

'abcde'))>>>dfabcde01822adq188acez292100da#32290e66e420042fkr>>>df.info()#查看df基本信息<class'pandas.core.frame.DataFrame'>

RangeIndex:5entries,0to4Datacolumns(total5columns):a5non-nullint64b5non-nullobjectc5non-nullobjectd5non-nullobjecte5non-nullobjec

tdtypes:int64(1),object(4)memoryusage:280.0+bytes>>>df['a'].astype(np.string_)#将'a'列内容转换成字符串0b'18'1b'88'2b'92'3b'22'4b'200

'Name:a,dtype:bytes168pandas模块数据清洗515.关键字段内容统一性检查>>>df['a']=df['a'].astype(np.string_)#修改'a'列内容，转换成字符串类型>>>

df.info()<class'pandas.core.frame.DataFrame'>RangeIndex:5entries,0to4Datacolumns(total5columns):a5non-null|S21b5non-nullobjectc5non-nullobjectd5

non-nullobjecte5non-nullobjectdtypes:bytes168(1),object(4)memoryusage:345.0+bytes>>>df['a'].apply(lambdax:x.isdigit())#判断'a'列字符串内容是否全部为数字

0True1True2True3True4TrueName:a,dtype:bool>>>dfabcde0b'18'22adq1b'88'acez2b'92'100da#3b'22'90e66e4b'

200'42fkrpandas模块数据清洗525.关键字段内容统一性检查>>>df['b']=df['b'].astype(np.string_)#修改'b'列内容，转换成字符串类型>>>df['b'].apply(lambdax:x

.isdigit())#判断'b'列内容是否全部为数字0True1False2True3True4TrueName:b,dtype:bool>>>df['c'].apply(lambdax:x.isalnum())#'c'列内容是否全部为字母和数字0Tr

ue1True2True3True4TrueName:c,dtype:bool>>>df['e'].apply(lambdax:x.isalnum())#'e'列内容是否全部为字母和数字0True1True2False3True4TrueName:e,dty

pe:bool>>>df['c'].apply(lambdax:x.isalpha())#'c'列内容是否全部为字母0True1True2True3True4TrueName:c,dtype:boolpandas模块数据清洗536.异常值和极端值查看对于数值型数据，需

要检查发现异常值和极端值，这些值一般不符合业务逻辑，方法是使用describe()函数生成数据的描述统计结果，该函数只会针对数值型变量做计算，主要关注最大值(max)和最小值(min)情况。>>>df1=pd.DataFrame(np.arange(12).reshape(3,4))>

>>df1012300123145672891011>>>df1.describe().T#查看数值型列的汇总统计，并转置countmeanstdmin25%50%75%max03.04.04.00.02.04.

06.08.013.05.04.01.03.05.07.09.023.06.04.02.04.06.08.010.033.07.04.03.05.07.09.011.0>>>df1.describe().a

stype(np.int64)#查看数值型列的汇总统计，转换成整型0123count3333mean4567std4444min012325%234550%456775%6789max891011pandas模块数据清洗547.数据替换数

据替换可使用replace()函数，replace()的基本结构是df.replace(原值1,新值1,inplace=True)，原值和新值可以用列表或字典给出。replace()函数可以搜索整个DataFrame，并将其中所有原值替换成新值，如df.replace()，也

可以对某一列或几列数据的值进行替换，如df[列名].replace()。replace()函数还可以对部分列的字符串进行部分或全部替换成另个字符串，如df[列名]=df[列名].str.replace(原字符串全部或部分,新字符串,)，还可以用正则表达式，如df.replace(‘[A-Z]

’，’中国’，regex=True)，将df的“A-Z”字母替换为“中国”，regex=True参数必不可少。>>>df1#比如上面最大值11和最小值0是异常值，可以使用replace函数替换异常数据012300123145

672891011#用平均值替换，抛出异常>>>df1.replace([0,11],df1.mean())Traceback(mostrecentcalllast):File"<pyshell#183>",line1,in<module>df1.replace([0,11],df1.mean(

))File"C:\Users\Administrator\AppData\Local\Programs\Python\Python36\lib\site-packages\pandas\core\generic.py",line457

5,inreplace(len(to_replace),len(value)))ValueError:Replacementlistsmustmatchinlength.Expecting2got4>>>df1.mean()0

4152637dtype:float64>>>df1.mean().mean()#df1各列的平均值再求平均值5.5pandas模块数据清洗557.数据替换#replace()中前一参数列表内多个值，后一参数1个值>>>df1.replace([0,11],df

1.mean().mean())012305.5123.014.0567.028.09105.5>>>df1#df1值未改变012300123145672891011#inplace=True原地操作，df1值被改变>>>d

f1.replace([0,11],df1.mean().mean(),inplace=True)>>>df1012305.5123.014.0567.028.09105.5>>>df=pd.DataFrame({'省份':['城市-A','城市-

A','城市-B','城市-B','城市-C','城市-C'],'编码':['ab33.33gp','ab33.335s','ab33.88ps','ab33.899g','ab33.92ag','ab33.92ap'],'城市':['城市-B','城市

-C','城市-A','城市-C','城市-A','城市-B'],'suzhilie1':[np.nan,211.86,211.87,211.87,211.85,211.85],'suzhilie2':[33.88,33.92,np.nan,33.92,33.33,33.88],

'suzhilie3':[211.87,211.85,211.86,211.85,np.nan,211.87]},columns=['省份','编码','城市','suzhilie1','suzhilie2','suzhilie3'])>>>df省份编码城市suzhilie1suzhilie

2suzhilie30城市-Aab33.33gp城市-BNaN33.88211.871城市-Aab33.335s城市-C211.8633.92211.852城市-Bab33.88ps城市-A211.87NaN211.863城市-Bab33.899g城市-C211.8733.92211.854

城市-Cab33.92ag城市-A211.8533.33NaN5城市-Cab33.92ap城市-B211.8533.88211.87pandas模块数据清洗567.数据替换>>>df1=df.copy()#深复制备份>>>df1省份编码城市suzhilie1s

uzhilie2suzhilie30城市-Aab33.33gp城市-BNaN33.88211.871城市-Aab33.335s城市-C211.8633.92211.852城市-Bab33.88ps城市-A211.87NaN211.863城市-Bab

33.899g城市-C211.8733.92211.854城市-Cab33.92ag城市-A211.8533.33NaN5城市-Cab33.92ap城市-B211.8533.88211.87>>>df1.info()<class'pandas.core.fra

me.DataFrame'>Int64Index:6entries,0to5Datacolumns(total6columns):省份6non-nullobject编码6non-nullobject城市6non-nullobjectsuzhilie15non-nul

lfloat64suzhilie25non-nullfloat64suzhilie35non-nullfloat64dtypes:float64(3),object(3)memoryusage:336.0+bytes>>>df1['suzhilie3

'].replace(211.85,'A',inplace=True)#对df1指定1列原地操作，数值211.85被字符A代替>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城市-Aa

b33.33gp城市-BNaN33.88211.871城市-Aab33.335s城市-C211.8633.92A2城市-Bab33.88ps城市-A211.87NaN211.863城市-Bab33.899g城市-C211.8733.92A4城市-Cab33.92ag

城市-A211.8533.33NaN5城市-Cab33.92ap城市-B211.8533.88211.87pandas模块数据清洗577.数据替换#df1整体操作，前列表多个值，替换为后面1个值，类型不同>>>df1.r

eplace(['A',33.88],'B')省份编码城市suzhilie1suzhilie2suzhilie30城市-Aab33.33gp城市-BNaNB211.871城市-Aab33.335s城市-C211.8633.92B2城市-Bab33

.88ps城市-A211.87NaN211.863城市-Bab33.899g城市-C211.8733.92B4城市-Cab33.92ag城市-A211.8533.33NaN5城市-Cab33.92ap城市-B211.85B211.87#df1一列多个值，替换

为对应多个值>>>df1['城市'].replace(['城市-B','城市-A'],['A','E'],inplace=True)>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城市-Aab33.33gpANaN33.88211.871城市-Aa

b33.335s城市-C211.8633.92A2城市-Bab33.88psE211.87NaN211.863城市-Bab33.899g城市-C211.8733.92A4城市-Cab33.92agE211.8533.33NaN5城市-

Cab33.92apA211.8533.88211.87#df1整体操作，regex=True表示用正则表达式，所有A-Z替换为城市>>>df1.replace('[A-Z]','城市',regex=True)省份编码城市suzh

ilie1suzhilie2suzhilie30城市-城市ab33.33gp城市NaN33.88211.871城市-城市ab33.335s城市-城市211.8633.92城市2城市-城市ab33.88ps城市211.87NaN211.863城市-城市ab33.899g城市-城

市211.8733.92城市4城市-城市ab33.92ag城市211.8533.33NaN5城市-城市ab33.92ap城市211.8533.88211.87pandas模块数据清洗587.数据替换>>>df1#上一步操

作没有给df1重新赋值，或使用原地inplace=True,因此df1未变省份编码城市suzhilie1suzhilie2suzhilie30城市-Aab33.33gpANaN33.88211.871城市-Aab33.3

35s城市-C211.8633.92A2城市-Bab33.88psE211.87NaN211.863城市-Bab33.899g城市-C211.8733.92A4城市-Cab33.92agE211.8533.33NaN5城市-Cab33.92apA211.8533.88211.87>>>df

1.info()#查看df1各列类型，<class'pandas.core.frame.DataFrame'>RangeIndex:6entries,0to5Datacolumns(total6columns):省份

6non-nullobject编码6non-nullobject城市6non-nullobjectsuzhilie15non-nullfloat64suzhilie25non-nullfloat64suzhilie35non-nullobjectdtypes:float64(2),obje

ct(4)memoryusage:368.0+bytes#对df1整体操作，只有suzhilie2列数值型33.88替换为字符型'B'>>>df1.replace(33.88,'B')省份编码城市suzhilie1suzhilie2suzh

ilie30城市-Aab33.33gpANaNB211.871城市-Aab33.335s城市-C211.8633.92A2城市-Bab33.88psE211.87NaN211.863城市-Bab33.899g城市-C211.8733.92A4城市-

Cab33.92agE211.8533.33NaN5城市-Cab33.92apA211.85B211.87pandas模块数据清洗597.数据替换>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城市-Aab33.33gpANaN33.882

11.871城市-Aab33.335s城市-C211.8633.92A2城市-Bab33.88psE211.87NaN211.863城市-Bab33.899g城市-C211.8733.92A4城市-Cab33.92agE211

.8533.33NaN5城市-Cab33.92apA211.8533.88211.87#不能实现将编码列33.88替换为B>>>df1['编码']=df1['编码'].replace('33.88','B')>>>df1省份编码城市suzhi

lie1suzhilie2suzhilie30城市-Aab33.33gpANaN33.88211.871城市-Aab33.335s城市-C211.8633.92A2城市-Bab33.88psE211.87NaN211

.863城市-Bab33.899g城市-C211.8733.92A4城市-Cab33.92agE211.8533.33NaN5城市-Cab33.92apA211.8533.88211.87#用.str转换为字符型，实现将编码列33.88替换为B>>>df1['编码']=df1['编

码'].str.replace('33.88','B')>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城市-Aab33.33gpANaN33.88211.871城市-Aab33.335s城市-C211.8633.92A2城市-BabBpsE211.87

NaN211.863城市-Bab33.899g城市-C211.8733.92A4城市-Cab33.92agE211.8533.33NaN5城市-Cab33.92apA211.8533.88211.87pandas模块数据清洗607.数据替换>>>df1=df1.str.replace

('33.92','Y')#DataFrame不可用.strTraceback(mostrecentcalllast):……AttributeError:'DataFrame'objecthasnoattribu

te'str'>>>df1[['编码','suzhilie2']]=df1[['编码','suzhilie2']].str.replace('33.92','Y')#原因同上Traceback(mostrecentcalllast):……AttributeError:'DataFrame'obje

cthasnoattribute'str'pandas模块数据清洗618.更改数据格式更改数据格式使用的函数是astype()，比如贷款金额通常为整数，因此数据格式改为int64。如果是利息字段，由于会有

小数，因此通常设置为float64。>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城市-AabY.YgpANaN33.88211.871城市-AabY.Y5s城市-C211.8633.92A2城市-Bab

BpsE211.87NaN211.863城市-BabY.899g城市-C211.8733.92A4城市-CabY.92agE211.8533.33NaN5城市-CabY.92apA211.8533.88211.87>>>df1.info()<class'pandas.core.frame.D

ataFrame'>Int64Index:6entries,0to5Datacolumns(total6columns):省份6non-nullobject编码6non-nullobject城市6non-nullobjectsuzhilie15non-nullflo

at64suzhilie25non-nullfloat64suzhilie35non-nullobjectdtypes:float64(2),object(4)memoryusage:336.0+bytes#suzhilie2列有空

值NaN，不能更改数据格式>>>df1['suzhilie2']=df1['suzhilie2'].astype(np.int64)Traceback(mostrecentcalllast):……ValueError:Cannotconvertnon-finitevalues(NAorin

f)tointegerpandas模块数据清洗628.更改数据格式#用该列均值填充>>>df1['suzhilie2']=df1['suzhilie2'].fillna(df1['suzhilie2'].mean())>>>

df1省份编码城市suzhilie1suzhilie2suzhilie30城市-AabY.YgpANaN33.880211.871城市-AabY.Y5s城市-C211.8633.920A2城市-BabBpsE211.8733.786211.863城市-BabY.899

g城市-C211.8733.920A4城市-CabY.92agE211.8533.330NaN5城市-CabY.92apA211.8533.880211.87#suzhilie2列数据格式改为np.int64>>>df1['suzhilie2']=df1[

'suzhilie2'].astype(np.int64)>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城市-AabY.YgpANaN33211.871城市-AabY.Y5

s城市-C211.8633A2城市-BabBpsE211.8733211.863城市-BabY.899g城市-C211.8733A4城市-CabY.92agE211.8533NaN5城市-CabY.92apA211.8533211.87>>>df1.info()

<class'pandas.core.frame.DataFrame'>Int64Index:6entries,0to5Datacolumns(total6columns):省份6non-nullobject编码6non-nullobject城市6non-nullobjects

uzhilie15non-nullfloat64suzhilie26non-nullint64suzhilie35non-nullobjectdtypes:float64(1),int64(1),object(4)memoryusage:336

.0+bytespandas模块数据清洗638.更改数据格式#suzhilie2列数据格式改为np.float64>>>df1['suzhilie2']=df1['suzhilie2'].astype(np.float64)>>>df1省份编码城市suz

hilie1suzhilie2suzhilie30城市-Aab33.33gpANaN33.0211.871城市-Aab33.335s城市-C211.8633.0A2城市-BabBpsE211.8733.0211.8

63城市-Bab33.899g城市-C211.8733.0A4城市-Cab33.92agE211.8533.0NaN5城市-Cab33.92apA211.8533.0211.87>>>df1.info()<

class'pandas.core.frame.DataFrame'>RangeIndex:6entries,0to5Datacolumns(total6columns):省份6non-nullobject编码6non-nullobject城市6non-nullobjectsuzhilie15

non-nullfloat64suzhilie26non-nullfloat64suzhilie35non-nullobjectdtypes:float64(2),object(4)memoryusage:368.0+bytespandas模块数

据清洗648.更改数据格式pandas中使用to_datatime()函数进行日期格式化处理，to_datetime()方法可以解析多种不同的日期表示形式。>>>date=['2017-6-26','2017-6-27']>>>pd.to_da

tetime(date)DatetimeIndex(['2017-06-26','2017-06-27'],dtype='datetime64[ns]',freq=None)>>>dates=['2017-

06-20','2017-06-21','2017-06-22','2017-06-23','2017-06-24','2017-06-25','2017-06-26','2017-06-27']>>>s_date=pd.Se

ries(dates)>>>s_date#数据类型为object02017-06-2012017-06-2122017-06-2232017-06-2342017-06-2452017-06-2562017-06-2672017-06-27dty

pe:object>>>f_date=pd.to_datetime(s,format="%Y-%m-%d")>>>f_date#格式化后，类型变为datetime64[ns]02017-06-2012017-06-2122017-06-2232017-06

-2342017-06-2452017-06-2562017-06-2672017-06-27dtype:datetime64[ns]pandas模块数据清洗659.重命名列名可对列名称赋值，实现原地修改；也可用rename()实现浅复制，或用

inplace=True深复制。>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城市-AabY.YgpANaN33211.871城市-AabY.Y5s城市-C211.8633A2城市-BabBpsE211.8733211.863城市-BabY.899g城市

-C211.8733A4城市-CabY.92agE211.8533NaN5城市-CabY.92apA211.8533211.87>>>df1.columns#当前的列名称Index(['省份','编码','城市','suzhilie1','suzhilie2','suz

hilie3'],dtype='object')#重命名列名称columns为0、1、2、3、4、5，原地修改>>>df1.columns=[0,1,2,3,4,5]>>>df10123450城市-AabY.YgpAN

aN33211.871城市-AabY.Y5s城市-C211.8633A2城市-BabBpsE211.8733211.863城市-BabY.899g城市-C211.8733A4城市-CabY.92agE211.8533NaN5城市-CabY.92apA211.8533211.87#重命名c

olumns，原地修改>>>df1.columns=['省份','编码','城市','suzhilie1','suzhilie2','suzhilie3']>>>df1省份编码城市suzhilie1suzhilie2suzhilie30城

市-AabY.YgpANaN33211.871城市-AabY.Y5s城市-C211.8633A2城市-BabBpsE211.8733211.863城市-BabY.899g城市-C211.8733A4城市-CabY.92agE211.8533NaN5城市-CabY

.92apA211.8533211.87pandas模块数据清洗669.重命名列名#非原地>>>df1.rename(columns={'省份':0,'编码':1,'城市':2,'suzhilie1':3,'suzhilie2':4,'suzhilie3':5})0123450城

市-AabY.YgpANaN33211.871城市-AabY.Y5s城市-C211.8633A2城市-BabBpsE211.8733211.863城市-BabY.899g城市-C211.8733A4城

市-CabY.92agE211.8533NaN5城市-CabY.92apA211.8533211.87>>>df1#非原地修改，df1的columns未变省份编码城市suzhilie1suzhilie2suzhilie30城市-AabY.YgpANaN33211.871城市-AabY

.Y5s城市-C211.8633A2城市-BabBpsE211.8733211.863城市-BabY.899g城市-C211.8733A4城市-CabY.92agE211.8533NaN5城市-CabY.92apA211.8533211.87#rename()原地修改，

可用inplace=True>>>df1.rename(columns={'省份':0,'编码':1,'城市':2,'suzhilie1':3,'suzhilie2':4,'suzhilie3':5},inplace

=True)>>>df10123450城市-AabY.YgpANaN33211.871城市-AabY.Y5s城市-C211.8633A2城市-BabBpsE211.8733211.863城市-BabY.899g城市-C211.8733A4城市-Cab

Y.92agE211.8533NaN5城市-CabY.92apA211.8533211.87>>>type(df1.columns)<class'pandas.core.indexes.numeric.Int64Ind

ex'>>>>type(df1.index)<class'pandas.core.indexes.range.RangeIndex'>>>>df1.columnsInt64Index([0,1,2,3,4,5],dtype='int64')pandas模块数据预处理671.数据表合并在Pyt

hon中，panda.merge()方法可根据一个或多个键将不同DataFrame类型的数据按行连接起来；pandas.concat()方法可以沿着一条轴将多个对象堆叠到一起。⚫使用merge()方法进行合并使用merge()方法进行合并，

可以根据一个或多个键将不同DataFrame类型的数据按行连接起来。merge()方法的格式：merge(left,right,how='inner',on=None,left_on=None,right_on=None,left_index=False,right_ind

ex=False,sort=True,suffixes=('_x','_y'),copy=True,indicator=False)left与right：两个不同的DataFrame类型数据。how：指合并（连接）的方式，有inner（内连接），left（左外连接），right

（右外连接），outer（全外连接），默认为inner。on:指用于连接的列索引名称。必须存在在左右两个DataFrame对象中，如果没有指定且其它参数也未指定，则以两个DataFrame的重叠列名做为连接键。left_on：左则DataFrame中用作连接键的列

名。当两个DataFrame对象中没有相同列名，但有含义相同的列时，就可以使用这个参数。right_on：与left_on配合使用，右则DataFrame对象中用作连接键的列名。left_index：使用左则DataFrame对象中的行索引作为连接键。right

_index：使用右则DataFrame对象中的行索引作为连接键。sort：默认为True，将合并的数据进行排序。在大多数情况下设置为False可以提高性能。suffixes：字符串值组成的元组，用于指定当左右Da

taFrame对象中存在相同列名时，在列名后面附加的后缀名称，默认为('_x','_y')copy：默认为True，总是将数据复制到数据结构中；大多数情况下设置为False可以提高性能。pandas模块数据预处理681

.数据表合并>>>df1=pd.DataFrame({'id':['1001','1002','1003'],'name':['mily','jake','merry']})>>>df1idname01001mily11002jak

e21003merry>>>df2=pd.DataFrame({'id':['1001','1002','1004'],'score':[82,95,77]})>>>df2idscore01001821100295

2100477>>>df3=pd.merge(df1,df2)#默认以重叠的列名当做连接键>>>df3idnamescore01001mily8211002jake95#当两个DataFrame对象中列名都不相同，需要用left_on

和right_on进行设置>>>df22=pd.DataFrame({'sid':['1001','1002','1004'],'score':[82,95,77]})#df1中的id和df22中的sid作为连接键>>>df33=pd.

merge(df1,df22,left_on='id',right_on='sid')>>>df33idnamescoresid01001mily82100111002jake951002#左连接，保留左边df1中所有行，如果有列中没有数据则以NaN填充>>>pd.merge(

df1,df2,how='left')idnamescore01001mily8211002jake9521003merryNaNpandas模块数据预处理691.数据表合并>>>pd.merge(df1,df2,how='outer')#外连接，相当于df1,

df2并集idnamescore01001mily8211002jake9521003merryNaN31004NaN77>>>pd.merge(df1,df2,how='inner')#内连接，相当于df1,df2交集idna

mescore01001mily8211002jake95⚫使用concat()方法进行拼接如果仅想进行简单的“拼接”而不是合并，要使用concat()方法。concat()方法可以指定按某个轴进行连接，也

可以指定连接的方式（outer，inner两种）。concat()方法的格式：concat(objs,axis=0,join=‘outer’,join_axes=None,ignore_index=False,keys=None,

levels=None,names=None,verify_integrity=False,copy=True）objs：参与连接的对象，唯一必须给定的参数。axis：指明连接的轴向，0是纵轴，1是横轴，默认是0。join：“inner”（交集），“outer”（并集），默认是“outer”。

>>>df1idname01001mily11002jake21003merry>>>df2idscore010018211002952100477pandas模块数据预处理701.数据表合并#axis=0是纵轴拼接，索引也直接拼接>>>df3=pd.concat([

df1,df2],axis=0，sort=True)idnamescore01001milyNaN11002jakeNaN21003merryNaN01001NaN8211002NaN9521004NaN77>>>df4=pd.concat([df1,df2],axis=1)#axis=1是横轴

拼接idnameidscore01001mily10018211002jake10029521003merry100477在横向连接中，加上join参数的属性，如果为“inner”得到的是两表对象的交集，如果是“outer”，得到的是两个表对象的并集。这里

需要对照下述的示例进行理解。>>>pd.concat([df1,df2],axis=0,join='outer')idnamescore01001milyNaN11002jakeNaN21003merryNaN01001NaN82.011002NaN95.0210

04NaN77.0>>>pd.concat([df1,df2],axis=0,join='inner')id010011100221003010011100221004pandas模块数据预处理712.设置索引列p

andas有三个方法可以重新设置索引。①reset_index()方法，使索引按0,1,2,3，……自然数顺序递增。②set_index()方法，将dataframe其中某列作为索引。③reindex()方法，设置新索引。上述方法有两个重要参数：

inplace参数如果设置为True就不会返回一个新的DataFrame，而是直接修改该DataFrame；drop参数如果设置为True，就会移掉该列的数据。>>>df1=pd.DataFrame({'id':['1001','1002','1003'],'name':['mily','

jake','merry']})>>>df1idname01001mily11002jake21003merry>>>df2=pd.DataFrame({'id':['1001','1002','100

4'],'score':[82,95,77]})>>>df2idscore010018211002952100477>>>df3=pd.concat([df1,df2],axis=0)#axis=0是纵轴拼接，索引也直接拼接idnamesco

re01001milyNaN11002jakeNaN21003merryNaN01001NaN8211002NaN9521004NaN77pandas模块数据预处理722.设置索引列#reset_index()设置索引，原行索引作为一列保留，列名为index>

>>df3.reset_index()indexidnamescore001001milyNaN111002jakeNaN221003merryNaN301001NaN82411002NaN95521

004NaN77>>>df3#重新索引，inplace默认为False，所以df3保持原状idnamescore01001milyNaN11002jakeNaN21003merryNaN01001NaN

82.011002NaN95.021004NaN77.0>>>df3.reset_index(drop=True)#drop=True，删除原索引列idnamescore01001milyNaN11002jakeNaN21

003merryNaN31001NaN82.041002NaN95.051004NaN77.0pandas模块数据预处理732.设置索引列#drop为True，就会移出该列的数据，设置“id”列为新索引>>>df4=df3.set_index('id

',inplace=False,drop=True)>>>df4namescoreid1001milyNaN1002jakeNaN1003merryNaN1001NaN821002NaN951004NaN77>>>df4.indexIndex(['100

1','1002','1003','1001','1002','1004'],dtype='object',name='id')>>>df4.valuesarray([['mily',nan],['jake',nan],['mer

ry',nan],[nan,82.0],[nan,95.0],[nan,77.0]],dtype=object)#drop为False，就不移掉该列的数据>>>df3.set_index('id',inplace

=False,drop=False)idnamescoreid10011001milyNaN10021002jakeNaN10031003merryNaN10011001NaN8210021002NaN9510041004NaN77pandas模块数据预处理742

.设置索引列reindex()方法可实现重排序索引和指定索引，reindex()方法创建一个适应新索引的新对象，原对象不变。如果某个索引值当前不存在，就会引入缺失值NaN；reindex()方法可以通过fill_value参数填

充默认值，也可以通过method参数设置填充方法。reindex()方法参数method取值ffill或pad，可实现前向填充(或搬运)值，取值bfill或backfill后向填充(或搬运)值。reindex()方法也可以通过colu

mns参数对列进行重索引。>>>df=pd.DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['A','B','C'])>>>dfABCa012c345d678#索引值不存在，引入缺失值NaN，增加“

D”列，值为NaN>>>df.reindex(index=['a','b','c','d'],columns=list(df.columns)+['D'])ABCDa012NaNbNaNNaNNaNNaNc345NaNd678NaN>>>

df#创建一个适应新索引的新对象，原对象不变ABCa012c345d678#填充默认值>>>df.reindex(index=['a','b','c','d'],columns=list(df.columns)+['D'],fil

l_value=0)ABCDa0120b0000c3450d6780pandas模块数据预处理752.设置索引列>>>df#创建一个适应新索引的新对象，原对象不变ABCa012c345d678>>>df.reindex(index=['a','b','c','d'],columns=lis

t(df.columns)+['D'],method='ffill')#前向填充ABCDa0122b0122c3455d6788>>>df.reindex(index=['a','b','c','d'],colum

ns=list(df.columns)+['D'],method='pad')#同上ABCDa0122b0122c3455d6788>>>df.reindex(index=['a','b','c','d'],columns=list(d

f.columns)+['D'],method='bfill')#后向填充ABCDa012NaNb345NaNc345NaNd678NaN>>>df.reindex(index=['a','b','c','d'],columns=list(df.co

lumns)+['D'],method='backfill')#同上ABCDa012NaNb345NaNc345NaNd678NaNpandas模块数据预处理763.按照索引列排序>>>df3idnamesco

re01001milyNaN11002jakeNaN21003merryNaN01001NaN8211002NaN9521004NaN77>>>df3.sort_index()#按索引排序idnamescore01001milyNaN01001NaN8211002jakeNaN11002NaN95

21003merryNaN21004NaN77>>>df4namescoreid1001milyNaN1002jakeNaN1003merryNaN1001NaN821002NaN951004NaN77>>>df4.sort_ind

ex()#按索引排序namescoreid1001milyNaN1001NaN821002jakeNaN1002NaN951003merryNaN1004NaN77pandas模块数据预处理774.按照特定列的值排序>>>df3idnamescore01001milyNaN1

1002jakeNaN21003merryNaN01001NaN8211002NaN9521004NaN77>>>df3.sort_values(by=['score'])#按score列排序idnamescore21004NaN77.001001NaN82.01

1002NaN95.001001milyNaN11002jakeNaN21003merryNaNpandas模块数据预处理785.根据条件填充列#如price列的值>3000，group列填high，否则填low>>>df=

pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006],"date":pd.date_range('20180101',periods=6),"city":['BeiJing','ShangHai','GuangZhou','ShenZhen',

'NanJing','ChangZhou'],"age":[-18,20,28,36,36,152],"category":['2018-A','2018-B','2018-C','2018-D','2018-E','2

018-F'],"price":[1200,2500,5500,5500,4300,6200]},columns=['id','date','city','age','category','price'])>>>dfiddatecityagecategoryprice01001201

8-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B2500210032018-01-03GuangZhou282018-C5500310042018

-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4300510062018-01-06ChangZhou1522018-F6200#增加一

列group，并填充high或low>>>df['group']=np.where(df['price']>3000,'high','low')>>>dfiddatecityagecategorypricegroup010012018-01

-01BeiJing-182018-A1200low110022018-01-02ShangHai202018-B2500low210032018-01-03GuangZhou282018-C5500high310042018-01-04ShenZhen362

018-D5500high410052018-01-05NanJing362018-E4300high510062018-01-06ChangZhou1522018-F6200highpandas模块数据预处理796.对符合条件的数据进行分组

标记#注意此处NanJing前有1个空格>>>df.loc[(df['city']=='NanJing')&(df['price']>=4000),'sign']=1>>>dfiddatecityagecateg

orypricegroupsign010012018-01-01BeiJing-182018-A1200lowNaN110022018-01-02ShangHai202018-B2500lowNaN210032018-01-03G

uangZhou282018-C5500highNaN310042018-01-04ShenZhen362018-D5500highNaN410052018-01-05NanJing362018-E4300hig

h1.0510062018-01-06ChangZhou1522018-F6200highNaN7.分列（拆分列）#对category列的值分列，并创建数据表，索引值为df.index，列名称为category和size>>

>df_split=pd.DataFrame((x.split('-')forxindf['category']),index=df.index,columns=['category','size'])categorysize020

18A12018B22018C32018D42018E52018F#合并数据>>>df=pd.merge(df,df_split,right_index=True,left_index=True)>>>dfiddatecityagecateg

ory_xpricegroupsigncategory_ysize010012018-01-01BeiJing-182018-A1200lowNaN2018A110022018-01-02ShangH

ai202018-B2500lowNaN2018B210032018-01-03GuangZhou282018-C5500highNaN2018C310042018-01-04ShenZhen362018-D5500highNaN2018D4100520

18-01-05NanJing362018-E4300high1.02018E510062018-01-06ChangZhou1522018-F6200highNaN2018Fpandas模块数据提取80数据提取主要用到的三个函数：loc()、iloc()和ix()函数，

loc()函数按标签值进行提取，iloc按索引位置进行提取，ix可以同时按标签和索引位置进行提取。>>>df=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006],"date":pd.date_range('201

80101',periods=6),"city":['BeiJing','ShangHai','GuangZhou','ShenZhen','NanJing','ChangZhou'],"age":[

-18,20,28,36,36,152],"category":['2018-A','2018-B','2018-C','2018-D','2018-E','2018-F'],"price":[1200,2500,5500,5500,4300

,6200]},columns=['id','date','city','age','category','price'])>>>dfiddatecityagecategoryprice010012018-01-01BeiJing

-182018-A1200110022018-01-02ShangHai202018-B2500210032018-01-03GuangZhou282018-C5500310042018-01-04ShenZhen362018-D55

00410052018-01-05NanJing362018-E4300510062018-01-06ChangZhou1522018-F62001.提取单行、单列数值>>>df.loc[3]#按行索引的标签3提

取单行数值id1004date2018-01-0400:00:00cityShenZhenage36category2018-Dprice5500Name:3,dtype:object>>>df.loc[3:4]#冒号前后的数字是行索引的标签名称iddatecityagecategory

price310042018-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4300pandas模块数据提取81#冒号前后的数字是数据所在的索引位置，从

3行开始到4行，左闭右开#注意与df.loc[3:4]进行比较>>>df.iloc[3:4]iddatecityagecategoryprice310042018-01-04ShenZhen362018-D550

0>>>df['id']#提取单列数值010011100221003310044100551006Name:id,dtype:int64>>>df.loc[:,['id']]#取所有行，列标签为id的列

id010011100221003310044100551006>>>df.iloc[:,[0]]#取所有行，数据所在的位置为0列id010011100221003310044100551006>>>df.ix[:,['id']]id0100111002

21003310044100551006>>>df.ix[:,[0]]id010011100221003310044100551006pandas模块数据提取822.提取行、列区域数值#3到5行，0到3列

>>>df.iloc[3:5,0:3]iddatecity310042018-01-04ShenZhen410052018-01-05NanJing>>>df.iloc[:,0:3]iddatecity010012018-01-01BeiJ

ing110022018-01-02ShangHai210032018-01-03GuangZhou310042018-01-04ShenZhen410052018-01-05NanJing510062018-01-06ChangZhou>>>df

[['id','age']]#取所有行，取'id'列和'age'列idage01001-18110022021003283100436410053651006152>>>df.loc[:,'id':'age']#取所有行，列标签取'id'列到'age'列iddatec

ityage010012018-01-01BeiJing-18110022018-01-02ShangHai20210032018-01-03GuangZhou28310042018-01-04ShenZh

en36410052018-01-05NanJing36510062018-01-06ChangZhou152>>>df.iloc[:,0:3]#取所有行，列数据位置，取0列到3列，左闭右开iddatecity010012018-01-01BeiJing110022018

-01-02ShangHai210032018-01-03GuangZhou310042018-01-04ShenZhen410052018-01-05NanJing510062018-01-06ChangZhou>>>df.

ix[:,'id':'age']#取所有行，列标签名称，取'id'列到'age'列iddatecityage010012018-01-01BeiJing-18110022018-01-02ShangHai20210032018-01-03GuangZho

u28310042018-01-04ShenZhen36410052018-01-05NanJing36510062018-01-06ChangZhou152>>>df.ix[:,0:3]#取所有行，列数据位置，取0列到3列，左闭右开iddatec

ity010012018-01-01BeiJing110022018-01-02ShangHai210032018-01-03GuangZhou310042018-01-04ShenZhen410052018-01-05NanJing510062018-01-06ChangZhoupandas

模块数据提取833.提取非连续行列数据>>>df.iloc[[0,2,5],[4,5]]#提取第0、2、5行，4、5列categoryprice02018-A120022018-C550052018-F62004.按条件提取数

据#提取date列日期数据小于等于2018-01-03的行>>>df[df['date']<='2018-01-03']iddatecityagecategoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai2

02018-B2500210032018-01-03GuangZhou282018-C5500>>>df.loc[df['city'].isin(['ShenZhen','ChangZhou'])]iddatecityagecategoryprice310

042018-01-04ShenZhen362018-D5500510062018-01-06ChangZhou1522018-F62005.使用ix按索引标签和位置混合提取数据>>>df.ix[:3,'id':'age']#逗号前的数字是行数据所在的位置，逗

号后是列索引的标签名称iddatecityage010012018-01-01BeiJing-18110022018-01-02ShangHai20210032018-01-03GuangZhou283100420

18-01-04ShenZhen36pandas模块数据提取846.数据包含判断#city列中是否包含ShangHai，包含为True，不包含为False，区分大小写>>>df['city'].isin(['shang

hai'])0False1False2False3False4False5FalseName:city,dtype:bool7.提取列的部分字符如提取category列的前三个字符，需要使用字符串处理方法。>>>df.category#取df的category列，生

成Series02018-A12018-B22018-C32018-D42018-E52018-FName:category,dtype:object>>>type(df.category)#df的category列是Series类型<class'pa

ndas.core.series.Series'>>>>df.category.str#df的category列的String方法<pandas.core.strings.StringMethodsobjectat0x7efc46dd9e50>>

>>type(df.category.str)<class'pandas.core.strings.StringMethods'>>>>df.category.str()#无此用法Traceback(mostrecentcall

last):TypeError:'StringMethods'objectisnotcallable>>>df.category.str[:3]#提取category列每个元素的前3个字符02011201

2201320142015201Name:category,dtype:object>>>type(df.category.str[:3])<class'pandas.core.series.Series'>#提取category列每个元素前三个字符，并生

成数据表>>>pd.DataFrame(df.category.str[:3])category020112012201320142015201pandas模块数据筛选85数据筛选可使用与、或、非三个条件，并配合大于、小于、等于、不等于对数据进行

筛选，并进行计数与求和。1.使用“与”进行筛选>>>dfiddatecityagecategoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B25

00210032018-01-03GuangZhou282018-C5500310042018-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4

300510062018-01-06ChangZhou1522018-F6200#通过str.strip()转换去除首尾的空格>>>df.loc[(df['age']>25)&(df['city'].str.strip()=='She

nZhen'),['id','city','age','category','gender']]idcityagecategorygender31004ShenZhen362018-DNaN2.使用“或”进行筛选

>>>df.loc[(df['age']>25)|(df['city'].str.strip()=='ShenZhen'),['id','city','age','category','gender']].sort_values(by='age')idc

ityagecategorygender21003GuangZhou282018-CNaN31004ShenZhen362018-DNaN41005NanJing362018-ENaN51006Cha

ngZhou1522018-FNaNpandas模块数据筛选863.使用“非”条件进行筛选>>>df.loc[(df['city'].str.strip()!='ShenZhen'),list(df.columns)].sort_values(by='price')iddatecityageca

tegoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B2500410052018-01-05NanJing362018-E43002100320

18-01-03GuangZhou282018-C5500510062018-01-06ChangZhou1522018-F62004.使用query()函数进行筛选#query()只支持string形式的值>>>df.query('age==[18,2

0,36]')iddatecityagecategoryprice110022018-01-02ShangHai202018-B2500310042018-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4300p

andas模块数据汇总87数据汇总主要有groupby()和pivote_table()函数，groupy()主要实现按列分组统计，pivote_table()主要实现二维的分组统计，就是EXCEL的数据透视

表功能。>>>dfiddatecityagecategoryprice010012018-01-01BeiJing-182018-A1200110022018-01-02ShangHai202018-B2500210032018-01-03Gua

ngZhou282018-C5500310042018-01-04ShenZhen362018-D5500410052018-01-05NanJing362018-E4300510062018-01-06Ch

angZhou1522018-F62001.对所有的列计数汇总>>>df.groupby('city').count()#按照city列对所有列进行计数汇总iddateagecategorypricecityShangHai11111BeiJing11111ChangZhou11

111GuangZhou11111NanJing11111ShenZhen11111>>>df.groupby('age').count()#按照age列对所有列进行计数汇总iddatecitycategorypriceage-18111

1120111112811111362222215211111pandas模块数据汇总882.对单个字段进行分组汇总>>>df.groupby('city')['age'].count()#按city对age字段进行计数cityShangHai1BeiJing1ChangZhou1

GuangZhou1NanJing1ShenZhen1Name:age,dtype:int64>>>df.groupby('age')['price'].sum()#按age进行分组，对price求和age

-1812002025002855003698001526200Name:price,dtype:int643.对两个字段进行分组汇总>>>df.groupby(['city','age'])['id'].count()#汇总不同城市不

同年龄的人数cityageShangHai201BeiJing-181ChangZhou1521GuangZhou281NanJing361ShenZhen361Name:id,dtype:int64pandas模块数据汇总894.对单个字段分组，进行多种汇总>>>d

f.groupby('city')['price'].agg([len,np.sum,np.mean])lensummeancityShangHai125002500BeiJing112001200ChangZhou162006200GuangZhou1

55005500NanJing143004300ShenZhen1550055005.多维度分组汇总>>>df=pd.DataFrame({'key1':['a','b','a','b','a','b','a','a'],'key2':['one',

'one','two','three','two','two','one','three'],'data1':np.random.randn(8),'data2':np.random.randn(8)})>>>dfdata1data2key1key200.8729430.

478501aone1-0.4283070.111715bone2-1.256894-0.732271atwo30.2128782.051143bthree4-1.9225912.345911atwo50.877699-0.454723btwo61.5902061.883469aone70

.583905-0.702138athreepandas模块数据统计90数据统计主要有数据采样、描述性统计、计算标准差、协方差和相关系数。1.数据采样随机采样法就是调查对象总体中每个部分都有同等被抽中的可能，是一种完全依照机会均等的原则进行的采样调查，被称为是一种“等概率”。随机采样有简单随机采样

、等距采样、类型采样和整群采样四种基本形式。非随机抽样是指抽样时不是遵循随机原则，而是按照研究人员的主观经验或其它条件来抽取样本的一种抽样方法。Python中简单随机抽样的方法有编写代码和利用pandas库

或numpy库实现。>>>df.sample(n=3)#简单数据采样，随机采集3个iddatecityagecategoryprice210032018-01-03GuangZhou282018-C5500310042018-01-04ShenZhen362018-

D5500110022018-01-02ShangHai202018-B2500>>>df.sample(n=3)#简单数据采样，不同次采样值不同iddatecityagecategoryprice510062018-01-

06ChangZhou1522018-F6200010012018-01-01BeiJing-182018-A1200410052018-01-05NanJing362018-E4300>>>weights=[0,0,0,0.2,0,0.8]>>>df.sample(n=2,weights=

weights)#设置采样权重iddatecityagecategoryprice310042018-01-04ShenZhen362018-D5500510062018-01-06ChangZhou1522018-F6200>>>df.sample(n=3,repl

ace=False)#采样后不放回不会抽到重复iddatecityagecategoryprice410052018-01-05NanJing362018-E4300110022018-01-02ShangHai20

2018-B2500010012018-01-01BeiJing-182018-A1200pandas模块数据统计912.数据表描述性统计DataFrame的描述性统计用discribe()函数实现。对于数值数据，结果的索引将包括计数、平均值、标准差、最小值

、最大值以及较低的百分位数和50百分位数。默认情况下，较低的百分位数为25，较高的百分位数为75，50百分位数与中位数相同。>>>df.describe()#显示计数、均值、标准差、分位数、最大最小值等idagepricecount6.0000006.0000006.000000mean10

03.50000042.3333334200.000000std1.87082957.3608461963.670033min1001.000000-18.0000001200.00000025%1002.25000022.0000002950.00000050%1003.50000032.000

0004900.00000075%1004.75000036.0000005500.000000max1006.000000152.0000006200.000000>>>df.describe().round(2).T#round函数设置显

示小数位2位，T表示转置countmeanstdmin25%50%75%maxid6.01003.501.871001.01002.251003.51004.751006.0age6.042.3357.36-18.

022.0032.036.00152.0price6.04200.001963.671200.02950.004900.05500.006200.0pandas模块数据统计923.计算列的标准差标准差又称均方差，在概率统计中常用作统计分布程度。标准差是总体各单

位标准值与其平均数差的平方的算术平均数的平方根，反映组内个体间的离散程度。标准差是一组数据平均值分散程度的一种度量。一个较大的标准差，代表大部分数值和其平均值之间差异较大；一个较小的标准差，代表这些数值较接近

平均值。如两组数的集合{0,3,10,15}和{5,6,8,9}其平均值都是7，但第二个集合具有较小的标准差。如果测量平均值与预测值相差太远（同时与标准差数值做比较），则认为测量值与预测值互相矛盾。因为如果测量值都落在一定数值范围之外，可以合理推论预测值是否正确。pandas中计

算标准差的方法是std()。>>>df['price'].std()1963.67003338137244.计算协方差协方差在概率论和统计学中用于衡量两个变量的总体误差，表示两个变量总体误差的期望。而方差是协方差的一种

特殊情况，即当两个变量是相同的情况。如果两个变量的变化趋势一致，即如果其中一个大于自身的期望值时另外一个也大于自身的期望值，那么两个变量之间的协方差就是正值；如果两个变量的变化趋势相反，即其中一个变量大于自身的期望值时另外一个却小于自身的期望

值，那么两个变量之间的协方差就是负值。pandas中计算协方差的方法是cov()。>>>df['price'].cov(df['age'])#计算两个字段间的协方差82160.0>>>df.cov()#数据表中所有字段间的协方差idagepriceid3.590.600000304

0.0age90.63290.26666782160.0price3040.082160.0000003856000.0pandas模块数据统计935.相关性分析相关性分析是指对两个或多个具备相关性的变量元素进行分析，从而衡量两个变量因素的密切

程度。相关性的元素之间需要存在一定的联系或者概率才可以进行相关性分析。相关分析是研究两个或两个以上处于同等地位的随机变量间的相关关系的统计分析方法。如在一段时期内出生率随经济水平上升而上升，这说明两指标间是正相关关系；而在另一时期，随着经济水平进一步发展，出现出生率

下降的现象，两指标间就是负相关关系。相关分析与回归分析之间的区别是回归分析侧重于研究随机变量间的依赖关系，以便用一个变量去预测另一个变量；相关分析侧重于发现随机变量间的种种相关特性。pandas中计算相关性的方法是corr()。#两个字段的相关性分析#相关系数在-1到1之间，接近1为正相关，接

近-1为负相关，0为不相关>>>df['price'].corr(df['age'])0.72941782001934674>>>df.corr()#数据表的相关性分析idagepriceid1.0000000.84426

50.827506age0.8442651.0000000.729418price0.8275060.7294181.000000pandas模块综合应用示例94【例9-1】给定以下数据，请依次完成操作。idnamesexageadressMjobO

job10001LYF18Californiaat_homehealth10002CEM20Texasservicesteacher10003ZSM36Floridaat_hometeacher10004LSF47Californiaserviceshealth10005WUF13Texasstu

dentother10006ZLF25Floridaat_hometeacher10007SQM32Californiateacherhealth10008ZBF45Floridahealthhealth10009WJM13Texass

tudentother10010ZSM16Texasstudentat_home（1）导入相应数据分析模块>>>importnumpyasnp>>>importpandasaspd>>>importrandom（2）根据给定的原始数据集创建一个DataFrame类型对象df>>>d

f=pd.DataFrame({'id':['10001','10002','10003','10004','10005','10006','10007','10008','10009','10010'],'name':['LY','CE','ZS','LS','WU','ZL','SQ','

ZB','WJ','ZS'],'sex':['F','M','M','F','F','F','M','F','M','M'],'age':[18,20,36,47,13,25,32,45,13,16],'adress':

['California','Texas','Florida','California','Texas','Florida','California','Florida','Texas','Texas'],'Mjob':['at_home','services','at_home','servi

ces','student','at_home','teacher','health','student','student'],'Ojob':['health','teacher','teacher','health','other','te

acher','health','health','other','at_home']},columns=['id','name','sex','age','adress','Mjob','Ojob'])pandas模块综合应用示

例95（3)查看df>>>dfidnamesexageadressMjobOjob010001LYF18Californiaat_homehealth110002CEM20Texasservicesteacher2

10003ZSM36Floridaat_hometeacher310004LSF47Californiaserviceshealth410005WUF13Texasstudentother510006ZLF25Floridaat_hometeacher610007SQM32Calif

orniateacherhealth710008ZBF45Floridahealthhealth810009WJM13Texasstudentother910010ZSM16Texasstudentat_home(4)查看df前5行>>>df.head()idnamesexage

adressMjobOjob010001LYF18Californiaat_homehealth110002CEM20Texasservicesteacher210003ZSM36Floridaat_hometeacher310004LSF47Ca

liforniaserviceshealth510005WUF13Texasstudentother(5)查看行和列的索引值>>>df.columnsIndex(['id','name','sex','age','adress','Mjob','O

job'],dtype='object')>>>df.indexRangeIndex(start=0,stop=10,step=1)(6)分别查看nam、sex列的值>>>df['name']0LY1CE2ZS3LS4

WU5ZL6SQ7ZB8WJ9ZSName:name,dtype:object>>>df[['name','sex']]namesex0LYF1CEM2ZSM3LSF4WUF5ZLF6SQM7ZBF8WJM9ZSMpandas模块综合应用示例96(7)连续切片，取行0到5行，列0到5列，左闭右开

，所有数据>>>df.iloc[:5,0:5]idnamesexageadress010001LYF18California110002CEM20Texas210003ZSM36Florida310004LSF47California410005

WUF13Texas（8）筛选出第2到4行，第1、3、5列的所有数据>>>df.iloc[2:6,[1,3,5]]nameageMjob2ZS36at_home3LS47services4WU13student5ZL25at_home（9）分别筛选出Mjob列值为"

student"和不为"student"的所有数据>>>df.loc[df["Mjob"]!="student"]idnamesexageadressMjobOjob010001LYF18Californiaat_homehealth110002CEM20Texas

servicesteacher210003ZSM36Floridaat_hometeacher310004LSF47Californiaserviceshealth510006ZLF25Floridaat_hometeacher610007SQM32Califor

niateacherhealth710008ZBF45Floridahealthhealth>>>df.loc[df["Mjob"]=="student"]idnamesexageadressMjobOjob410005WUF13Texasstuden

tother810009WJM13Texasstudentother910010ZSM16Texasstudentat_home（10）以Mjob分组，求每一种职业所有用户的平均年龄>>>df.groupby('Mjob').age.

mean()Mjobat_home26.333333health45.000000services33.500000student14.000000teacher32.000000Name:age,dtype:float64>>>df.groupby

('Mjob')['age'].mean()Mjobat_home26.333333health45.000000services33.500000student14.000000teacher32.000000Name:age,dtype

:float64（11）求每一种职业男性的占比，并排序。（作为新的一列gender_n添加到df最后一列）>>>defgender_count(x):#定义函数对性别进行标识，M用1表示，F用0表示。...ifx=='M':...return1..

.ifx=='F':...return0pandas模块综合应用示例97>>>df['gender_n']=df['sex'].apply(gender_count)#df增加一列，调用函数对性别进行标识>>>dfidnamesexageadress

MjobOjobgender_n010001LYF18Californiaat_homehealth0110002CEM20Texasservicesteacher1210003ZSM36Floridaat_homet

eacher1310004LSF47Californiaserviceshealth0410005WUF13Texasstudentother0510006ZLF25Floridaat_hometeacher06100

07SQM32Californiateacherhealth1710008ZBF45Floridahealthhealth0810009WJM13Texasstudentother1910010ZSM16Texasstudentat_home1>>>a=df.groupby('Mjob').g

ender_n.sum()/df.Mjob.value_counts()*100>>>a#各种职业男性的占比at_home33.333333health0.000000services50.000000student66.666

667teacher100.000000dtype:float64>>>a.sort_values(ascending=False)#a按照从高到低的顺序排列teacher100.000000student66.666667services50.000000at_home33.333333hea

lth0.000000dtype:float64>>>df.groupby('Mjob').gender_n.sum()#按Mjob分类，求gender_n和Mjobat_home1health0services1student2te

acher1Name:gender_n,dtype:int64>>>df.Mjob.value_counts()#求Mjob列不同值的和student3at_home3services2teacher1health1Name:Mjob,dtype:in

t64pandas模块综合应用示例98(12)获取每一种职业对应的最大和最小的用户年龄>>>df.groupby('Mjob').age.agg(['min','max'])minmaxMjobat_home1836health4545services2047student1

316teacher3232>>>df.groupby('Mjob').age<pandas.core.groupby.SeriesGroupByobjectat0x7fbc243a0e10>(13)删除最后一列gender_n>>>df.drop('gender_n',axis=1,inpl

ace=True)>>>dfidnamesexageadressMjobOjob010001LYF18Californiaat_homehealth110002CEM20Texasservicesteacher210003ZSM36Floridaat_h

ometeacher310004LSF47Californiaserviceshealth410005WUF13Texasstudentother510006ZLF25Floridaat_hometeacher610007SQM32California

teacherhealth710008ZBF45Floridahealthhealth810009WJM13Texasstudentother910010ZSM16Texasstudentat_home(14)将数据列Mjob和Ojob中所有数据实现首字母大写>>>df["Mjob"]

=df['Mjob'].map(lambdax:x.capitalize())>>>df["Ojob"]=df['Ojob'].map(lambdax:x.capitalize())>>>dfidnamesexageadressMjobOjob010

001LYF18CaliforniaAt_homeHealth110002CEM20TexasServicesTeacher210003ZSM36FloridaAt_homeTeacher310004LSF47Californ

iaServicesHealth410005WUF13TexasStudentOther510006ZLF25FloridaAt_homeTeacher610007SQM32CaliforniaTeach

erHealth710008ZBF45FloridaHealthHealth810009WJM13TexasStudentOther910010ZSM16TexasStudentAt_home(15)设定id列为行索引>>>df.set_index(["id"])namesex

ageadressMjobOjobid10001LYF18CaliforniaAt_homeHealth10002CEM20TexasServicesTeacher10003ZSM36FloridaAt_homeTeacher100

04LSF47CaliforniaServicesHealth10005WUF13TexasStudentOther10006ZLF25FloridaAt_homeTeacher10007SQM32CaliforniaTeacherHealth10

008ZBF45FloridaHealthHealth10009WJM13TexasStudentOther10010ZSM16TexasStudentAt_home项目训练：清洗和预处理8.6节爬取的doubanread.csv文件03读取8

.6节爬取的CSV文件，了解pandas读取CSV文件的方法，通过对爬取数据的处理，进一步熟悉pandas数据处理的功能，为实际应用打下良好的基础。清洗和预处理爬取的数据训练目标训练内容1.读入CSV文件

到pandas中；2.对数据进行初步的分析，了解空值，缺失值等情况；3.对数据进行处理；4.进行相关的统计。训练步骤①项目分析pandas对CSV文件可以直接进行读写。对读取的数据，首先通过浏览了解数据初步情况，再使用空值等方法进行判断与统计，确定数据的情况，然

后进行空值的处理，最后进行相关的统计。②项目实施本项目直接在交互模式下进行即可>>>importpandasaspd◆读取数据#读取CSV文件生成DataFrame类型的对象（10.1.1节讲解CSV的读写）>>>doubanread=pd.read_cs

v(‘/home/scrapy/douban/doubanread.csv’,encoding=’utf-8’)◆初步了解数据的情况>>>len(doubanread)#输出记录的条数，不同的爬取时间，爬取

的记录数也是不一样的988>>>doubanread.columns#查看各列Index(['grade','introduction','author','book_name','count'],d

type='object')通过浏览发现列有空值情况，使用isnull()进行统计查看清洗和预处理爬取的数据训练步骤②项目实施◆空值查看>>>doubanread.isnull().any(axis=0).sum()#3列有空值3>>>doubanread.isnul

l().any(axis=0)#各列空值情况，True表示有空值，False表示无空值gradeTrueintroductionTrueauthorFalsebook_nameFalsecountTrue#有空值的列是introduction、count和grade3

列>>>doubanread.isnull().all(axis=1).sum()#全部是空值行的行数量38◆空值处理#用均值填充grade列，用0填充count列，删除introduction列有空值的行>>>doubanread[‘count’]#

查看count列的信息0\n(179450人评价)\n1\n(222769人评价)\n……#用正则表达式提取评价人数>>>doubanread['count']=doubanread['count'].str.extract(r'(\d+)')>>>

doubanread[‘count’]#再次查看提取的结果01794501222769……清洗和预处理爬取的数据训练步骤②项目实施>>>doubanread['count']=doubanread['c

ount'].fillna(value=0)>>>doubanread['grade']=doubanread['grade'].fillna(value=doubanread['grade'].mean())

#填完两列之后再次查看，发现只有introduction列有空值>>>doubanread.isnull().any(axis=0)gradeFalseintroductionTrueauthorFalsebook_nameFalsecountFalse

dtype:bool#删除introduction空值的行>>>doubanread.dropna(axis=0,how='any',inplace=True)>>>len(doubanread)#再次查看行，发现只有952行了952清洗和预处理爬取的数据训练步骤②项目实施◆基本的统计>>>

doubanread['count'].astype(float).mean()7774.634453781513>>>doubanread['grade'].mean()8.3559332759472

96>>>doubanread['count'].astype(float).max()222769.0>>>doubanread['grade'].min()5.7>>>doubanread['grade'].max()9.8>>>doubanread['co

unt']=doubanread['count'].astype(float)#将类型转换为float>>>doubanread.describe()gradecountcount952.000000952.00

0000mean8.3559337774.634454std0.61651219263.972525min5.7000000.00000025%8.000000613.50000050%8.4000001975

.00000075%8.8000006004.000000max9.800000222769.000000请填写表1-1的项目训练小结训练小结清洗和预处理爬取的数据小结041.numpy是一个用Python实现的科学计算包，专为进行严格的数值处理而产生，尤其是对大型多维数组和矩阵的

支持，并且有一个大型的高级数学函数库来操作这些数组。主要有ndarray和matrix两种类型的数据对象。2.数组array中很多运算都是元素级的，如+、-、*、/四则运算都针对array的每个元素进行处理，而matrix是根据

矩阵的定义进行整体处理的。3.pandas是Python的一个数据分析包，主要有Series和DataFrame两种类型的数据对象。4.pandas数据处理功能强大，主要用来完成数据清洗、提取、筛选、汇总和统计。5.pandas的

很多处理要依赖于numpy。小结106THANKS！107