pandas实现数据读取&清洗&分析的项目实践

目录

• 一、数据读取和写入
• 1.1 CSV和txt文件：
• 1.2 Excel文件：
• 1.3 MYSQL数据库：
• 二、数据清洗
• 2.1 清除不需要的行数据
• 2.2 清除不需要的列
• 2.3 调整列的展示顺序或列标签名
• 2.4 对行数据进行排序
• 2.5 空值的处理
• 2.6 数据去重处理
• 2.7 对指定列数据进行初步加工
• 2.8 对DataFrame内所有数据进行初步加工处理
• 2.9 设置数据格式
• 三、数据切片和筛选查询
• 3.1 行切片
• 3.2 列切片
• 3.3 数据筛选和查询
• 3.4 遍历
• 四、数据简单统计和聚合
• 4.1 数据统计
• 4.2 数据分组和聚合

近期因工作需要，需对几十万条商品和订单数据进行初步的数据分析，本来尝试过用Excel，但是数据量一旦超过10万条，Excel和电脑的性能瓶颈就捉襟见肘了，为了后续遇到类似问题提升处理效率，抽空系统性的研究学习了pandas这个库，初步上手之后，感觉以后再处理千万级的数据量的时候，也会游刃有余了，话不多讲，直接进入正题。

本文主要沿着在日常使用pandas处理数据时的步骤，讲解pandas对应的知识点和常见操作，分析工具使用jupyter-notebook，强烈推荐。

本文假设已经对pandas有基础性的了解，核心是Series和DataFrame概念（numpy库可不了解）

一、数据读取和写入

第一步，先从存量数据源，将数据读取过来，然后再将分析得出的数据写入并永久保存，这是数据分析的开始和结束，在此一并说明，主要只讲解常用的读取和写入方式，其他的可以自行学习和了解

1.1 CSV和txt文件：

import pandas as pd
file_path_read=''
file_path_write=''

#读入csv或txt文件内数据，以下只罗列了常用的参数
df=pd.read_csv(
    file_path_read ,  #指定需读入或写入的文件的路径，可为相对路径，也可为绝对路径
    sep= ',' ,  #指定分隔符
    encoding= utf-8 , #指定字符编码格式
    usecols=None , #指定需读入的列，列表格式，可为索引[1,2,3]或列明['A','B','C']
    names=['A','B','C'] , #可自定义读入数据的列标签
    skip_blank_lines=True,  #设置是否跳过内容全空的行
    nrows=1000, #指定读入的行数
    skiprows=[2,5],#指定需跳过的行数
    dtype={0:str,'B':'float64'}) #指定列数据读入的格式，可分别对每一列指定读入的数据格式

#将分析好的数据写入csv或txt文件
df.to_csv( file_path_write  )

1.2 Excel文件：

import pandas as pd
file_path_read=''
file_path_write=''

#从数据源读取数据，并同时指定读入数据的格式，也可不指定，读入后就是一个标准的DataFrame
#其他常用的参数，与read_csv一致，不再赘述
df=pd.read_excel(file_path_read ,encoding= utf-8 , usecols=None , names=['A','B','C'] , skip_blank_lines=True, nrows=1000, skiprows=[2,5],dtype={0:str,2:'float64'})

#将分析好的数据写入Excel，并同时指定写入数据的格式，也可不指定
df.to_excel(file_path_write , dtype=str)

1.3 MYSQL数据库：

import pandas as pd
from sqlalchemy import create_engine

#1、连接数据库
#其中username为账户名，比如root，password为密码，ip为数据库的ip，如果是本地的一般是localhost，port为端口，database为数据库名
engine = create_engine('mysql+pymysql://username:password@ip:port/database')

#2、定义查询sql语句
sql = '''select * from tablename where colname in (,)  '''

#3、读取数据，使用以上数据库引擎和sql语句查询数据，直接读入，为DataFrame格式
#coerce_float，很有用，为true时会将字符串格式的数据直接读取为float数字格式，columns，列表格式，指定读入的行，一般没用，因为基本会在sql语句中指定
#sql也可以直接为表名，即读入整张表，但一般使用sql语句
df=pd.read_sql(sql, engine,  coerce_float=True, columns=None)

#4、写入数据，将分析好的数据落库
#tablename为需要写入的表名，if_exists,默认为false，即表存在则不写入，也可设置为'append'，即将数据追加到该表内，dtype可指定各个列的数据格式，一般无需指定
df.to_sql('tablename', engine , if_exists='append' ,dtype={})

二、数据清洗

2.1 清除不需要的行数据

