《Python金融数据分析与挖掘（微课版）》全套教学课件

第1章Python基础Python基本数据类型Python基本数据结构Python基本数据结构之间的比较全套可编辑PPT课件

Python基本数据类型第1章

电子表格数据、新闻文本数据等属于常见的数据集，它们是由一个个的数值和文本组成的。单个数值和文本，即是构成数据集的基本单元。Python基本数据类型第1章

在Python中，将构成数据集的基本单元：数值和文本，定义为基本数据类型，即数值和字符串。n1=2#整型n2=1.3#浮点n3=float(2)#转换为浮点类型t=True#布尔真f=False#布尔假n4=t==1n5=f==0s1='1234's2='中国's3='''helloword!'''s4='ILikepython’

Python基本数据类型，即对单个数值和文本进行了定义。然而，真实数据集是由多个数值或多个文本组成的，其数据集形态可能是二维表（比如Excel表格），也可能是某一列（数据序列）。以某个数据序列为例，如何进行组织和存储呢？——Python基本数据结构Python基本数据结构第1章

列表元组集合字典

列表作为Python中一种数据结构，可以存放不同类型的数据，用中括号括起来进行定义。

L1=[1,2,3,4,5,6]L2=[1,2,'HE',3,5]L3=['KJ','CK','HELLO']

Python基本数据结构（列表）第1章

元组与列表类似，也是Python中一种常用数据结构，不同之处在于元组中的元素不能修改，元组采用圆括号括起来进行定义。

t1=(1,2,3,4,6)t2=(1,2,'kl')t3=('h1','h2','h3')

Python基本数据结构（元组）第1章

集合也是Python中的数据结构，是一种不重复元素的序列，用大括号括起来进行定义。

J1={1,'h',2,3,9}J2={1,'h',2,3,9,2}J3={'KR','LY','SE'}J4={'KR','LY','SE','SE'}Python基本数据结构（集合）第1章

字典是一种按键、值对定义的数据结构，其中键必须唯一，用大括号括起来进行定义。字典中的元素由键和值两部分组成，键在前值在后，键和值之间用冒号(:)来区分，元素之间用逗号隔开。键可以是数值、字符，值可以是数值、字符或者其他Python数据结构（比如列表、元组等）。

d1={1:'h',2:[1,2,'k'],3:9}d2={'a':2,'b':'ky'}d3={'q1':[90,100],'k2':'kkk'}

Python基本数据结构（字典）第1章

Python基本数据结构之间比较第1章

列表和元组，对每个元素都进行了编号，称为索引（index），从0开始依次递增，它们的编号方式是系统默认的，不可以更改。从数据的存储上来看，它们没有本质区别，但是在操作有区别，比如列表的元素可以修改，执行L2[1]=100，则原来值为2的元素，成功修改为100，而执行t2[1]=100,则报错，说明元组具有“写保护”的功能，列表则没有。而字典的编号方式则更灵活，可以进行个性化设置，比如可以用整数来编号，也可以用字符串来编号，这个编号要求具有唯一性，即“键”。集合数据结构则没有索引，仅保持了元素的唯一性，如果是集合之间运算，比如取交集、并集、差集等，建议使用这个数据结构，否则不建议使用第1章Python基础索引、切片求长度、统计成员身份确认和变量删除Python相关公有方法第1章Python公有方法是指Python中大部分的数据结构均可以通用的一种数据操作方法索引切片求长度统计成员身份确认变量删除

索引第1章索引即通过数据结构中的数据标识（下标索引或键）来访问s3='ILikepython'L1=[1,2,3,4,5,6]t2=(1,2,'kl')d1={1:'h',2:[1,2,'k'],3:9}d3={'q1':[90,100],'k2':'kkk'}print(s3[0],s3[1],L1[0],t2[2],d1[3],d3['k2'])执行结果如下：I1kl9kkk注意下标从0开始。字典结构的数据标识为键。需要说明的是，集合类型数据结构，不支持索引访问。因为它没有数据标识

切片是指定索引位置，对数据实现分块访问或提取的一种数据操作方式。

下面简单介绍字符串、列表、元组的切片方法。

s2='''helloword!'''L2=[1,2,'HE',3,5]t2=(1,2,'kl')s21=s2[0:]s22=s2[0:4]s23=s2[:]s24=s2[1:6:2]L21=L2[1:3]L22=L2[2:]L23=L2[:]t21=t2[0:2]t22=t2[:]切片执行结果如下：helloword!hellhelloword!el[2,'HE']['HE',3,5][1,2,'HE',3,5](1,2)(1,2,'kl')

第1章

print(s21)print(s22)print(s23)print(s24)print(L21)print(L22)print(L23)print(t21)print(t22)0123456789100123012345678910135122340123401012

字符串的长度为字符串中所有字符的个数，其中空格也算一个字符；列表、元组、集合的长度，即为元素的个数；字典的长度为键的个数，用函数len()来实现

s3='ILikepython'L1=[1,2,3,4,5,6]t2=(1,2,'kl')J2={1,‘h’,2,3,9}

d1={1:'h',2:[1,2,'k'],3:9}k1=len(s3)k2=len(L1)k3=len(t2)k4=len(J2)k5=len(d1)

