python数据清洗处理常用语句

Avasla

已于 2023-01-10 16:13:45 修改

阅读量1.1k

点赞数 1

分类专栏： Python 文章标签： python 数据挖掘数据分析

于 2022-03-18 14:31:57 首次发布

本文链接：https://blog.csdn.net/WHYbeHERE/article/details/115512635

版权

Python 专栏收录该内容

61 篇文章 16 订阅

订阅专栏

开头常见设置

# 显示所有行/列
pd.set_option('display.max_columns', None) # 显示所有列
pd.set_option('display.max_rows', None) # 显示所有行


#设置小数点
from IPython.display import display
pd.options.display.float_format = '{:,.2f}'.format

#显示所有画图
%matplotlib inline

#不用警告
import warnings 
warnings.filterwarnings("ignore")

#中文不显示
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False

#取消科学计数法
np.set_printoptions(suppress=True)

读取

pd.read_excel(filename) # 从Excel⽂件导⼊数据

pd.DataFrame() # 自己创建数据框，用于练习

pd.read_csv(filename) # 从CSV⽂件导⼊数据

.read_table(filename) # 从限定分隔符的⽂本⽂件导⼊数据

pd.read_sql(query,connection_object) # 从SQL表/库导⼊数据

pd.read_json(json_string) # 从JSON格式的字符串导⼊数据

pd.read_html(url) # 解析URL、字符串或者HTML⽂件，抽取其中的tables表格

read_csv 读取参数

pd.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=False, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, skip_footer=0, doublequote=True, delim_whitespace=False, as_recarray=False, compact_ints=False, use_unsigned=False, low_memory=True, buffer_lines=None, memory_map=False, float_precision=None)

sep：指定分隔符，默认为逗号’,’
delimiter : str, default None 定界符，备选分隔符（如果指定该参数，则sep参数失效）
delimiter_whitespace: True or False 默认False, 用空格作为分隔符等价于spe=’\s+’如果该参数被调用，则delimite不会起作用
header：int or list of ints, default ‘infer’ 指定哪一行作为表头。默认设置为0（即第一行作为表头），如果没有表头的话，要修改参数，设置header=None
names：指定列的名称，用列表表示。一般我们没有表头，即header=None时，这个用来添加列名就很有用啦！
index_col: 指定哪一列数据作为行索引，可以是一列，也可以多列。多列的话，会看到一个分层索引
prefix: 给列名添加前缀。如prefix=“x”,会出来"x1"、“x2”、“x3”
nrows : int, default None 需要读取的行数（从文件头开始算起）
encoding: 乱码的时候用这个就是了，官网文档看看用哪个： https://docs.python.org/3/library/codecs.html#standard-encodings
skiprows : list-like or integer, default None 需要忽略的行数（从文件开始处算起），或需要跳过的行号列表（从0开始）。
squeeze: 默认为False, True的情况下返回的类型为Series
dtype: E.g. {‘a’: np.float64, ‘b’: np.int32} 指定数据类型
thousands 千分位符号，默认‘，’
decimal 小数点符号，默认‘.’

读取csv/excel指定单元格数据

一定要加header=None，否则默认第一行是标题行，会自动跳过，无法读取第一行，比如不带header=None则iloc[0,0] 会取第二行第一个单元格。

data['ACCOUNT NAME']=pd.read_excel(files,header=None).iloc[0,0] #读取第一行第一个单元格
data['ACCOUNT NO']=pd.read_excel(files,header=None).iloc[2,0]  #读取第三行第一个单元格

导出

df.to_csv(filename) #导出数据到CSV⽂件

df.to_excel(filename) #导出数据到Excel⽂件

df.to_sql(table_name,connection_object) #导出数据到SQL表

df.to_json(filename) #以Json格式导出数据到⽂本⽂件

writer=pd.ExcelWriter('test.xlsx',index=False) 

df1.to_excel(writer,sheet_name='单位')和writer.save()，将多个数据帧写⼊同⼀个⼯作簿的多个sheet(⼯作表)

查看

df.head(n) # 查看DataFrame对象的前n⾏

df.tail(n) # 查看DataFrame对象的最后n⾏

df.shape() # 查看⾏数和列数

df.info() # 查看索引、数据类型和内存信息

df.columns # 查看列名！没有括号

df.describe() # 查看数值型列的汇总统计

