一、Pandas数据结构

S1=pd.Series([‘a’,’b’,’c’]) series是一组数据与一组索引（行索引）组成的数据结构
S1=pd.Series([‘a’,’b’,’c’],index=(1,3,4)) 指定索引
S1=pd.Series({1:‘a’,2:’b’,3:’c’}) 用字典形式指定索引
S1.index() 返回索引
S1.values() 返回值
Df=pd.DataFrame([‘a’,’b’,’c’]) dataframe是一组数据与两组索引（行列索引）组成的数据结构
Df=pd.DataFrame([[a,A],[b,B],[c,C]],columns=[‘小写’,’大写’]，index=[‘一’,’二’,’三’])
Columms 为列索引，index为行索引
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyspider 清华镜像

二、读取数据

df=pd.read_excel(r’C:\user...xlsx’,sheet_name=’sheet1’) 或
pd.read_excel(r’C:\user...xlsx’,sheet_name=0) 读取excel表
pd.read_excel(r’C:\user...xlsx’,index_col=0,header=0)
index_col指定行索引，header指定列索引
pd.read_excel(r’C:\user...xlsx’,usecols=[0,1]) 导入指定列,不能有index_col和header
pd.read_tablel(r’C:\user...txt’，sep=’ ’) 导入txt文件,sep指定分隔符是什么
df.head(2) 展示前两行，默认展示前5行
df.shape 显示数据几行几列，不包含行和列索引
df.info()可查看表中数据的类型
df.describe() 可获得表中数值类型指端的分布值（和、平均值、方差等）

三、数据预处理

四、数据选择

df[[‘ID’,’姓名’]] 多个列名要装入list
df.iloc[[1,3],[2,4]] 用行列编号选择数据
df.iloc[1,1] 选取表中的第3行2列数据，第一行默认为列索引
df.iloc[:,0:4] #获取第1列到第4列的值
df.loc[‘一’] #loc用行名选取的行数据，格式是Series，但可以用列表形式访问
df.loc[‘一’][0] 或 df.loc[‘一’][‘序号’]
df.iloc[1]#iloc用行编号选取行数据
df.iloc[[1,3]]#多行编号选取行数据，要用list封装，不然变成行列选取
df.iloc[1:3]#选择第二行和第四行
df[df[‘年龄’]<45] #加判断条件返回符合条件的全部数据，不局限年龄列
df[(df[‘年龄’]<45)&(df[‘ID’]<4)] #判断多条件选择数据
df.iloc[[1,3],[2,4]] 相当于df.loc[[‘一’,’二’],[‘年龄’,’ID’]] #loc是名，iloc是编号
df[df[‘年龄’]<45][[‘年龄’,’ID’]]#先通过年龄条件选择行，再通过不同索引指定列
df.iloc[1:3,2:4]#切片索引

五、数值操作

df[‘年龄’].replace(100,33)#对年龄列中的100替换成33
df.replace(np.NaN,0)#相当于fillna(),其中np.NaN是python中缺省值的表示方式
df.replace([A,B],C)#多对一替换，A、B替换成C
df.replace({‘A’:’a’,‘B’:’b’,‘C’:’c’})#多对多替换
df.sort_values(by=['申请单编号'],ascending=False)#申请单编号列降序排列，Ture升序排列（默认）
df.sort_values(by=['申请单编号'],na_position=’first’)#申请单编号列升序排列，缺失值排在第一位
默认缺失值在最后一位last
df = pd.DataFrame([['A',1],['A',3],['A',2],['B',5],['B',9]], columns = ['name','score'])
df.sort_values(['name','score'], ascending = [True,False])#多列排序
df.groupby('name').apply(lambda x: x.sort_values('score',ascending=False)).reset_index(drop=True)

df[‘销量’].rank(method=’first’)#销量排名（不是排序），method有first\min\max\average

df.drop([‘销量’,’ID’],axis=1)#删除列,直接是列名,inpace=True是保留修改哦
df.drop(df.columns[[4,5]],axis=1)#删除列,是编号
df.drop(colums=[‘销量’,’ID’])#此种方式删除列，可以不写axis=1
df.drop([‘a’,’b’],axis=0)#删除行,直接是列名
df.drop(df.index[[4,5]],axis=0)#删除行,是编号
df.drop(index=[‘a’,’b’])#此种方式删除行，可以不写axis=0
df[‘ID’].value_counts()#对ID列中数据出现的次数进行统计
df[‘ID’].value_counts(normalize=Ture,sort=False)#对ID列中数据出现的次数占比进行统计，并降序排序
df[‘ID’].unique()#获取列的唯一值
df[‘年龄’].isin([‘a’,11])#查看这列中是否包含a或11
pd.cut(df[‘ID’],bins=[0,3,6,10])#用bins指明切分区间
pd.qcut(df[‘ID’],3)#ID列切分成3个部分，每部分数据个数尽量一致
df.insert(2,’商品’,[‘书’,’笔’,’计算器’])#插入第三列
df[’商品’]=[‘书’,’笔’,’计算器’])#插新列，在表的最后面
df.T行列互换
df.tack()#把表格型数据转化成树形数据
df.set_index([‘ID’,’姓名’]).stack().reset_index()#宽表转换成长表，先将共同列设置成行索引，再对其他列
进行转化成树形数据，再重置行索引

