pandas大总结（宝典）---看这篇就够了

目录

一、pandas统计分析

1、读取数据

2、DataFrame的增删改查

3、DataFrame的描述分析

4、时间数据

5、分组聚合

6、透视表与交叉表

二、数据预处理

1、合并数据

2、清洗数据（重复值，缺失值，异常值）

3、数据标准化

4、数据的转换

三、补充

help、dir帮助函数

---

一、pandas统计分析

1、读取数据

（1）数据库数据读取/存储：

import pymysql

from sqlalchemy import create_engine

conn = create_engine('mysql+pymysql://root:123456@localhost:3306/databasename?charset=utf8')  

sql = 'select * from tb_name'

df = pd.read_sql(sql=sql,con=con,index_col=True,coerce_float=True,columns=True)

或者：

df = pd.read_sql_table(tablename,con=con,index_col=True,coerce_float=True,columns=True)

（2）文本文件，csv文件读取/存储：

pd.read_table(filepath,sep='/t',header='infer',names=None,index_col=None,

              dtype=None,encoding='utf-8',nrows=None)

pd.read_csv(filepath,sep=',',header='infer',names=None,index_col=None,

            dtype=None,encoding='utf-8',nrows=None)

df.to_csv(path_or_buf,sep=',',na_rep='',columns=None,header=True,index=True,

          index_label=None,mode='w',encoding='utf-8')

（3）excel文件读取/存储

pd.read_excel(filepath,sheetname='',header='infer',names=None,index_col=None,

              dtype=None)

df.to_excel(excel_writer,sheetname='',na_rep='',header=True,index=True,

            index_label=None,mode='w',encoding='utf-8')

2、DataFrame的增删改查

2.1 查看DataFrame：

df.values  # 查看所有元素

df.index   # 查看索引

df.columns # 查看所有列名

df.dtype   # 查看字段类型

df.size    # 元素总数

df.ndim    # 表的维度数

df.shape   # 返回表的行数与列数

df.info    # DataFrame的详细内容

df.T       # 表转置

2.2 查看访问DataFrame中的数据

2.2.1 基本查看方式:

单列数据：df['col1']

单列多行：df['col1'][2:7]

多列多行：df[['col1','col2']][2:7]

多行数据：df[:][2:7]

前几行：  df.head()

后几行：  df.tail()

2.2.2 loc，iloc的查看方式（大多数时候建议用loc）

# loc[行索引名称或条件，列索引名称]

# iloc[行索引位置，列索引位置]

单列切片：df.loc[:,'col1']

         df.iloc[:,3]

多列切片：df.loc[:,['col1','col2']]

         df.iloc[:,[1,3]]

花式切片：df.loc[2:5,['col1','col2']]

         df.iloc[2:5,[1,3]]

条件切片：df.loc[df['col1']=='245',['col1','col2']]

         df.iloc[(df['col1']=='245').values,[1,5]]

2.3 更改某个字段的数据：

df.loc[df['col1']=='258','col1']=214

# 注意：数据更改的操作无法撤销，更改前最好对条件进行确认或者备份数据

2.4 增加一列数据：

df['col2'] = 计算公式/常量

2.5 删除数据：

# 删除某几行数据,inplace为True时在源数据上删除，False时需要新增数据集

df.drop(labels=range(1,11),axis=0,inplace=True)

# 删除某几列数据

df.drop(labels=['col1','col2'],axis=1,inplace=True)