s.value_counts(dropna=False) # 查看Series对象的唯⼀值和计数

df.apply(pd.Series.value_counts) # 查看DataFrame对象中每⼀列的唯⼀值和计数

df.isnull().any() # 查看是否有缺失值
c_class.isnull().sum() 

c_class.duplicated().sum() #没有重复值

df[df[column_name].duplicated()] # 查看column_name字段数据重复的数据信息

df[df[column_name].duplicated()].count() # 查看column_name字段数据重复的个数

np.unique(df[column_name])#查看某列的唯一值

数据选取

df[col] # 根据列名，并以Series的形式返回列

df[[col1,col2]] # 以DataFrame形式返回多列

s.iloc[0] # 按位置选取数据

s.loc['index_one'] # 按索引选取数据

df.iloc[0,:] # 返回第⼀⾏

df.iloc[0,0] # 返回第⼀列的第⼀个元素

df.loc[0,:] # 返回第⼀⾏（索引为默认的数字时，⽤法同df.iloc），但需要注意的是loc是按索引,iloc参数只接受数字参数

df.ix[[:5],["col1","col2"]] # 返回字段为col1和col2的前5条数据，可以理解为loc和iloc的结合体。

df.at[5,"col1"] # 选择索引名称为5，字段名称为col1的数据

df.iat[5,0] # 选择索引排序为5，字段排序为0的数据

2.按条件取行

#选取等于某些值的行记录 用 ==
df.loc[df[‘column_name’] == some_value]
c_1.loc[c_1['操作记录']=='恢复课程']

#选取某列是否是某一类型的数值
df.loc[df[‘column_name’].isin(some_values)]

#多种条件的选取
# and &
# or |
# not !
df.loc[(df[‘column’] == some_value) & df[‘other_column’].isin(some_values)]

#选取不等于某些值的行记录
df.loc[df[‘column_name’] != some_value]

#isin返回一系列的数值,如果要选择不符合这个条件的数值使用~
df.loc[~df[‘column_name’].isin(some_values)]

#多条件选取
top_oceania_wines = reviews[
    (reviews.country.isin(['Australia', 'New Zealand']))
    & (reviews.points >= 95)
]

top_oceania_wines = reviews.loc[
    (reviews.country.isin(['Australia', 'New Zealand']))
    & (reviews.points >= 95)
]

#同一列不同值
data[(data.Outlet_Establishment_Year == 1987) | (data.Outlet_Establishment_Year == 1988) | (data.Outlet_Establishment_Year == 1999)]

# 在两个连续值之间
data[data.Outlet_Establishment_Year.isin([1987, 1988])]

#根据特定条件，删选指定列的内容
# Using Square brackets
# list of specific columns
select_columns = ['Item_Identifier', 'Item_MRP', 'Outlet_Establishment_Year', 'Outlet_Size']
# filter the data
data[(data.Outlet_Establishment_Year == 1987) & (data.Outlet_Size == 'High')][select_columns]

#Using loc
data.loc[(data.Outlet_Establishment_Year == 1987) & (data.Outlet_Size == 'High'), select_columns]


# 筛选特定数据类型
data.select_dtypes('object')
data.select_dtypes('int64')

数据处理

数据删除

df=df.drop(['a','b','c'],axis=1) #删除列

df.dropna() # 删除所有包含空值的⾏

df.dropna(axis=1) # 删除所有包含空值的列

df.dropna(axis=1,thresh=n) # 删除所有⼩于n个⾮空值的⾏

删除指定行

dfc=df.drop(df[df["UnitPrice"]<0].index) #删除uniprice 小于0的行

df.drop(df[df["UnitPrice"]<0].index,inplace=True) # 直接在df里删除

重命名

df.rename(columns=lambdax:x+1) # 批量更改列名

df.rename(columns={'old_name':'new_ name'}) # 选择性更改列名

df.set_index('column_one') # 将某个字段设为索引，可接受列表参数，即设置多个索引

df.reset_index("col1") # 将索引设置为col1字段，并将索引新设置为0,1,2...

df.rename(index=lambdax:x+1) # 批量重命名索引

df.columns= ['a','b','c'] # 重命名列名（需要将所有列名列出，否则会报错）

缺失值查看处理


pd.isnull() # 检查DataFrame对象中的空值，并返回⼀个Boolean数组

pd.notnull() # 检查DataFrame对象中的⾮空值，并返回⼀个Boolean数组