六、数据运算

df[‘ID’]+Df[‘ID’]#可进行加减乘除
df[‘ID’]>Df[‘ID’]#可进行> < == !=等比较运算
df.nunique()#统计每列不重复值的个数
df.count()#统计每列的非空值的个数
df.count(axis=1)#统计每行的非空值的个数
df[‘ID’].count()#统计指定列的非空值的个数
df.sum(axis=1)#每列/行求和结果
df.mean(axis=1)#每列/行求均值
df.max(axis=1)#每列/行求最大值
df.min(axis=1)#每列/行求最小值
df.median(axis=1)#每列/行求中间值
df.mode(axis=1)#每列/行中出现最多的值
df.var(axis=1)#每列/行求方差
df.std(axis=1)#每列/行求标准差
df.quantile(0.25)#求1/4分位数，可以0.5、0.75等分位数
df.corr()#求整个DataFrame表中的相关性

七、时间序列

from datetime import datetime
datatime.now()#返回现在的时间年月日时分秒
datatime.now().year#返回年，可以.month.day
datatime.now().weekday()-1#返回周几
datatime.now().isocalendar()#返回周数
（2018，41，7）#2018年的第41周第7天
datatime.now().date()#只返回年月日
datatime.now().time()#只返回时间
datatime.now().strftime(‘%Y-%m-%d %H:%M:%S’)#返回2020-03-13 09:09:12
pd.to_datetime(['201221'],format = "%Y%m%d")#返回DatetimeIndex(['2012-02-01'], dtype='datetime64[ns]', freq=None)
pd.to_datetime('201221',format = "%Y%m%d")#不加列表，返回Timestamp('2012-02-01 00:00:00')，需要省去时分秒可以在后面加.strftime("%Y-%m-%d")
from dateutil.parser import parse
parse(str_time)#将字符串的时间转化成为时间格式
pd.Datetimeindex([‘2020-02-03’,2020-03-05’])#设置时间索引
data[‘2018’]#获取2018年的数据
data[‘2018-01’]#获取2018年1月的数据
data[‘2018-01-05’:‘2018-01-15’]#获取这个时段的数据
非时间索引的表格处理
df[df[‘成交时间’]==datetime(2018,08,05)]
df[df[‘成交时间’]>datetime(2018,08,05)]
df[(df[‘成交时间’]>datetime(2018,08,05))&(df[‘成交时间’] <datetime(2018,08,15))]
cha=datatime(2018,5,21,19,50)-datatime(2018,5,18,17,50)
cha.days#返回天的时间差
cha.seconds#返回秒的时间差
cha.seconds/3600#返回小时的时间差
datatime(2018,5,21,19,50)+timedelta(days=1)#往后移一天
datatime(2018,5,21,19,50)+timedelta(seconds=20)#往后移20秒
datatime(2018,5,21,19,50)-timedelta(days=1)#往前移一天

日期时间类型接口一览表

df = generate_sample_data_datetime().reset_index()
df = df.sample(500)
df["Year"] = df["index"].dt.year
df["Month"] = df["index"].dt.month
df["Day"] = df["index"].dt.day
df["Hour"] = df["index"].dt.hour
df["Minute"] = df["index"].dt.minute
df["Second"] = df["index"].dt.second
df["Nanosecond"] = df["index"].dt.nanosecond
df["Date"] = df["index"].dt.date
df["Time"] = df["index"].dt.time
df["Time_Time_Zone"] = df["index"].dt.timetz
df["Day_Of_Year"] = df["index"].dt.dayofyear
df["Week_Of_Year"] = df["index"].dt.weekofyear
df["Week"] = df["index"].dt.week
df["Day_Of_week"] = df["index"].dt.dayofweek
df["Week_Day"] = df["index"].dt.weekday
df["Week_Day_Name"] = df["index"].dt.weekday_name
df["Quarter"] = df["index"].dt.quarter
df["Days_In_Month"] = df["index"].dt.days_in_month
df["Is_Month_Start"] = df["index"].dt.is_month_start
df["Is_Month_End"] = df["index"].dt.is_month_end
df["Is_Quarter_Start"] = df["index"].dt.is_quarter_start
df["Is_Quarter_End"] = df["index"].dt.is_quarter_end
df["Is_Leap_Year"] = df["index"].dt.is_leap_year