DataFrame增删查改（总结） 1、创建DataFrame    df=pd.DataFrame(data=[[150,0],[150,0],[150,0],[300,0]],columns=['张三','李四'],index=['语文','数学','英语','理综']) 字典创建： df = pd.DataFrame({'语文':[87,79,67,92],                          '数学':[93,89,80,77],                          '英语':[90,80,70,75]},                          index=['张三', '李四', '王五', '赵六'])   2、访问        先写列名称，再写行名称。  df [列] [行] ①访问单列       df[‘date’] ②访问单列多行   df[‘date’] [:5] ③访问多列多行   df[‘id’,’date’] [:5] ④访问多行       df[‘date’][:5]         df[:][1:6] ⑤使用loc 和 iloc  df1=df[['date','format']][:5]    #这2列的前5行数据      （列，行） df2=df[:][:5]         #所有列的前5行数据 df2=df.iloc[0:5,0:5]   df3=df.loc[:,'date']    注意： （1）不要使用df.ix（）函数了，已经不推荐使用了。 （2）loc函数的区间，左右都是闭区间。 （标签） （3）iloc函数的区间，左闭右开。 （位置，索引） （4）df [列] [行]   df.loc[行,列]   df.iloc[行,列]      df.loc[ :, ’date’ ]  df.iloc [ 0:5, 0:5] ⑥ 条件切片+花式切片   （必须学） （1）loc函数可以传入表达式，结果会返回满足表达式的所有值 df4=df.loc[df['format']=='AB',:] print(df4) 3、修改        （更改DataFrame中的数据） 更改DataFrame中的数据的原理是将这部分数据提取出来，重新赋值为新的数据。 （赋值用一个等号） #将order_id为458的变换为45800 ， df.loc [   df['order_id']==458 ,  'order_id'   ] = 45800          df.loc [行，列] = 赋值 ①修改单个数据     方法二： df.iloc[0,3]=100   将第0行第4列的元素修改为100 df.iloc[2:5,3:6]=0   将第3-5行,第4-6列的元素修改为0 ②修改一列数据     ③修改满足条件的数据 一般情况下的修改是满足一定的条件才进行修改！ ④列名/行名 重命名 df.rename(columns={‘原列名’：’新列名’}) df.rename(index={‘原行名’：’新行名’}) 4、增加           ① 新增一列 ① 新增一列固定值 ② 新增一列不同值 【1】 df['score']=[80,98,67,90]     一定要用df [‘新增列名’] 【2】 ② 新增一行 df.loc['new']=[0,0]    一定要用loc标签索引 5、删除         ① 删除一列 df.drop(labels='day', axis=1, inplace=True)       axis=1表示列

3、DataFrame的描述分析

#数值型：

df[['col1','col2']].describe()

#类别型：

df['col1'].value_counts()[0:10]

#category型：

df['col1'] = df['col1'].astype('category')

df['col1'].describe()

4、处理时间序列数据

4.1 转换字符串时间为标准时间：

df['time'] = pd.to_datetime(df['time'])

4.2 提取时间序列信息

year = df['time'].year()

# year-年，month-月，day-天，hour-小时，minute-分钟，second-秒，date-日期，time-时间

  week-一年中第几周，quarter-季节，dayofweek-一周中第几天，weekday_name-星期名称

4.3 加减时间：

# 使用Timedelta,支持weeks，days，hours，minutes,seconds，但不支持月和年

df['time'] = df['time'] + pd.Timedelta(days=1)

df['time'] = df['time'] - pd.to_datetime('2016-1-1')

# 时间跨度计算：

df['time'].max() - df['time'].min()

实操：使用pandas提取日期信息 方法一： 使用for循环，i.year/ i.month提取 案例实操：      import pandas as pd import numpy as np import datetime     df=pd.read_csv("D:/pylearn/data/layout_ex1.csv") df['Time']= pd.to_datetime(df['Time'])   #转换时间类型 year= [ i.year for i in df[‘Time’] ]         #新增一个列表year print(year) 方法二： 使用dt.year/ dt.month方法 案例实操：      import pandas as pd import numpy as np import datetime     df=pd.read_csv("D:/pylearn/data/layout_ex1.csv") df['Time']= pd.to_datetime(df['Time'])   #转换时间类型 df['Year'] = df1['Time'].dt.year         #新增一列Year df['Month'] = df1['Time'].dt.month     #新增一列Month print(df)

5、分组聚合

5.1 使用groupby拆分数据并计算：

df.groupby(by='',axis=0,level=None,as_index=True,sort=True,group_keys=True

           ,squeeze=False).count()

# by--分组的字段  level--标签所在级别，默认None  as_index--聚合标签是否以df形式输出，

  默认True，sort--是否对分组依据，分组标签进行排序，默认True  group_keys--是否显示分组

  标签名称，默认True  squeeze--是否对返回数据进行降维，默认False

# 聚合函数有count，head,max,min,median,size,std,sum

5.2 使用agg聚合数据：

# 求出当前数据的统计量

df[['col1','col2']].agg([np.mean,np.sum])

# 分别求字段的不同统计量

df.agg({'col1':np.sum,'col2':np.mean})