一般数据源都是csv、txt 或者excel，此时可能源数据内就包含大量异常或不想要的行数据，如果不进行清除，则会严重影响后续数据分析的准确性

当然，如果数据源是mysql等数据库，则可在读取数据的时候，即通过slq命令，将异常或不想要的数据给过滤掉。

2.1.1 清除满足指定条件的行数据

#清除满足指定条件的行数据的表达式
df = df.drop(df[<some boolean condition>].index)

#比如希望清除x列小于0.01或大于10的指定行数据，返回一个清除后的DataFrame
#其中的布尔表达式可以有多个,可以用与（&）或（|）非（~）进行连接
df_clear = df.drop(df[(df['x']<0.01) | (df['x']>10)].index) #删除x小于0.01或大于10的行

#或者，比如希望清除A列值为空，或者B列中值小于0的行，然后返回清除后的新的DataFrame
df_clear = df.drop(df[(df['A']==‘') | (df['B']<0)].index)

2.1.2 清除指定的行数据

如果数据源是mysql等数据库，可直接在sql语句中添加筛选条件，不过在分析过程中，可能也需要清除指定的行数据。

#清除指定的行
#drop(list)，函数接受一个列表，列表内是指定需删除的行索引
df.drop([index]) #即删除指定行
df.drop([0,1,2,3,4]) #清除前5行
df.drop(range(20)) #清除前20行，

2.2 清除不需要的列

如果数据源是mysql等数据库，则其实可以在sql语句中，只拉取自己需要的列，如果是从csv或Excel读取，也可在读取数据时，就指定对应需要的列

不过在实际数据分析时，可能在分析过程中产生了新的DataFrame，此时可能需要清除不需要的列。

#执行删除操作时，原df不会变化，一般是返回一个新的DataFra
df.drop(['列索引或标签',axis=1])

#删除索引为2，即第三列
df.drop([2],axis=1)

#删除索引为0，1，2即第一、第二、第三列
df.drop([0,1,2],axis=1)

#删除列标签为A的列
df.drop(['A'],axis=1)

#删除列标签为A、B、C的多列
df.drop(['A','B','C'],axis=1)

2.3 调整列的展示顺序或列标签名

这个步骤一般是为了方便自己观察数据，或者在数据分析接近尾声时，为增强数据可读性，对列的顺序进行调整

#语句如下，使用reindex函数
new_col_list=['B','C','A'] #假设希望将列的展示顺序由A、B、C，调整为B、C、A
df.reindex(columns = new_col_list)

#调整存量DataFrame的列标签名称，一般用于将默认的列标签修改的更加直观易懂
new_col_name=['age','name',gender']
df.columns=new_col_name

2.4 对行数据进行排序

此处也是为了在进行数据分析时观察数据，或者增强输出的数据的可读性

2.4.1 sort_values()

即按照实际的数据值进行排序

#df.sort_values()函数
#既可以根据列数据，也可根据行数据排序，最为常用

#axis，默认为0，即纵向排序，可指定按照哪列的值进行排序，最终会改变数据纵向的顺序
#axis，为1时，即横向排序，可指定按照哪行（根据行索引）进行排序，最终会改变数据的横向顺序
#inplace,
#ascending，可为数组格式，即指定按照多行或列，不同行或列的升序降序规则
#na_position，指定缺省值排在最前还是最后，一般是last，即最后
df.sort_values(by=, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')

#假设数据如下：
    b   a   c
2   1   4   1
0   2   3   3
3   2   1   2
1   3   2   8

#先按照b降序，再按照a升序排序
df.sort_values(by=['b','a'],axis=0,ascending=[False,True])

#先按照3行升序排序，再按照0行降序排序
df.sort_values(by=[3,0],axis=1,ascending=[True,False])

2.4.2 sort_index()

#df.sort_index()函数
#默认根据行标签对所有行排序，或根据列标签对所有列排序，或根据指定某列或某几列对行排序。

#axis，默认为0，即按行标签进行排序，最终会改变数据在纵向的顺序
#axis，为1时，即按列标签排序，最终会改变数据在横向的顺序
#na_position，指定缺省值排在最前还是最后，一般是last，即最后
df.sort_index(axis=0, ascending=True , na_position='last')

#假设数据如下：
    b   a   c
2   1   4   1
0   2   3   3
3   2   1   2
1   3   2   8

#按照行标签升序排序，最后会变成0、1、2、3
df.sort_index(axis=0,ascending=True)

#按照列标签升序排序，最后会变成a、b、c
df.sort_index(axis=1,ascending=True)

2.5 空值的处理

一般导入的数据，会存在空值的情况，为了避免此类数值影响后续的数据分析，一般需要进行相应的处理

#1、对空值直接清除
df.dropna(
    axis=0,     # 0: 对行进行操作; 1: 对列进行操作 默认为0
    how='any'   # 'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop 默认为'any'
    ) 

#2、对空值填补
df.fillna(value=0) #用0填补所有的空值
df.fillna({'B': 3,'C': 4})  #使用常量填补对应列的空值，比如针对B列，用3填补空值，针对C列，用4填补空值

#3、用前项填充或者后项填充
df.fillna(method = 'ffill') #用前一个观测值填充
df.fillna(method = 'bfill') #用后一个观测值填充

#4、用均值或中位数填充各自的列
df.fillna(df.median())
df.fillna(df.mean())

#注：使用fillna,dropna时，需要添加参数 inplace = True，如df.fillna(df.median()，inplace = True),以确认修改，否则实际的数据并不会有改动。

2.6 数据去重处理

一般源数据可能会在某列存在重复数据的问题，为方便后续处理等，可能需要进行去重

#删除重复行时，需要用到drop_duplicates函数
df.drop_duplicates(
    ['A','B'], #指定按照某列，判断数据重复，参数非必填，可以单列、多列
    keep='first' #指定如果发现重复，保留哪行数据，枚举有first（保留第一行）、last（保留最后一行），False（删除所有重复行）
)

df.drop_duplicates() #删除完全重复的行数据

2.7 对指定列数据进行初步加工

#1、map()函数
#可对一列数据，统一给一列(Series)中的每一个元素应用指定函数
def myfunc(x):
    if x>40:
        return '中年人'
    elif x<30:
        return '青年人'
    else:
        return '尴尬的年纪'
df['age'].map(myfunc)

#2、apply()函数
#也可对一列数据，统一应用指定函数，但功能更强大，可传入除列元素的其他参数
#其他参数可以关键词的方式传入，也可以直接传入其他值
def myfunc(x,*args,**args_dict):
    if x<10000:
        return x+args_dict['high']
    else:
        return x+args_dict['low']
df1['salary']=df1['salary'].apply(myfunc,low=100,high=300)#对工资列，低于1万的加一个值，高于1万的，加另外一个值

2.8 对DataFrame内所有数据进行初步加工处理

此种方法不太常用，或者可以作为填充默认值的方式，比如将NAN的值填充为0

#以下会对DataFrame每个元素应用一次指定的函数，并将返回值作为新的值
#一般会产生一个新的df
#以下函数将空值全部填充为0
df_new=df.apply(lambda x: 0 if str(x)=='' else x)

2.9 设置数据格式

一般在后续数据处理时，或者在数据处理基本宣告尾声时，为增强数据可读性或者分析的方便，需要对数据设置格式

#以下主要演示对某df内某列数据进行常见的数字格式设置

#四舍五入
df['salary'].round([decimals=2]) #将工资列，数字进行四舍五入并保留小数点后2位

#将小数设置为百分数，以下设置为精确到小数点后2位，返回一个设置好格式的series
df['percent'].map( lambda x: format(x,'.2%') )

#设置千分位分隔符，返回一个设置好格式的series
df['percent'].map( lambda x: format(x,',') )

#更多设置格式的方式，可自行了解

三、数据切片和筛选查询

一般需要对清洗后的数据，按照具体数据分析的需求，提取部分数据并进行进一步的分析，这个时候就需要对数据进行进一步切片或查询筛选，找出自己想要的具体数据集

3.1 行切片

提取指定的行，一般是由行索引组成的列表，即提取指定的某行或某几行

#1、直接使用索引
df[index:index+1] #注意，一定要用切片的形式，如果希望直接使用index，则可用iloc[index]
#2、使用行标签，行标签为再创建DataFrame或Series时自定义的行标签
df['row_tag']

#提起的方法，可以直接使用标准的列表访问方式[]，也可使用loc()和iloc（函数）
#[]方式，可使用标签或索引，如果传入的是
#loc()函数，一般用于使用行或列标签进行访问
#iloc()函数，一般使用行或列index索引进行访问

df[2:5] #提取第3到5行

df['2020-10-20'] #提取行标签为2020-10-20的行数据

df.loc['2020-10-20':'2020-10-31',:] #提取指定3到5行，全列，后面的 : 也可不写

df.loc[2:4,:] #提取指定3到5行，全列，后面的 : 也可不写

3.2 列切片

提取指定的一列或多列，一般使用列标签或列索引进行提取

df['colname'] #直接提取指定单列标签的列数据

df[['A','D','E']] #指定直接提取指定多列数据，这种方法只能使用列标签进行提取

df.loc[:,'A':'C'] #使用loc方法提取A列到C列
df.iloc[:,0:2] #使用iloc方法提取第1到3列

3.3 数据筛选和查询

按照一定的条件，对数据进行筛选和查询，找出自己想要的数据记录（行）

3.3.1 快速筛选

一般在导入数据或数据分析时，如果数据量过大，希望能摘出几行，看下数据表现是否正常

df.head(n) #展示前n行，默认5
df.tail(n) #展示后n行，默认5

3.3.2 条件筛选和查询

本质和sql查询较为相似

#通过逻辑运算来取数据子集，查询和筛选出列值满足指定条件的行数据
#可使用 & (AND)、 ~ (NOT) 和 | (OR) 连接多个条件表达式
df[df[ ‘country' ]== 'french' ]
df[(df[ ‘country'  ]== 'french' ) & (df[ 'year_born' ]=='1990')]
df[(df[‘country'  ]== 'french' ) & (df[ 'year_born' ]=='1990') & ~(df[ 'city' ]== 'London' )]

df[(df[‘country'  ]== french ) & (df[ 'year_born' ]==1990) & ~(df[ 'city' ].isin([ ['London' , 'beijing']) )]

3.3.3 正则过滤

使用正则表达式，过滤某指定列的值

df.filter(regex='string')#其中string为正则表达式

3.4 遍历

不建议使用，因为效率比较低，一般使用pandas内置的一些函数满足类似需求

3.4.1 行遍历

用于分析每一行的数据并进行遍历，比如发现某一行数据的对应列值是否满足条件

#逐行打印数据，使用iloc
for i in range(len(df.index)):
    print(df.iloc[i])
#逐行打印数据，使用loc
for i in df.index:
    print(df.loc[i])

3.4.2 列遍历

#逐个打印df中的每一列，使用df
for i in df.columns:
    print(df[i])
#逐个打印df中的每一列，使用loc
for i in df.columns:
    print(df.loc[:,i])

#逐个打印df中的每一列，使用iloc
for i in range(len(df.columns)):
    print(df.iloc[:,i])

3.4.3 DataFrame所有数据遍历

#使用loc
for i in df.index:
    for j in df.columns:
        if df.loc[i][j]=='':
            print('发现空值')
#使用iloc
for i in range(len(df.index)):
    for j in range(len(df.columns)):
        if df.iloc[i][j]=='':
            print('发现空值')

四、数据简单统计和聚合

4.1 数据统计

4.1.1 指定列数据统计分析

#常见统计数据值
#某列的个数、合、平均值、最大值、最小值
df['colname'].count()
df['colname'].sum()
df['colname'].mean()
df['colname'].max()
df['colname'].min()

#快速统计
#会快速展示每一列的最大、最小、平均、均方差等统计数据
df.describe()

4.1.2 各列相关度分析

#协方差--相关度系数
df.corr()  #会输出相关性矩阵,展示每一列的相关度系

4.2 数据分组和聚合

4.2.1  指定列快速分组和聚合
一般情况下，希望对某列，比如国家等，对数据进行分组并快速知道每个国家对应数据记录的数量，然后进行快速预览

#先按照A列的值，对数据进行分组，然后计算出每个分组的数据记录数量
df['A'].value_counts()

4.2.2 分组

常见的数据分析中，一般是对数据按照行或列进行分组，然后进一步对分组数据，按照分组进行求和、计数、求平均值、均方差等聚合，或者用自定义的函数进行进一步的分析

#分组使用groupby函数，分组之后，得到一个DataFrameGroupBy对象，后续可对该对象进行聚合

#1、按单列分组，纵向分组
df.groupby('colname')
df.groupby('country') #指按国家列分组

#2、按多列分组，纵向分组
df.groupby(['cloA','colB']) #先按照A列，再按照B列分组

#3、按单行分组，横向分组
df.groupby(level=index)

#4、按多行分组，横向分组
df.groupby(level=[0,1])

#5、通过字典或者Series分组
#可将行或者列标签，通过子字典映射成对应的值，然后进行分组
mapping = {'a':'one','b':'one','c':'two','d':'two','e':'three'}
df.groupby(mapping)

#6、自定义函数分组
#会将行或者列标签作为参数传入自定义函数，并以函数返回值作为分组的名进行分组
def myfunc(x):
    if x =='a' or x=='b'
        return 'one'
    else:
        return 'two'
df.groupby(myfunc,axis=0)

4.2.3 聚合

4.2.3.1 常见聚合函数

gp=df.groupby('A')
gp.count() #计数
gp.sum()#求和
gp.max(),gp.min()#最大值、最小值
gp.mean()#算数平均数
gp.first(),gp.last()#第一个和最后一个非空
gp.prod()#非空数值的乘积
gp.median()#非空的算数中位数
gp.std(),gp.var()#非空数据的标准差和均方差
gp.describe()#快速生成以上所有统计数据

4.2.3.2 自定义聚合函数

#对某分组后的对象使用自定义的聚合函数，需要用到agg()函数
#具体实现，分组后的数据为一个数组，然后会分别将每组对应的数组作为参数传入自定义函数内，最终以函数返回值作为该分组数据聚合后的值
def myfunc(x):
    return (x.max()-x.min())

df.groupby('A').agg(myfunc)

4.2.3.3 应用多个聚合函数

#对某次分组对象，一次性应用多个聚合函数
#可以集合的格式传入不同的聚合函数，如果不写名称，只传入函数，则默认以函数名为列标签
df.groupby('A').agg([('求和',sum),('标准差',std),'mean',('range',myfunc)])

#对某次分组对象，不同列使用不同的聚合函数
df.groupby('sku_type').agg({
    'sku_sale_price':'max',
    'profit_rate':'mean'
    })

4.2.3.4 将聚合结果与原始数据合并

#1、使用merge函数进行连接合并
agg=df1.groupby('card_cate_name').sum().add_prefix('sum_')
pd.merge(df1,agg,on='card_cate_name',how='right')

#2、使用transform()，,将聚合结果按照原始数据排序成一个DataFrame对象，然后再合并
tf = df.groupby('A').transform(sum)
df[tf.columns]=tf

4.2.3.5 数据透视图

了解了数据的分组和聚合之后，再了解pandas的数据透视图，会更加直观易懂，并且当使用习惯了透视图之后，会发现，可能大多数情况下，就不再需要groupby了，而是直接使用pivot_table函数，因为更加直观、高效

下图是数据透视图函数工作示意：

#类似Excel的数据透视图，pandas可对数据快速生成你想要的数据透视图，以快速发现数据相关有趣的特征

#1、数据透视表的使用
pd.pivot_table(
    df,#要生成透视图的数据源
    index=['colA','colB','colC'],#设置透视图的行索引，类似指定需要以源数据的哪些列值进行分组，可指定多个，自左向右依次多级分组
    values=['colD','colE'],#指定分组后，需要透视的数据列，可对数据列应用不同的聚合函数来透视，也可不指定，不指定则会展示出除了index指定的列外所有其他列的聚合透视
    columns=['colF','colG'],#指定透视表的列，即会使用指定列的值，对指定的values列进行分组，该概念是相较于index,注意，columns指定的列和index指定的列及values指定的列不能有重复
    aggfunc=[np.mean,len],#指定聚合函数，可以指定多个，如果指定多个，则会分别对指定的values列应用对应的聚合函数
    fill_value=0,#将Nan空值设置为0，为了便于后面应用聚合函数造成异常，也可不设
    margins=True,#主要是对已经分组透视好的数据values，最后进行纵向求和，得出一个汇总值
)

#2、对每一个values列应用不同的聚合函数
pd.pivot_table(
    df,#要生成透视图的数据源
    index=['colA','colB','colC'],
    values=['colD','colE'],
    aggfunc={'colD':np.mean,'colE':len},#指定colD列使用mean聚合函数，colE列使用len聚合函数，字典格式
    #或者
    aggfunc={'colD':np.mean,'colE':[np.mean,np.sum,len]},#对colE列使用多个聚合函数
)

#3、使用自定义的聚合函数
#与分组与聚合一样，也可以指定使用自定义的聚合函数，此时同理，也会将分组后每列的值作为参数传入自定义函数
#以下实现了count的功能，即根据A分组，计算B列值对应各分组的记录个数
def count(x):
    c=0
    for i in x:
        c+=1
    return c
pd.pivot_table(df,index=["A"],values=["B"],aggfunc=[count])

#4、数据透视表的筛选
tb=pd.pivot_table(df,index=['colA'])
tb.query('name == ["jacky"]')
#或
tb.query('name == ["jacky","dennis"]')

后续文章再详细展开数据的合并及可视化，数据的合并类似sql中的原理

到此这篇关于pandas实现数据读取&清洗&分析的项目实践的文章就介绍到这了,更多相关pandas 数据读取&清洗&分析内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！