df.fillna(value=x) # ⽤x替换DataFrame对象中所有的空值，⽀持

df[column_name].fillna(x)

数据替换

s.replace(1,'one') # ⽤‘one’代替所有等于1的值

数据批量替换

s.replace([1,3],['one','three']) # ⽤'one'代替1，⽤'three'代替3 
s.replace([1,3],['one','three'],inplace=True) # ⽤'one'代替1，⽤'three'代替3 并改变源数据

数据格式转换

转float

s.astype(float) # 将Series中的数据类型更改为float类型

转时间格式

train.timestamp=pd.to_datetime(train.Month,format='%Y-%m')
train.index=train.timestamp
train.drop('Month',axis=1,inplace=True )
train.head()

批量格式转换

#Series to data Frame
df = pd.DataFrame(df)

# 
astype(dtype, copy=True, errors = ‘raise’, **kwargs)
#批量转换
app_train[['uid','index']] = app_train[['uid','index']].astype('int')

#string to float
df[['columnsA','columnsB','columnsC']]=df[['columnsA','columnsB','columnsC']].apply(pd.to_numeric)

df[['columnsA','columnsB','columnsC']]=df[['columnsA','columnsB','columnsC']].apply(pd.to_numeric)

#string to float 
df['columnsA'] = pd.to_numeric(df['columnsA'].apply(lambda x: re.sub(',', '.', str(x))))

https://blog.csdn.net/Python_Ai_Road/article/details/81158376?spm=1001.2101.3001.6650.3&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-3-81158376-blog-121106822.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-3-81158376-blog-121106822.pc_relevant_default&utm_relevant_index=6

筛选

df.loc[df['条件列名'] == '筛选条件'] #根据条件查看内容
df['列名'].loc[df['条件列名'] == '筛选条件']  #根据条件查看指定列的内容
df['列名'].loc[df['条件列名'] == '筛选条件'] ='替换的内容' #根据条件替换数据

数据汇总

分组，排序，透视

df.sort_index().loc[:5] # 对前5条数据进⾏索引排序

df.sort_values(col1) # 按照列col1排序数据，默认升序排列

df.sort_values(col2,ascending=False) # 按照列col1降序排列数据

df.sort_values([col1,col2],ascending=[True,False]) # 先按列col1升序排列，后按col2降序排列数据

df.groupby(col) # 返回⼀个按列col进⾏分组的Groupby对象

df.groupby([col1,col2]) # 返回⼀个按多列进⾏分组的Groupby对象

df.groupby(col1)[col2].agg(mean) # 返回按列col1进⾏分组后，列col2的均值,agg可以接受列表参数，agg([len,np.mean])

df.pivot_table(index=col1,values=[col2,col3],aggfunc={col2:max,col3:[ma,min]}) # 创建⼀个按列col1进⾏分组，计算col2的最⼤值和col3的最⼤值、最⼩值的数据透视表

df.groupby(col1).agg(np.mean) # 返回按列col1分组的所有列的均值,⽀持

df.groupby(col1).col2.agg(['min','max'])

data.apply(np.mean) # 对DataFrame中的每⼀列应⽤函数np.mean

data.apply(np.max,axis=1) # 对DataFrame中的每⼀⾏应⽤函数np.max

df.groupby(col1).col2.transform("sum") # 通常与groupby连⽤，避免索引更改

合并

df1.append(df2) # 将df2中的⾏添加到df1的尾部

df.concat([df1,df2],axis=1,join='inner') # 将df2中的列添加到df1的尾部,值为空的对应⾏与对应列都不要

df1.join(df2.set_index(col1),on=col1,how='inner') # 对df1的列和df2的列执⾏SQL形式的join，默认按照索引来进⾏合并，如果df1和df2有共同字段时，会报错，可通过设置lsuffix,rsuffix来进⾏解决，如果需要按照共同列进⾏合并，就要⽤到set_index(col1)

pd.merge(df1,df2,on='col1',how='outer') # 对df1和df2合并，按照col1，⽅式为outer

pd.merge(df1,df2,left_index=True,right_index=True,how='outer') #与 df1.join(df2, how='outer'

# 根据多列合并两个df
#!两个表中引用的连接键需要相同格式。
pd.merge(df1,df2,on=['col1','col2'],how='outer') # 对df1和df2合并，按照col1，⽅式为outer