# 求不同字段不同数目的统计量

df.agg({'col1':np.sum,'col2':[np.mean,np.sum]})

综合应用 案例1： 需求：先按sex列分组，然后获取分组后age列的最大值   df.groupby(by='sex').agg({'age':np.max}) 案例2： （1）单层分组聚合：    #求出不同性别学生数学成绩的最大数，只输出['成绩']列 grade_df2 = grade_df.groupby('性别')['成绩'].max()      （2）多层分组聚合：    # 获取不同班级、不同性别、戴与不戴眼镜的学生的最高分 grade_df5 = grade_df.groupby(['班级','眼镜','性别'])['成绩'].max()

6、创建透视表与交叉表

6.1使用pivot_table创建透视表

pd.pivot_table(data,index='order_id',aggfunc=np.sum)

# data为表，index为行分组键，columns为列分组键，values为要聚合的字段，aggfunc为聚合

  函数，默认为mean，fill_value为指定填充缺失值，margins为是否显示汇总，默认为True

  dropna为是否删除全部为NaN的列，默认False

案例一：  

detailPivot1 = pd.pivot_table(detail[['order_id','counts','amounts']],index = 'order_id',aggfunc = np.sum)

6.2使用crosstab创建交叉表

案例一：  以order_id和dishes_name为分组键、counts为值的交叉表

二、数据预处理

1、合并数据

1.1 横向合并数据：

pd.concat([df1,df2,df3],axis=1,join='inner',ignore_index=False,keys=None,

           levels=None,names=None,verify_integrity=False)

# 当axis=1时，concat作行合并，join参数为inner（交集）和outer（并集）,默认为outer

  ignore_index，keys，levels，names，verify_integrity这几个参数不常用，设为默认即可

 

1.2 纵向合并数据

# 使用concat合并

pd.concat([df1,df2,df3],axis=0,join='inner',ignore_index=False,keys=None,

          levels=None,names=None,verify_integrity=False)

# 使用append合并，前提条件是两张表的列名需完全一致

df1.append(df2,ignore_index=False,verify_integrity=False)    例如： df3.append(df4)

1.3 主键合并数据（表联接）

# 使用merge合并：

pd.merge(left,right,how='inner',on=None,left_on=None,right_on=None,

         left_index=False,right_index=False,sort=False,

         suffixes=('_x','_y'),copy=True,indicator=False)

# left和right为联接的表1和表2，how为联接的方式（inner,outer,right,left),默认inner

  left_on为表1的主键，right为表2的主键，left_index为是否将表1的index作为主键，默认False

  sort为是否根据连接键对合并后的数据进行排序，默认False，suffixes为合并后数据列名相同的

  后缀，默认('_x','_y')。

# 使用join进行合并，前提是俩张表的主键的名字必须相同

df1.join(df2,on=None,how='inner',lsuffix='',rsuffix='',sort=None)

# lsuffix为合并后左侧重叠列名的后缀，rsuffix为合并后右侧重叠列名的后缀

1.4 重叠合并数据：

俩张表的内容几乎一致，但某些特征在一张表上是完整的，但在另外一张表上是缺失的

df1.combine_first(df2)

2、清洗数据（重复值，缺失值，异常值）

2.1重复值的检测及处理：  （duplicates   英[ˈdjuːplɪkeɪts]  n. 复制品; 副本;）

# 判断某个字段是否有重复值

len(df.col1.unique())  #将返回值与len(df.col1)进行比较

# 记录重复处理：

df.drop_duplicates(subset=['col1','col2'],keep='first',inplace=False)

# subset为需要去重复的列，keep参数有first（保留第一个），last（保留最后一个），

  false（只要有重复都不保留） inplace为是否在源数据上操作，默认False

案例1：对dishes_name去重

dishes_name = detail.drop_duplicates(subset=['dishes_name'])

案例2：对订单编号、会员编号去重

shapeDet = detail.drop_duplicates(subset = ['order_id','emp_id'])

2.2 缺失值的检测及处理

# 判断字段是否有缺失

df.isnull().sum() 或 df.notnull().sum()     例如：df['date'].isnull().sum()

# 缺失值处理1--删除：

df.dropna(axis=1,how='any',inplace=False)