求长度第1章

统计包括求最大值、最小值、求和等，可以是列表、元组、字符串L1=[1,2,3,4,5,6]t1=(1,2,3,4,6)s2='''helloword!'''m1=max(L1)m2=max(t1)m3=min(L1)m4=sum(t1)m5=max(s2)

统计第1章

成员身份的确认，用in命令，用来判断某个元素是否属于指定的数据结构变量。

L1=[1,2,3,4,5,6]t1=(1,2,3,4,6)s2='''helloword!'''J2={1,'h',2,3,9,'SE'}z1='I'ins2z2='kj'inL1z3=2int1z4='SE'inJ2

成员身份确认第1章

程序运行过程中，可以存在大量的中间变量，这些变量一来占用空间，二来影响可读性，可以使用del命令删除不必要的中间变量。

a=[1,2,3,4];b='srt'c={1:4,2:7,3:8,4:9}dela,b执行该程序代码，删除了a、b两个变量，而变量c保留。变量删除第1章

第1章Python基础列表和元组方法字典方法字符串方法

预定义几个列表L1=[1,2,3,4,5,6]L2=[1,2,'HE',3,5]L3=['KJ','CK','HELLO']L4=[1,4,2,3,8,4,7]列表方法L=list()#产生空列表LL=[]#也可以用[]来产生空列表第1章

1.创建空列表：list()

2.添加元素：append()

L1=[1,2,3,4,5,6]L2=[1,2,'HE',3,5]L=[]L1.append('H')#在L1列表后面增加元素‘H’.print(L1)fortinL2:#利用循环,将L2中的元素，依次顺序添加到前面新建的空列表L中L.append(t)print(L)

执行结果如下：[1,2,3,4,5,6,'H'][1,2,'HE',3,5]列表方法第1章

3.扩展列表：extend()

L2=[1,2,'HE',3,5]L1=[1,2,3,4,5,6,'H']L1.extend(L2)#在前面的L1基础上，添加整个L2至其后面print(L1)执行结果如下：[1,2,3,4,5,6,'H',1,2,'HE',3,5]4.元素计数：count()print('元素2出现的次数为：',L1.count(2))执行结果如下：元素2出现的次数为：2列表方法第1章

5.返回下标：index()

L1=[1,2,3,4,5,6,'H',1,2,'HE',3,5]print('H的索引下标为：',L1.index('H'))执行结果如下：H的索引下标为：66.删除元素：remove()

L1.remove('HE')#删除HE元素print(L1)执行结果如下：[1,2,3,4,5,6,'H',1,2,3,5]列表方法第1章

7.元素排序：sort()

L4=[1,4,2,3,8,4,7]L4.sort()print(L4)执行结果如下：[1,2,3,4,4,7,8]注意，如果执行L5=L4.sort(),则L5为空的。实际上经过排序后L4的元素位置顺序已经改变了列表方法第1章

预定义两个元组T1=(1,2,2,4,5)T2=('H2',3,'KL')创建空元组：tuple()

t1=tuple()#产生空元组

t=()#产生空元组元组方法第1章

T1=(1,2,2,4,5)T2=('H2',3,'KL')2.元素计数：count()print('元素2出现的次数为：',T1.count(2))执行结果如下：

元素2出现的次数为：

23.返回下标：index()

print('KL的下标索引为：',T2.index('KL'))执行结果如下：KL的下标索引为：2元组方法第1章4.元组连接T3=T1+T2print(T3)执行结果如下：(1,2,2,4,5,'H2',3,'KL')