ty['课程包'].value_counts()

j.dtypes

ty=df[[ '分业务线','用户ID','老师ID', '老师姓名', '课程包', '课程期']]

#fliter
ty=ty.loc[ty['分业务线']=='小火箭体验课分部']

#转换格式
ty['用户ID']=ty['用户ID'].astype('float')

crosstab / pivot


crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, dropna=True, normalize=False)

#crosstab的index和columns是必须要指定复制的参数：
pd.crosstab(data.key1,data.key2)

#拆分
#方法一
df['日期']=df['时间'].str.split(' ').str[0]
df['小时']=df['时间'].str.split(' ').str[1]
#方法二(用apply或map都行）
df['日期']=df['时间'].map(lambda x: x.split(' ')[0])
df['小时']=df['时间'].map(lambda x: x.split(' ')[1])

#字段分割函数： split（sep，n，expand=false）
## sep ：用于分割的字符窜
## n ：分割为多少列
## expand：是否展开为数据框，默认为false；如果为true 则返回数据框
    
newDF=df['name'].str.split('',1,true)

#命名
newDF.columns=['band','name']

pivot

#函数：
df.pivot(index= 'ID', columns='Product', values='Sales')

pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')


data.groupby(['key1','key2'])['num1'].count().unstack()

#pivot
pivot_table
(data, values=None, index=None, columns=None, 
aggfunc='mean', fill_value=None, margins=False,
 dropna=True, margins_name='All')

#默认均值
data.pivot_table(index='key1',columns='key2')

#定义一个最大值减最小值的函数
def max_min (group):
    return group.max()-group.min()
    
data.pivot_table(index='key1',columns='key2',aggfunc=max_min)

字段合并

## 合并

df1 = pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']})

df1['period'] = df[['Year', 'quarter']].apply(lambda x: ''.join(x), axis=1)
df1
    Year    quarter period
0   2014    q1  2014q1
1   2015    q2  2015q2
第二种
df2 = pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']})
df2["period"] = df["Year"].map(str) + df["quarter"]
df2
    Year    quarter period
0   2014    q1  2014q1
1   2015    q2  2015q2
第三种
 
df3 = pd.DataFrame({'Year': ['2014', '2015'], 'quarter': ['q1', 'q2']})
df3['period'] = df["Year"].str.cat(df["quarter"],sep='|')
df
 
    Year    quarter period
0   2014    q1  2014q1
1   2015    q2  2015q2
第四种
psi['as_id'] = psi['as_id'].map(lambda x :str(x))
psi['cat'] = psi['symbol'].str.cat(psi['as_id'],sep='|')
第五种
psi['cc'] = psi['symbol'] + psi['as_id']

重命名

data.rename(columns={"学号":"id",
                    "姓名":"name",
                    "年龄":"age"})
# 列名首字母大写
data.rename(str.upper,axis="column")
#columns 直接进行赋值命名,需要确保和原本column 的字段数量一致。
data.columns=["id","name","age"]

每列重新排序

order = ['date', 'time', 'open', 'high', 'low', 'close', 'volumefrom', 'volumeto']
    df = df[order]

数据清洗

#删除逗号
df['column_name'] = df['column_name'].apply(lambda x: str(x).replace(",","")) 

##删除空格
df[i] = df[i].apply(lambda x: str(x).replace(" ",""))

#批量删除空格
c=['收/支', '支付方式', '当前状态', '交易类型', '账户'] #需要批量删除的列名
for i in c: 
    df[i] = df[i].apply(lambda x: str(x).replace(" ",""))

#多个替换
t='123,.0964123'
char_to_replace = {',': '.',
                   '.': ','}
t.translate(str.maketrans(char_to_replace))

删除掉文本中的数字

string = 'abcd1234efg567'
newstring = ''.join([i for i in string if not i.isdigit()])
print(newstring)

文本分割

split()

s = 'Hi||Hello||Adios'
str_list = s.split('||')
print(str_list)

re.split（）

import re
line = 'aaa bbb ccc;ddd   eee,fff'

#单字符切割
re.split(r';',line)

#两个字符以上切割需要放在 [ ] 中
re.split(r'[;,]',line)

#使用括号捕获分组，默认保留分割符
re.split(r'([;])',line)

#不想保留分隔符，以（?:...）的形式指定
re.split(r'(?:[;])',line)