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

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  )

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)

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={})

#清除满足指定条件的行数据的表达式
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) 

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

#执行删除操作时，原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)

#语句如下，使用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

#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])

#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)

#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),以确认修改，否则实际的数据并不会有改动。

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

#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万的，加另外一个值

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

#以下主要演示对某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,',') )
 
#更多设置格式的方式，可自行了解

#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行，全列，后面的 : 也可不写

df['colname'] #直接提取指定单列标签的列数据
 
df[['A','D','E']] #指定直接提取指定多列数据，这种方法只能使用列标签进行提取
 
 
df.loc[:,'A':'C'] #使用loc方法提取A列到C列
df.iloc[:,0:2] #使用iloc方法提取第1到3列

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

#通过逻辑运算来取数据子集，查询和筛选出列值满足指定条件的行数据
#可使用 & (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']) )]

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

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

#逐个打印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])

#使用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('发现空值')

#常见统计数据值
#某列的个数、合、平均值、最大值、最小值
df['colname'].count()
df['colname'].sum()
df['colname'].mean()
df['colname'].max()
df['colname'].min()
 
 
#快速统计
#会快速展示每一列的最大、最小、平均、均方差等统计数据
df.describe()

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

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

#分组使用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)

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()#快速生成以上所有统计数据

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

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

#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

#类似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"]')