八、数据透视表

df.groupby(‘客户分类’).count()#客户分类后求数运算
df.groupby(‘客户分类’).sum()#客户分类后求和运算
df.groupby(‘客户分类’,’区域分类’).sum()#多列分类后求和运算
df.groupby(‘客户分类’,’区域分类’)[‘ID’].sum()#多列分类后ID求和运算
df[‘ID’]#DataFrame取出一列就是Series类型
df.groupby(df[‘ID’]).sum（） 相当于 df.groupby(‘ID’).sum（）
df.groupby(‘客户分类’).aggregate([‘sum’,’count’]# aggregate可实现多种汇总方式
df.groupby(‘客户分类’).aggregate({‘ID’：‘count’,’销量’： ‘sum’})

九、多表格拼接

pd.merge(df1,df2)#默认自动寻找两个表中的公共列进行拼接
pd.merge(df1,df2,on=“学号“)#on来指定连接列，连接列要是公共列
pd.merge(df1,df2,on=[‘学号’,’姓名’]#on来指定连接列，连接列要是公共列
pd.merge(df1,df2,left_on=‘学号’right_on=’编号’) #由公共列，但类名不同时用左右键指定
pd.merge(df1,df2,left_index=‘学号’right_index=’编号’)#两表公共列都是索引列时
pd.merge(df1,df2,left_index=‘学号’right_on=’编号’)#公共列一个时索引列一个时普通列
pd.merge(df1,df2,on=’学号’,how=’inner’)#返回公共列中对应的公共值拼接（内连接）
pd.merge(df1,df2,on=’学号’,how=’left’)#返回公共列中对应的左表值（左连接）
pd.merge(df1,df2,on=’学号’,how=’right’)#返回公共列中对应的右表值（右连接）
pd.merge(df1,df2,on=’学号’,how=’outer’)#返回公共列中对应的所有值（外连接）
pd.concat([df1,df2])#两个结构相同的表纵向连接，保留原索引值
pd.concat([df1,df2]，ignore_index=True)#两个结构相同的表纵向连接，重新设置索引值
pd.concat([df1,df2]，ignore_index=True).drop_duplicates()#拼接后去掉重复值

十、导出文件

df.to_excel(excel_writer=r’C:\users\zhoulifu\Desktop\测试.xlsx’,sheet_name=’文档’，index=False,columns=[‘ID’,’销量’,‘姓名’],encoding=’utf-8’,na_rep=0)

导出多个文件至一个文件的多个sheet；

writer=pd.ExcelWriter(excelpath,engine='openpyxl',mode='a')
用openpyxl不会删除excel表中原有sheet，更保险！
df1.to_excel(writer,sheet_name=‘表一’，index= False)
writer.save()
writer.close()
df = pd.read_excel(path,sheet_name='test3')
#写入到原Excel表中避免清空其他数据
book = openpyxl.load_workbook(path)   #读取你要写入的workbook
#和pd.read_excel() 用于将Dataframe写入excel。xls用xlwt。xlsx用openpyxl
writer = pd.ExcelWriter(path,engine='openpyxl')   
##此时的writer里还只是读写器. 然后将上面读取的book复制给writer  
writer.book = book
#转化为字典的形式
writer.sheets = dict((ws.title, ws) for ws in book.worksheets)#返回一个字典，sheet名和sheet对象组成的键值对
#将data写入writer
df.to_excel(writer,sheet_name="测试",index=False)
writer.save()
writer.close()
to_json

data = df([['a', 'b'], ['c', 'd']], index=['row 1', 'row 2'], columns=['col 1', 'col 2'])

json_columns = data.to_json(orient = "columns") # 返回结果：

'{"col 1":{"row 1":"a","row 2":"c"},"col 2":{"row 1":"b","row 2":"d"}}'

json_split = data.to_json(orient = "split")  # 返回结果：

'{"columns":["col 1","col 2"],"index":["row 1","row 2"],"data":[["a","b"],["c","d"]]}'

json_records = data.to_json(orient = "records")  # 返回结果：

'[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'

json_index = data.to_json(orient = "index")  # 返回结果：

'{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}'

json_values = data.to_json(orient = "values")  # 返回结果：

'[["a","b"],["c","d"]]'