字符串作为基本的数据类型，也可以看作一种特殊的数据结构字符从0开始进行索引编号，包括空格特特殊字符1.创建空字符串：str(）通过str函数，可以创建空的字符串。示例代码如下：S=str()#或S=’’产生空字符串

字符串方法第1章

2.查找子串：find()用find函数查找子串出现的开始索引位置，如果没有找到则返回-1。st='helloword!‘z1=st.find('he',0,len(st))#返回包含子串的开始索引位置，否则-1z2=st.find('he',1,len(st))print(z1,z2)

执行结果为：

0-1其中find函数第一个参数为需要查找的子串，第二个参数是待查字符串指定的开始位置，第三个参数为指定待查字符串的长度。字符串方法第1章

3.替换子串：replace()st='helloword!‘stt=st.replace('or','kl')#原来的st不变print(stt)print(st)执行结果如下：hellowkld!helloword!4.字符串连接st1='joh'st2=st1+''+stprint(st2)执行结果如下：johhelloword!字符串方法第1章

5.字符串比较

通过等号或不等号“==”、“!=”来进行判断。str1='jo'str2='qb'str3='qb's1=str1!=str2s2=str2==str3print(s1,s2)执行结果如下：TrueTrue字符串方法第1章

字典方法1.创建字典：dict()通过dict函数，可以创建空字典，也可以将嵌套列表转换为典。d=dict()#产生空字典D={}#产生空字典list1=[('a','ok'),('1','lk'),('001','lk')]#嵌套元素为元组list2=[['a','ok'],['b','lk'],[3,'lk']]#嵌套元素为列表d1=dict(list1)d2=dict(list2)print('d=：',d)print('D=:',D)print('d1=:',d1)print('d2=:',d2)第1章

执行结果如下：d={}D={}d1={'a':'ok','1':'lk','001':'lk'}d2={'a':'ok','b':'lk',3:'lk'}字典方法第1章

2.获取字典值：get()print(d2.get('b'))输出结果如下：lk3.字典赋值：setdefault()通过setdefault方法，可以对预定义的空字典进行赋值。d.setdefault('a',0)D.setdefault('b',[1,2,3,4,5])print(d)print(D)执行结果如下：{'a':0}{'b':[1,2,3,4,5]}预定义d={}D={}d2={'a':'ok','b':'lk',3:'lk'}第1章Python基础条件语句循环语句函数条件语句条件判断语句，是指满足某些条件，才能做某件事情，而不满足条件时是不允许做的。Python条件语句主要有三种形式：if…if…else…if…elif…else…第1章

条件语句第1章

if…语句if条件:

执行代码块注意条件后面的冒号（英文格式输入），同时执行代码块均需要缩进并对齐。x=10importmath#导入数学函数库ifx>0:#冒号s=math.sqrt(x)#求平方根，缩进print('s=',s)#打印结果，缩进执行结果如下：s=3.1622776601683795条件语句第1章

if…else…语句if条件：

执行语句块else:

执行语句块同样需要注意冒号及缩进对齐语法。x=-10importmath#导入数学函数库ifx>0:#冒号s=math.sqrt(x)#求平方根，缩进print('s=',s)#打印结果，缩进else:s='负数不能求平方根'#提示语，缩进print('s=',s)#打印结果，缩进执行结果如下：s=负数不能求平方根条件语句第1章

if…elif…else…语句if条件:

执行语句块elif条件:

执行语句块else:

执行语句块weather='sunny'ifweather=='sunny':print("shopping")elifweather=='cloudy':print("playingfootball")else:print("donothing")执行结果如下：shopping循环语句第1章

while语句循环语句while，其使用方式如下：while条件:

执行语句块注意执行语句块中的程序全部都要缩进并对齐。一般while循环需要预定义条件变量，当满足条件的时候，循环执行语句块的内容。以求1到100的和为例t=100 s=0whilet:s=s+tt=t-1print('s=',s)执行结果如下：s=5050循环语句第1章

for循环循环语句for使用方式如下：for变量in序列:

执行语句块注意执行语句块中的程序全部需要缩进并对齐，其中序列为任意序列，可以是数组、列表、元组等。list1=list()list2=list()list3=list()forainrange(10):list1.append(a)fortin['a','b','c','d']:list2.append(t)forqin('k','j','p'):list3.append(q)print(list1)print(list2)print(list3)执行结果如下：[0,1,2,3,4,5,6,7,8,9]['a','b','c','d']['k','j','p']函数第1章

无返回值函数定义与调用无返回值函数的定义格式如下：def函数名(输入参数):

函数体注意冒号及缩进，函数体中的程序均需要缩进并对齐。#定义函数defsumt(t):s=0whilet:s=s+tt=t-1#调用函数并打印结果

s=sumt(50)print(s)执行结果如下所示：None执行结果为None，表示没有任何结果，因为该函数没有任何返回值。函数第1章

有返回值函数定义与调用有返回值的函数定义如下：def函数名称(输入参数):

函数体return返回变量

#定义函数defsumt(t):s=0whilet:s=s+tt=t-1returns

#调用函数并打印结果

s=sumt(50)print(s)执行结果如下：1275该示例程序仅仅是在上一节无返回值函数定义的基础上，增加了返回值。函数第1章

有多返回值函数定义与调用多返回值函数，可以用一个元组来存放返回结果，元组中的元素数据类型可以不相同，其定义如下：def函数名称(输入参数):

函数体return(返回变量1,返回变量2,…)#定义函数deftest(r):importmaths=math.pi*r**2c=2*math.pi*rL=(s,c)D=[s,c,L]return(s,c,L,D)#调用函数并打印结果v=test(10)s=v[0]c=v[1]L=v[2]D=v[3]print(s)print(c)print(L)print(D)执行结果如下：314.159265358979362.83185307179586(314.1592653589793,62.83185307179586)[314.1592653589793,62.83185307179586,(314.1592653589793,62.83185307179586)]第2章

科学计算包Numpy数组创建、数组尺寸与重排数组运算与数学函数数组切片、连接、存取、展平、排序与搜索Numpy简介第2章

Numpy是Python用于科学计算的基础包，也是大量Python数学和科学计算包的基础。Numpy的核心基础是ndarray（N-dimensionalarray，N维数组），即由数据类型相同的元素组成的N维数组。使用该包，需要按模块的形式导入，即：importnumpy，大多情况下是importnumpyasnp，即简称np。利用array()函数创建数组第2章。基于array()函数，可以将列表、元组、嵌套列表、嵌套元组等数据结构转化为数组d1=[1,2,3,4,0.1,7]#列表d2=(1,2,3,4,2.3)#元组d3=[[1,2,3,4],[5,6,7,8]]#嵌套列表，元素为列表d4=[(1,2,3,4),(5,6,7,8)]#嵌套列表，元素为元组d5=((1,2,3,4),(5,6,7,8))#嵌套元组importnumpyasnpd11=np.array(d1)d21=np.array(d2)d31=np.array(d3)d41=np.array(d4)d51=np.array(d5)deld1,d2,d3,d4,d5利用内置函数创建数组第2章importnumpyasnpz1=np.ones((3,3))#创建3行3列元素全为1的数组z2=np.zeros((3,4))#创建3行4列元素全为0的数组z3=np.arange(10)#创建默认初始值为0，默认步长为1，末值为9的一维数组z4=np.arange(2,10)#创建默认初始值为2，默认步长为1，末值为9的一维数组z5=np.arange(2,10,2)#创建默认初始值为2，步长为2，末值为9的一维数组数组尺寸与重排第2章d1=[1,2,3,4,0.1,7]#列表d3=[[1,2,3,4],[5,6,7,8]]#嵌套列表，元素为列表importnumpyasnpd11=np.array(d1)#将d1列表转换为一维数组，结果赋值给变量d11d31=np.array(d3)#将d3嵌套列表转换为二维数组，结果赋值给变量d31deld1,d3#删除d1,d3s11=d11.shape

#返回一维数组d11的尺寸，结果赋值给变量s11s31=d31.shape#返回二维数组d31的尺寸，结果赋值给变量s31r=np.array(range(9))#一维数组r1=r.reshape((3,3))#重排为3行3列第2章数组运算importnumpyasnpA=np.array([[1,2],[3,4]])#定义二维数组AB=np.array([[5,6],[7,8]])#定义二维数组BC1=A-B#A、B两个数组元素之间相减，结果赋给变量C1C2=A+B#A、B两个数组元素之间相加，结果赋给变量C2C3=A*B#A、B两个数组元素之间相乘，结果赋给变量C3C4=A/B#A、B两个数组元素之间相除，结果赋给变量C4C5=A/3#A数组所有元素除以3，结果赋给变量C5C6=1/A#1除以A数组所有元素，结果赋给变量C6C7=A**2#A数组所有元素取平方，结果赋给变量C7C8=np.array([1,2,3,3.1,4.5,6,7,8,9])#定义数组C8C9=(C8-min(C8))/(max(C8)-min(C8))#C8中的元素做极差化处理，结果赋给变量C9第2章数学函数D=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])#定义数组D#数学运算E1=np.sqrt(D)#数组D中所有元素取平方根，结果赋给变量E1E2=np.abs([1,-2,-100])#取绝对值E3=np.cos([1,2,3])#取cos值E4=np.sin(D)#取sin值E5=np.exp(D)#取指数函数值第2章常用组切片方法假设D为待访问或切片的数据变量，则访问或者切片的数据=D[①,②]。其中①为对D的行下标控制，②为对D的列下标控制。为了更灵活地操作数据，取所有的行或者列，可以用“：”来代替实现。同时，行控制还可以通过逻辑列表来实现。importnumpyasnpD=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])#定义数组DD12=D[1,2]#访问D中行为1，列为2的数据，注意下标是从0开始的。D1=D[:,[1,3]]#访问D中第1、3列数据D2=D[[1,3],:]#访问D中第1、3行数据Dt1=D[D[:,0]>5,:]#取D中满足第0列大于5的所有列数据，本质上行控制为逻辑列表TF=[True,False,False,True]#取D中第0、3行的所有列数据，本质上行控制为逻辑列表，取逻辑值为真的行Dt3=D[TF,:]第2章利用ix_()函数进行数组切片通过ix_()函数构造行、列下标索引器，实现数组的切片操作。importnumpyasnpD=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])#定义数组DD3=D[np.ix_([1,2],[1,3])]#提取D中行数为1、2，列数为1、3的所有元素D4=D[np.ix_(np.arange(2),[1,3])]#提取D中行数为0、1，列数为1、3的所有元素D6=D[np.ix_(D[:,1]<11,[1,2])]#提取D中第1列小于11得到的逻辑数组作为行索引，列数为1、2的所有元素D7=D[np.ix_(D[:,1]<11,[2])]#提取D中第1列小于11得到的逻辑数组作为行索引，列数为2的所有元素TF=[True,False,False,True]D8=D[np.ix_(TF,[2])]#提取TF=[True,False,False,True]逻辑列表为行索引，列数为2的所有元素D9=D[np.ix_(TF,[1,3])]#提取TF=[True,False,False,True]逻辑列表为行索引，列数为1，,3的所有元素第2章数组连接importnumpyasnpA=np.array([[1,2],[3,4]])#定义二维数组AB=np.array([[5,6],[7,8]])#定义二维数组BC_s=np.hstack((A,B))#水平连接要求行数相同C_v=np.vstack((A,B))#垂直连接要求列数相同第2章数组存取importnumpyasnpA=np.array([[1,2],[3,4]])#定义二维数组AB=np.array([[5,6],[7,8]])#定义二维数组BC_s=np.hstack((A,B))#水平连接np.save('data',C_s)第2章数组存取importnumpyasnpC_s=np.load(‘data.npy’)

数组展平

前面介绍了reshape函数将一维数组形态变换为二维数组，事实上也可以将二维数组形态展平变换为一维数组，通过ravel()函数即可实现。importnumpyasnparr=np.arange(12).reshape(3,4)arr1=arr.ravel()第2章

数组排序

通过sort函数，可以对数组元素值按从小到大进行直接排序importnumpyasnparr=np.array([5,2,3,3,1,9,8,6,7])arr1=np.sort(arr)第2章

数组搜索

通过argmax和argmin函数，可以返回待搜索数组最大值和最小值元素的索引值，如果存在多个最大值或最小值，则返回第一次出现的索引。对于二维数组而已，可以通过设置axis=0或1返回各列或者各行最大值或最小值索引。需要注意的是，索引从0开始。importnumpyasnparr=np.array([5,2,3,3,1,1,9,8,6,7,8,8])arr1=arr.reshape(3,4)maxindex=np.argmax(arr)minindex=np.argmin(arr)maxindex1=np.argmax(arr1,axis=0)#返回各列最大值索引minindex1=np.argmin(arr1,axis=1)

#返回各行最小值索引第2章第2章

科学计算包Numpy矩阵创建、矩阵基本属性矩阵基本运算线性代数运算

矩阵创建Numpy的matrix是继承自NumPy的二维数组对象，不仅拥有二维数组的属性、方法与函数，还拥有诸多特有的属性与方法。同时，Numpy中的matrix和线性代数中的矩阵概念几乎完全相同，同样含有转置矩阵，共轭矩阵，逆矩阵等概念。利用mat、matrix创建Numpy矩阵Numpy中可使用mat、matrix或bmat函数来创建矩阵importnumpyasnpmat1=np.mat("123;456;789")mat2=np.matrix([[1,2,3],[4,5,6],[7,8,9]])

第2章

矩阵创建

利用bmat创建矩阵在矩阵的日常使用过程中，将小矩阵组合成大矩阵是一种频率极高的操作。在Numpy中可以使用bmat分块矩阵函数实现。importnumpyasnparr1=np.eye(3)arr2=3*arr1mat=np.bmat(“arr1arr2;arr1arr2”)

第2章

矩阵基本属性（转置、共轭、逆矩阵）

importnumpyasnpmat=np.matrix(np.arange(4).reshape(2,2))mT=mat.TmH=mat.HmI=mat.I矩阵基本属性第2章

importnumpyasnpmat1=np.mat("123;456;789")mat2=mat1*3mat3=mat1+mat2mat4=mat1-mat2mat5=mat1*mat2mat6=np.multiply(mat1,mat2)#点乘矩阵基本运算第2章

线性代数运算线性代数是数学的一个重要分支。Numpy包含numpy.linalg模块，提供线性代数所需的功能，如计算逆矩阵、求解线性方程组、求特征值、奇异值分解以及求解行列式等。numpy.linalg模块中的一些常用函数表函数名称说明dot矩阵相乘inv求逆矩阵solve求解线性方程组

eig求特征值和特征向量eigvals求特征值svd计算奇异值分解det求行列式线性代数运算第2章

计算逆矩阵使用numpy.linalg模块中的inv函数可以计算逆矩阵importnumpyasnpmat=np.mat('111;123;136')inverse=np.linalg.inv(mat)A=np.dot(mat,inverse)线性代数运算第2章

求解线性方程组numpy.linalg模块中的solve函数可以求解线性方程组importnumpyasnpA=np.mat("1,-1,1;2,1,0;2,1,-1")b=np.array([4,3,-1])x=np.linalg.solve(A,b)#线性方程组Ax=b的解第2章

线性代数运算求解特征值与特征向量numpy.linalg模块中的eigvals函数可以计算矩阵的特征值，eig函数可以返回一个包含特征值和对应的特征向量的元组：importnumpyasnpA=np.matrix([[1,0,2],[0,3,0],[2,0,1]])#A_value=np.linalg.eigvals(A)A_value,A_vector=np.linalg.eig(A)第2章

线性代数运算奇异值分解利用numpy.linalg模块中的svd函数可以对矩阵进行奇异值分解，返回U、Sigma、V这3个矩阵，其中，U和V是正交矩阵，Sigma为一维。importnumpyasnpA=np.mat("4.0,11.0,14.0;8.0,7.0,-2.0")U,Sigma,V=np.linalg.svd(A,full_matrices=False)第2章

线性代数运算计算矩阵行列式的值矩阵行列式是指矩阵的全部元素构成的行列式，但构成行列式的矩阵为方阵时，行列式存在值。numpy.linalg模块中的det函数可以计算矩阵行列式的值。importnumpyasnpA=np.mat("3,4;5,6")A_value=np.linalg.det(A)第2章

线性代数运算第3章

数据处理包Pandaspandas简介、序列创建与访问序列属性与方法序列切片与聚合运算Pandas简介第3章

Pandas是基于Numpy开发的一个Python数据分析包，提供了大量的数据分析函数，包括数据处理、数据抽取、数据集成、数据计算等基本的数据分析手段。Pandas核心数据结构包括序列和数据框，序列储存一维数据，而数据框则可以存储更复杂的多维数据。这里的数据框主要用来存储二维数据（类似于数据表）。通过importpandasaspd命令导入该包，其中pd为其简写。序列创建及访问第3章

序列由索引index和对应的值构成，默认情况下索引从0开始从小到大顺序排列，每个索引对应一个值。可以通过列表、元组、数组、字典等创建默认序列或个性化序列。序列对象的创建通过Pandas包中的Series()函数来实现。importpandasaspd

#导入Pandas库importnumpyasnp

#导入Numpy库s1=pd.Series([1,-2,2.3,'hq'])#指定列表创建默认序列s2=pd.Series([1,-2,2.3,'hq'],index=['a','b','c','d'])#指定列表和索引，创建个性化序列s3=pd.Series((1,2,3,4,'hq'))

#指定元组创建默认序列s4=pd.Series(np.array([1,2,4,7.1]))

#指定数组创建默认序列#通过字典创建序列mydict={'red':2000,'bule':1000,'yellow':500}

#定义字典ss=pd.Series(mydict)

#指定字典创建序列序列创建及访问第3章序列的访问通过index索引访问对应的元素值。print(s4[3])print(s2['c'])执行结果如下:7.12.3序列属性第3章序列有两个属性，分别为值（values）和索引（index）。通过序列中的values属性和index属性可以获取其内容。importpandasaspds1=pd.Series([1,-2,2.3,'hq'])#创建序列s1va1=s1.values#获取序列s1中的值，赋给变量va1in1=s1.index#获取序列s1中的索引，赋给变量in1print(va1)

#打印变量结果print(in1)

#打印变量结果，可通过list()函数转化为列表，如in2=list(in1)执行结果如下：[1-22.3'hq']RangeIndex(start=0,stop=4,step=1)序列方法第3章unique()通过序列中的unique()方法，可以去掉序列中重复的元素值importpandasaspds5=[1,2,2,3,'hq','hq','he']#定义列表s5s5=pd.Series(s5)#将定义的列表s5转换为序列s51=s5.unique()#调用unique()方法去重print(s51)

执行结果如下：[123'hq''he']序列方法第3章isin()通过isin()方法，判断元素值的存在性，如果存在则返回True，否则为False。比如判断‘he’这个元素是否存在前面定义的s5序列中。importpandasaspds5=[1,2,2,3,'hq','hq','he']s5=pd.Series(s5)s52=s5.isin(['he'])print(s52)执行结果如下：0False1False2False3False4False5False6Truedtype:bool序列方法——value_counts()第3章value_counts()通过序列中的value_counts()方法，可以统计获得序列元素值出现的次数。比如统计s5序列中每个元素值出现的次数。s53=s5.value_counts()其中索引（index）为原序列元素的值，其值部分则为出现的次数。序列方法——空值处理方法第3章空值处理方法：isnull()、notnull()、dropan()它们的使用方法如下：isnull()判断序列中是否有空值（nan值），如果有空值，返回True，否则False;notnull()判断序列中的非空值（nan值），如果真，返回True，否则False；dropan()清洗序列中的空值（nan值）。importpandasaspdimportnumpyasnpss1=pd.Series([10,'hq',60,np.nan,20])#定义序列ss1，其中np.nan为空值（nan值）tt=ss1[~ss1.isnull()]#~为取反，采用逻辑数组进行索引获取数据在以上代码后面继续输入以下示例程序：tt2=ss1[ss1.notnull()]tt3=ss1.dropna()tt2和tt3的结果与tt一样。序列切片第3章序列元素访问是通过索引完成的，切片即连续或者间断地批量获取元素。importnumpyasnps1=pd.Series([1,-2,2.3,'hq'])s2=pd.Series([1,-2,2.3,'hq'],index=['a','b','c','d'])s4=pd.Series(np.array([1,2,4,7.1]))s22=s2[['a','d']]#取索引号为字符a,b的元素s11=s1[0:2]#索引为连续的数组s12=s1[[0,2,3]]#索引为不连续的数组s41=s4[s4>2]#索引为逻辑数组print(s22)print('-'*20)print(s11)print('-'*20)print(s12)print('-'*20)print(s41)执行结果如下：a1dhqdtype:object--------------------011-2dtype:object--------------------0122.33hqdtype:object--------------------24.037.1dtype:float64序列聚合运算第3章序列的聚合运算，主要包括对序列中的元素求和、平均值、最大值、最小值、方差、标准差等。importpandasaspds=pd.Series([1,2,4,5,6,7,8,9,10])su=s.sum()sm=s.mean()ss=s.std()smx=s.max()smi=s.min()第3章

数据处理包Pandas数据框（DataFrame）简介、创建数据框属性与方法数据框访问与切片数据框（DataFram）简介第3章

Pandas中另一个重要的数据对象为数据框（DataFram），由多个序列按照相同的index组织在一起形成一个二维表。事实上，数据框的每一列为序列。数据框的属性包括index、列名和值，均可以获取出来并进行操作。由于数据框是更为广泛的一种数据组织形式，许多外部数据文件读取到Python中大部分会采用数据框的形式进行存取，比如数据库、excel和TXT文本。同时数据框也提供了极为丰富的方法用于处理数据及完成计算任务。数据框创建第3章

基于字典，利用Pandas库中的DataFrame函数，可以创建数据框。其中字典的键转化为列名，字典的值转化为列值，而索引为默认值，即从0开始从小到大排列。importpandasaspdimportnumpyasnpdata={'a':[2,2,np.nan,5,6],'b':[‘kl’,’kl’,’kl’,np.nan,’kl’],’c’:[4,6,5,np.nan,6],’d’:[7,9,np.nan,9,8]}df=pd.DataFrame(data)数据框属性第3章

数据框对象具有三个属性，分别为列名、索引和值。以前面定义的df为例print('columns=',df.columns)print('-'*50)print('index=',list(df.index))print('-'*50)print('values=')print(df.values)输出结果为：columns=Index(['a','b','c','d'],dtype='object')--------------------------------------------------index=[0,1,2,3,4]--------------------------------------------------values=[[2.0'kl'4.07.0][2.0'kl'6.09.0][nan'kl'5.0nan][5.0nannan9.0][6.0'kl'6.08.0]]数据框方法第3章dropna()通过dorpna()方法，可以去掉数据集中的空值（nan值），需要注意的是原来数据集不发生改变，新数据集需要重新定义。df1=df.dropna()数据框方法第3章

fillna()通过fillna()方法，可以对数据框中的空值（nan值）进行填充。默认情况下所有空值填充同一个元素值（数值或者字符串），也可以指定不同的列填充不同的值。df2=df.fillna(0)#所有空值元素填充0df3=df.fillna('Kl')#所有空值元素填充kldf4=df.fillna({'a':0,'b':'kl','c':0,'d':0})

#全部列填充df5=df.fillna({'a':0,'b':'kl'})#部分列填充数据框方法第3章

sort_values()可以利用sort_values()方法，指定列按值进行排序importpandasaspddata={'a':[5,3,4,1,6],'b':['d','c','a','e','q'],'c':[4,6,5,5,6]}Df=pd.DataFrame(data)Df1=Df.sort_values('a',ascending=False)#默认按升序，这里设置为降序数据框方法第3章sort_index()有时候需要按索引进行排序，这时候可以使用sort_index()方法。Df2=Df1.sort_index(ascending=False)#默认按升序，这里设置为降序数据框方法第3章head()通过head(N)方法，可以取数据集中的前N行，比如取前面定义的数据框Df2中的前4行。H4=Df2.head(4);数据框方法第3章

drop()利用dorp()方法，可以删掉数据集中的指定列。比如删除前面定义的H4中的b列。H41=H4.drop('b',axis=1)#需指定轴为1数据框方法第3章

join()利用join()方法，可以实现两个数据框之间的水平连接Df3=pd.DataFrame({'d':[1,2,3,4,5]})Df4=Df.join(Df3)数据框方法第3章to_excel()通过to_excel()方法，可以将数据框导出到Excel文件中，Excel文件中。importpandasaspdlist1=['a','b','c','d','e','f']list2=[1,2,3,4,5,6]list3=[1.4,3.5,2,6,7,8]list4=[4,5,6,7,8,9]list5=['t',5,6,7,'k',9.6]D={'M1':list1,'M2':list2,'M3':list3,'M4':list4,'M5':list5}G={'M1':list2,'M2':list3,'M3':list4}D=pd.DataFrame(D)#将字典D转化为数据框G=pd.DataFrame(G)#将字典G转化为数据框D.to_excel('D.xlsx')G.to_excel('G.xlsx')数据框方法第3章

描述统计方法可以对数据框中各列求和、求平均值或者进行描述性统计，以前面定义的Df4为例Dt=Df4.drop('b',axis=1)#Df4中删除b列R1=Dt.sum()#各列求和R2=Dt.mean()#各列求平均值R3=Dt.describe()#各列做描述性统计数据框访问与切片第3章

利用数据框中的iloc属性进行切片假设DF为待访问或切片的数据框，则切片形式为：DF.iloc[①,②]。其中①为行下标控制，②为列下标控制，可通过数值列表来实现，取所有的行或者列用“：”。同时，行控制还可以通过逻辑列表来实现。#ilocforpositionalindexingc3=df2.iloc[1:3,2]c4=df2.iloc[1:3,0:2]c5=df2.iloc[1:3,:]c6=df2.iloc[[0,2,3],[1,2]]TF=[True,False,False,True,True]c7=df2.iloc[TF,[1]]访问当个值，比如：df2.iloc[2,1]第3章

数据处理包PandasExcel数据文件读取TXT数据文件读取CSV数据文件读取Excel文件读取第3章

通过read_excel()函数读取Excel文件数据，可以读取指定的工作簿（sheet），也可以设置读取有无表头的数据表。path='一、车次上车人数统计表.xlsx';data=pd.read_excel(path);Excel文件读取第3章

读取文件中Sheet2里的数据data=pd.read_excel(path,'Sheet2')#读取sheet里面的数据Excel文件读取第3章

有时候数据表中没有设置字段，即无表头，读取格式如下：dta=pd.read_excel('dta.xlsx',header=None)#无表头TXT文件读取第3章

通过read_table()函数可以读取TXT文本数据。需要注意的是，TXT文本数据列之间会存在特殊字符作为分隔，常见的有Tab键、空格和逗号。同时还需注意有些文本数据文件是没有设置表头的。importpandasaspddta1=pd.read_table('txt1.txt',header=None)#分隔默认为Tab键，设置无表头。TXT文件读取第3章

dta2=pd.read_table('txt2.txt',sep='\s+')#分隔为空格，带表头TXT文件读取第3章dta3=pd.read_table('txt3.txt',sep=',',header=None)

#分隔为逗号，设置无表头CSV文件读取第3章CSV文件也是一类广泛使用的外部数据文件，对于一般的CSV数据文件可以通过read_csv()函数读取。importpandasaspdA=pd.read_csv('data.csv',sep=',');#逗号分隔CSV文件读取第3章CSV文件可以存储大规模的数据文件，比如单个数据文件大小可达数GB、数十GB，这时候可以采用分块的方式进行读取。importpandasaspdreader=pd.read_csv('data.csv',sep=',',chunksize=50000,usecols=[3,4,10])k=0forAinreader:k=k+1print('第'+str(k)+'次读取数据规模为：',len(A))执行结果如下：第1次读取数据规模为：50000第2次读取数据规模为：50000第3次读取数据规模为：33699CSV文件读取第3章对大规模的CSV文件进行数据探索，可以读取前N行进行分析，比如前1000行importpandasaspdA=pd.read_csv('data.csv',sep=',',nrows=1000)小结：通过pandas包中的函数，读取Excel、TXT和CSV文件，在Python中的数据结构均为DataFrame数据框，进而我们可以利用数据框中的方法进行数据处理和分析了第3章

数据处理包Pandas时间处理函数数据框合并函数数据框关联函数时间处理函数第3章

to_datetime()函数主要是将字符串型的日期转换为时间戳的格式。方便后续的数据处理，比如提取其所属年份、月份、周数、日期、小时、分钟、秒、星期几等简单调用形式为to_datetime(S,format)，其中S为待求的日期字符串或日期字符串列表或日期字符串序列，format为日期字符串格式，默认缺省importpandasaspdt1=pd.to_datetime('2015-08-0105:50:43.000001',format='%Y-%m-%d%H:%M:%S.%')t2=pd.to_datetime(['2015-08-0105:50:43','2015-08-0105:51:40'])t3=pd.to_datetime(['2015-08-01','2015-08-02'])t4=pd.to_datetime(pd.Series(['2015-08-01','2015-08-02']))时间处理函数第3章

执行结果如下数据框合并函数第3章

对两个数据框进行水平合并、垂直合并是数据处理与整合中常见的操作，这里介绍concat()函数，可以通过设置轴（Axis）为1或0实现importpandasaspdimportnumpyasnpdict1={'a':[2,2,'kt',6],'b':[4,6,7,8],'c':[6,5,np.nan,6]}dict2={'d':[8,9,10,11],'e':['p',16,10,8]}dict3={'a':[1,2],'b':[2,3],'c':[3,4],'d':[4,5],'e':[5,6]}df1=pd.DataFrame(dict1)df2=pd.DataFrame(dict2)df3=pd.DataFrame(dict3)deldict1,dict2,dict3df4=pd.concat([df1,df2],axis=1)#水平合并df5=pd.concat([df3,df4],axis=0)#垂直合并，有相同的列名，index属性伴随原数据框df5.index=range(6)#重新设置index属性数据框合并函数第3章

执行结果如下数据框关联函数第3章

merge()函数类似于数据库中的SQL关联操作语句，指定关联字段之后可进行内连接（InnerJoin）、左连接（LeftJoin）和右连接（RightJoin）等数据操作importpandasaspddict1={'code':['A01','A01','A01','A02','A02','A02','A03','A03'],'month':['01','02','03','01','02','03','01','02'],'price':[10,12,13,15,17,20,10,9]}dict2={'code':['A01','A01','A01','A02','A02','A02'],'month':['01','02','03','01','02','03'],'vol':[10000,10110,20000,10002,12000,21000]}df1=pd.DataFrame(dict1)df2=pd.DataFrame(dict2)deldict1,dict2df_inner=pd.merge(df1,df2,how='inner',on=['code','month']) #内连接df_left=pd.merge(df1,df2,how='left',on=['code','month']) #左连接df_right=pd.merge(df1,df2,how='right',on=['code','month']) #右连接数据框关联函数第3章

执行结果如下第3章

数据处理包Pandas滚动计算、时间元素提取映射与离散化分组统计滚动计算第3章

滚动计算，也称为移动计算，给定一个数据序列，按指定的前移长度进行统计计算，比如求和、平均值、最大值、最小值、中位数、方差、标准差等。这里前移长度的计算，包含自身，如果待计算的数据序列小于指定的前移长度，则无法计算，用空值“nan”来表示。简单调用形式为：S.rolling(N).统计函数，其中S表示序列，N表示指定的前移长度importpandasaspdlist_data=[10,4,3,8,15,26,17,80,12,5]series_data=pd.Series(list_data)rolling_sum=series_data.rolling(5).sum()rolling_mean=series_data.rolling(5).mean()rolling_max=series_data.rolling(5).max()rolling_min=series_data.rolling(5)