# axis为1是删除列，为0时删除行  how参数为any（只要有缺失值存在就删除），all（全部为缺失值

  时才删除，默认为any  inplace为是否在源数据上操作，默认为False

# 缺失值处理2--替换法

# 替换数值型字段时，常用平均数，中位数，替换类别性字段时，常用众数

df.fillna(value=None,method=None,axis=1,inplace=False,limit=None)

# method参数为ffill（用上一个非缺失值填充），bfill（用下一个非缺失值来填充）

# 缺失值处理3--插值法

# 线性插值：  # 拉格朗日插值：  # 样条插值：

# 线性插值法需要x与y存在线性关系，效果才好，大多数情况下，用拉格朗日法和样条插值法较好

2.3 异常值的检测及处理

# 使用3σ原则识别异常值，不过该原则只对正态分布或近似正态分布的数据有效

def outRange(ser1):

    boolInd = (ser1.mean()-3*ser1.std()>ser1)|(ser1.mean()+3*ser1.std()

    index = np.arange(ser1.shape[0])[boolInd]

    outRange = ser1.iloc[index]

    return outRange

outlier = outRange(df['col1'])

len(outlier)

# 用箱线图来分析异常值

import matplotlib.pyplot as plt

plt.figure(figsize=(10,7))

p = plt.boxplot(df['col1'].values,notch=True)

outlier = p['fliers'][0].get_ydata()

plt.show()

len(outlier)

3、数据标准化

3.1 离差标准化数据（区间缩放）

# 自定义离差标准化函数

def MinMaxScale(data):

    data = (data-data.min())/(data-data.max())

    return data

df['col1_scale'] = MinMaxScale(df['col1'])

3.2 标准差标准化数据

# 自定义标准差标准化函数

def StandardScale(data):

    data = (data-data.mean())/data.std()

    return data

df['col1_scale'] = StandardScale(df['col1'])

3.3 小数定标标准化数据：通过移动数据的小数位数，将数据映射到区间【-1,1】

# 自定义小数定标标准化数据

def DecimalScale(data):

    data = data/10**np.ceil(np.log10(data.abs().max()))

    return data

df['col1_scale'] = DecimalScale(df['col1'])

离差标准化缺点为若数据集中某个数据值很大，则离差标准化的值就会趋近于0，并且相互之间差别不大。但方法简单，便于理解。标准差标准化受数据分布的影响较小，小数定标标准化的适用范围更广。

4、数据的转换

4.1 哑变量处理

pd.get_dummies(data,prefix=None,prefix_sep='_',dummmy_na=False,columns=None)

# prefix为哑变量后列名的前缀，默认为None  dummy_na为是否需要为NaN值添加一列，默认None

  columns默认为None，表示对所有的object和category类型的字段进行处理

4.2 连续型数据离散化（分箱处理）

# 等宽法：对数据分布要求较高，若数据分布非常不均匀，这种方法不合适

pd.cut(df['col1'],bins=5,labels='',precision=3)

# bins为离散化后的类别数目，labels为离散化后各个类别的名称，默认为空  precision是标签精度

  默认为3

# 等频法：

def SameRateCut(data,k):

    w = data.quantile(np.arange(0,1+1.0/k,1.0/k))

    data = pd.cut(data,w)

    return data

result = SameRateCut(df['col1'],5).value_counts()

三、补充

help、dir帮助函数 （1）help()函数是查看函数或模块用途的详细说明、示例 （2）dir()函数是查看函数或模块内的操作方法都有什么，输出的是方法列表 （有哪些函数）。 举例： （1）help( df.rename )   查看rename函数的用法、例子 （2）help（list.append） 查看append函数的用法、例子 （3）dir（df）           查看df有哪些函数可以用 （4）dir（list）   dir（dict）   查看列表、字典有哪些函数可以用

1、对字段进行重命名 :

df.rename(columns={'old':'new'},inplace=True)  

法二：

columns=({'col1':'new1', 'col2':'new2', 'col3':'new3'})     

df.rename(columns=columns,inplace=True)     

2、利用apply + lambda 对变量进行赋值

df['col'] = df.apply(lambda x:'a' if x.col<10 else 'b' if x.col>=10 and x.col<=20

                     else 'c',axis=1)

3、利用loc 进行多条件筛选：

and用"&"表示，or用“|"表示。  用" isin"筛选多个值。 用"-"实现not in筛选

df.loc[(df['col1']>=20)&(df['col2']=='a')&((df['col3']<10)|(df['col4']==30)),:]

df.loc[df['col1'].isin(['a','b','c'],:]

df.loc[-(df['col1']=='a'),:]

4、使用正则表达式进行模糊匹配

df.loc[df.col.str.contains('^35'),:] # 匹配字段为35开头的记录

df.loc[df.col.str.contains('35$'),:] # 匹配字段为35结尾的记录

5、用groupby和agg对分组后的多个字段进行不同方式的聚合：

常用的聚合函数：

计数：pd.Series.count

求和：np.sum

平均值：np.mean

最大值：np.max

最小值：np.min

df.groupby(by=['col1','col2'],as_index=False).agg({'col3':pd.Series.count,'col5':np.mean,'col6':np.sum})

6、非重复计数：

df.groupby(by='col1',as_index=False).agg({'col2':pd.Series.nunique})

df.col.nunique() #对某个字段进行非重复计数

df.nunique(axis=0) #对表中的每个字段进行非重复计数

7、用sort_values 和 reset_index对多个字段进行排序

df.sort_values(by=['col1','col2'],ascending=['False','True']).reset_index(drop=True)

8、根据某个字段筛选前n条记录，后n条记录

df.nlargest(n,columns=['col'])

df.nsmallest(n,columns=['col'])

9、分组之后的筛选每组前n条记录：

df.assign(rn=df.groupby('col1').col2.rank(method='first',ascending=False)).\

          query('rn<=3').sort_values(['col1','rn']).reset_index().loc[:,['col1','col2','rn']]

10、对某列排序后并编号，相当于给出排序名次：

df['rank']= df['col'].rank(method='first',ascending=False).apply(lambda x:int(x))

df.sort_values(by='rank',ascending=True)

11、对一个字段中的值进行替换操作：

df.replace({'col':{'a':'A','b':'B','c':'C'}},inplace=True)

12、导入必要的包并进行参数设置：

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

%matplotlib inline

plt.style.use('ggplot')

plt.rcParams['font.sans-serif']=['Microsoft YaHei']

plt.rcParams['axes.unicode_minus']=False

import seaborn as sns

sns.set(style='ticks',palette='muted',font_scale=1.5,font='ETBembo',rc={'figure.figsize':(8,4)})

# sns 的style有'dark','white','darkgrid','whitegrid','ticks'五种设置，

# palette有'muted','deep','pastel','bright','dark','colorblind'

import warnings

warnings.filterwarnings('ignore') #去除弹出的warnings

pd.set_option('precision',5)  #设置精度

pd.set_option('display.float_format', lambda x: '%.3f' % x) #不显示科学计数法，设置小数位为3

pd.options.display.max_rows=200 #最多显示200行

13、查看变量类型

df.dtypes #每个字段的类型

set(df.dtypes) #数据集包含哪几种数据类型

df.select_dtypes(include=['float64']).columns #查看每种类型对应的字段

14、对分类型变量作描述分析

df.select_dtypes(include=['0']).describe().T\

   .assign(missing_pct=df.apply(lambda x: (len(x)-x.count())/len(x)))

# 对于object类型describe会给出非空值数量、unique数量、最大频数变量、最大频数

15、对连续型变量作描述分析

(df.select_dtypes(include=['int64','float64']).describe().T)\

 .drop(['25%','50%','75%'],axis=1)\

 .assign(missing_pct = df.apply(lambda x: (len(x)-x.count())/len(x)),

         nunique = df.apply(lambda x:x.nunique()),

         pct_10 = df.select_dtypes(include=['int64','float64']).apply(lambda x:x.dropna().quantile(0.1)),

         pct_25 = df.select_dtypes(include=['int64','float64']).apply(lambda x:x.dropna().quantile(0.25)),

         pct_50 = df.select_dtypes(include=['int64','float64']).apply(lambda x:x.dropna().quantile(0.5)),

         pct_75 = df.select_dtypes(include=['int64','float64']).apply(lambda x:x.dropna().quantile(0.75)),

         pct_90 = df.select_dtypes(include=['int64','float64']).apply(lambda x:x.dropna().quantile(0.9)))

（禁止转载，谢谢！）