Python——Pandas（第三讲）

文章目录

修改替换变量值
- 对应数值的替换
- 指定数值范围的替换
虚拟变量变换
数值变量分段
数据分组
- 基于拆分进行筛选
分组汇总
- 使用 agg 函数进行汇总
- 引用自定义函数
长宽格式转换
- 转换为最简格式
- 长宽型格式的自由互转
多个数据源的合并
- 数据的横向合并
- concat 命令
处理缺失值
- 认识缺失值
- 缺失值查看
- 填充缺失值
- 删除缺失值
数据查重
- 标识出重复的行
- 直接删除重复的行

修改替换变量值

本质上是如何直接指定单元格的问题，只要能准确定位单元地址，就能够做到准确替换。

# 判断哪一行是我们要的数据 先定位再给值
df.体重[1] = 78
df['体重'][1] = 68
df.loc[1,
'体重'] = 78
df.开设.isin(['不清楚'])
df.开设[df.开设.isin(['不清楚'])] = '可以'

对应数值的替换

df.replace(
to_replace = None :将被替换的原数值，所有严格匹配的数值
将被用 value 替换，可以是 str/regex/list/dict/Series/numeric/None
value = None :希望填充的新数值
inplace = False
)

df.开设.replace('可以','不清楚',inplace = True)
df.性别.replace(['女','男'],[0,1],inplace =True)
df.性别.replace({0:'女',1:'男'},inplace =True)

指定数值范围的替换

方法一：使用正则表达式完成替换

df.replace(regex, newvalue)

方法二：使用行筛选方式完成替换
用行筛选方式得到行索引，然后用 loc 命令定位替换目前也支持直接筛选出单元格进行数值替换

# 使用正则匹配数据
df.开设.replace(regex = '不.+',value = '可以',inplace = True)
#iloc loc
df.支出.iloc[0:3] = 20
df.支出.loc[0:2] =30
#条件筛选替换
df.体重[df.体重>70] =70
df[df.体重==70].体重 = 80   # 注意引用问题
#query()的使用
df.query('性别 == "女" and 体重 > 60 ').体重 =50
df.loc[df.query('性别 == "女" and 体重 > 60').体重.index,'体重'] = 50

虚拟变量变换

pd.get_dummies(
data :希望转换的数据框/变量列
prefix = None :哑变量名称前缀
prefix_sep = 11 :前缀和序号之间的连接字符，设定有prefix 或列名时生效
dummy_na = False :是否为 NaNs 专门设定一个哑变量列
columns = None :希望转换的原始列名，如果不设定，则转换所有符合条件的列
drop_first = False :是否返回 k-l 个哑变量，而不是 k 个哑变量
）
返回值为数据框

df2.head()
pd.get_dummies(df2.类型，prefix = '_' )
pd.get_dummies(df2 ， columns= [ '类型' ])

数值变量分段

pd.cut(
X :希望逬行分段的变量列名称
bins :具体的分段设定
int :被等距等分的段数
sequence of scalars :具体的每一个分段起点，必须包括最值，可不等距
right = True :每段是否包括右侧界值
labels = None :为每个分段提供自定义标签
include_lowest = False :第一段是否包括最左侧界值，需要和right 参数配合
)

分段结果是数值类型为 Categories 的序列
pd.qcut ——按均值取值范围进行等分

#按均值取值范围进行等分
df['cut1'] = pd.qcut(df.身高,q=5)
#自定义分段
df['cut2'] = pd.cut(df.身高,bins=[150,160,170,180,190],right=False)

数据分组

df.groupby(
by :用于分组的变量名/函数
level = None :相应的轴存在多重索引时，指定用于分组的级别
as_index = True :在结果中将组标签作为索引
sort = True :结果是否按照分组关键字逬行排序
)

生成的是分组索引标记，而不是新的 df

dfg = df.groupby ('开设')
#查看dfg里面的数据
dfg.groups
#查看具体描述
dfg.describe( )
#按多列分组
dfg2 = df.groupby(['性别','开设'])
dfg2.mean ()

基于拆分进行筛选

筛选出其中一组
dfgroup.get_group()

dfg.get_group ('不必要').mean ()
dfg.get_group ('不必要').std ()

筛选出所需的列
该操作也适用于希望对不同的变量列进行不同操作时

dfg['身高'].max()

分组汇总

在使用 groupby 完成数据分组后，就可以按照需求进行分组信息汇总，此时可以使用其它专门的汇总命令，如 agg 来完成汇总操作。

使用 agg 函数进行汇总

df.aggregate( )

名称可以直接简写为 agg
可以用 axis 指定汇总维度

可以直接使用的汇总函数

名称	含义
count ()	Nuniber of non-null observations size () group sizes
sum()	Sum of values29
mean()	Mean of values
median()	Arithmetic median of values
min ()	Minimum
max()	Maximum
std()	Unbiased standard deviation
var ()	Unbiased variance
skew()	Unbiased skewness(3rd moment)
kurt()	Unbiased kurtosis (4th moment)
quantile ()	Sample quantile (value at %) apply() Generic apply
cov()	Unbiased covariance (binary)
corr()	Correlation (binary)

dfg.agg( 'count')
dfg.agg('median')
dfg.agg(['mean', 'median'])
dfg.agg(['mean', 'median'])
#引用非内置函数
import numpy as np
df2.身高.agg (np. sum)
dfg.身高.agg (np. sum)

引用自定义函数

# 使用自定义函数
def mynum(x:int) ->int:
    return x.min()
df2.身高.agg (mymean)
dfg.agg(mymean)

长宽格式转换

基于多重索引，Pandas 可以很容易地完成长型、宽型数据格式的相互转换。

转换为最简格式

df.stack(
level = -1 :需要处理的索引级别，默认为全部，int/string/list
dropna = True :是否删除为缺失值的行
)

转换后的结果可能为 Series

用法：

df =pd.read_excel('person.xlsx')
dfs = df.stack()

长宽型格式的自由互转

df.unstack(
level = -1 :需要处理的索引级别，默认为全部，int/string/list
fill_value :用于填充缺失值的数值
)

dfs.unstack (1)
dfs.unstack([0,1])

数据转置: df.T

多个数据源的合并

数据的横向合并

merge 命令使用像 SQL 的连接方式
pd.merge（
需要合并的 DF
left :需要合并的左侧 DF
right :需要合并的右侧 DF
how = ’ inner’:具体的连接类型
{left、right 、outer 、 inner、）
两个 DF 的连接方式
on :用于连接两个 DF 的关键变量（多个时为列表），必须在两侧都出现
left_on :左侧 DF 用于连接的关键变量（多个时为列表）
right_on :右侧 DF 用于连接的关键变量（多个时为列表）
left_index = False :是否将左侧 DF 的索引用于连接
right_index = False :是否将右侧 DF 的索引用于连接
)

left=pd.DataFrame({'key':['k0','k1','k2','k3'],'A':['A0','A1','A2','A3'],'B':['B0','B1','B2','B3'],})
right=pd.DataFrame({'key':['k0','k1','k2','k4'],'C':['C0','C1','C2','C3'],'D':['D0','D1','D2','D3'],})
left
'''
	key	A	B
0	k0	A0	B0
1	k1	A1	B1
2	k2	A2	B2
3	k3	A3	B3
'''
right
'''
	key	C	D
0	k0	C0	D0
1	k1	C1	D1
2	k2	C2	D2
3	k4	C3	D3
'''
# inner left right
# 内连接 只保留相同key的值
# 外连接 left 以左边的df为基准  保留所有的左边的所有同列名的值
# 全连接 outer 全连接
pd.merge(left,right,how='inner')
'''
	key	A	B	C	D
0	k0	A0	B0	C0	D0
1	k1	A1	B1	C1	D1
2	k2	A2	B2	C2	D2
'''
pd.merge(left,right,how='left')
'''
	key	A	B	C	D
0	k0	A0	B0	C0	D0
1	k1	A1	B1	C1	D1
2	k2	A2	B2	C2	D2
3	k3	A3	B3	NaN	NaN
'''
pd.merge(left,right,how='right')
'''
	key	A	B	C	D
0	k0	A0	B0	C0	D0
1	k1	A1	B1	C1	D1
2	k2	A2	B2	C2	D2
3	k4	NaN	NaN	C3	D3
'''
pd.merge(left,right,how='outer')
'''
	key	A	B	C	D
0	k0	A0	B0	C0	D0
1	k1	A1	B1	C1	D1
2	k2	A2	B2	C2	D2
3	k3	A3	B3	NaN	NaN
4	k4	NaN	NaN	C3	D3
'''

concat 命令

同时支持横向合并与纵向合并
pd.concat(
objs :需要合并的对象，列表形式提供
axis = 0 :对行还是对列方向逬行合并(0 index 、 1 columns )
join = outer :对另一个轴向的索引值如何进行处理(inner 、outer )
ignore_index = False
keys = None :为不同数据源的提供合并后的索引值
verify_integrity = False : 是否检查索引值的唯一性，有重复时报错
copy = True
)

【示例】一维的Series拼接

ser1=pd.Series([1,2,3],index=list('ABC'))
ser2=pd.Series([4,5,6],index=list('DEF'))
pd.concat([ser1,ser2])
'''
A    1
B    2
C    3
D    4
E    5
F    6
dtype: int64
'''

【示例】df对象拼接

def make_df(cols,index):
    data={c:[str(c)+str(i) for i in index] for c in cols}
    return pd.DataFrame(data,index=index)
df1=make_df('AB',[1,2])
df2=make_df('AB',[3,4])
df1
'''
    A	B
1	A1	B1
2	A2	B2
'''
df2
'''
    A	B
3	A3	B3
4	A4	B4
'''
pd.concat([df1,df2])
'''
	A	B
1	A1	B1
2	A2	B2
3	A3	B3
4	A4	B4
'''

【示例】两个df对象拼接，如果索引重复

x=make_df('AB',[1,2])
y=make_df('AB',[1,2])
x
'''
    A	B
1	A1	B1
2	A2	B2
'''
y
'''
	A	B
1	A1	B1
2	A2	B2
'''
pd.concat([x,y])
'''
	A	B
1	A1	B1
2	A2	B2
1	A1	B1
2	A2	B2
'''
pd.concat([x,y],ignore_index=True)
'''
	A	B
0	A1	B1
1	A2	B2
2	A1	B1
3	A2	B2
'''
pd.concat([x,y],keys=list('xy'))
'''
	    A	B
x	1	A1	B1
    2	A2	B2
y	1	A1	B1
    2	A2	B2
'''

【示例】两个df对象拼接，join参数的使用

a=make_df('ABC',[1,2,3,4])
b=make_df('BCD',[3,4,5])
a
'''
    A	B	C
1	A1	B1	C1
2	A2	B2	C2
3	A3	B3	C3
4	A4	B4	C4
'''
b
'''
	B	C	D
3	B3	C3	D3
4	B4	C4	D4
5	B5	C5	D5
'''
pd.concat([a,b],join='outer',axis=1)
'''
	A	B	C	B	C	D
1	A1	B1	C1	NaN	NaN	NaN
2	A2	B2	C2	NaN	NaN	NaN
3	A3	B3	C3	B3	C3	D3
4	A4	B4	C4	B4	C4	D4
5	NaN	NaN	NaN	B5	C5	D5
'''
a=make_df('ABC',[1,2])
b=make_df('BCD',[3,4])
pd.concat([a,b],join='inner')
'''
	B	C
1	B1	C1
2	B2	C2
3	B3	C3
4	B4	C4
'''

处理缺失值

在这里插入图片描述

认识缺失值

系统默认的缺失值 None 和 np. nan

data=pd.Series([3,4,np.nan,1,5,None])
df=pd.DataFrame([[1,2,None],[4,np.nan,6],[5,6,7]])
'''
	0	1	2
0	1	2.0	NaN
1	4	NaN	6.0
2	5	6.0	7.0
'''

缺失值查看

直接调用info()方法就会返回每一列的缺失情况。

df.info()
'''
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   0       3 non-null      int64  
 1   1       2 non-null      float64
 2   2       2 non-null      float64
dtypes: float64(2), int64(1)
memory usage: 200.0 bytes
'''

Pandas中缺失值用NaN表示，从用info()方法的结果来看，索引1这一列是1 2 non-null float64，表示这一列有2个非空值，而应该是3个非空值，说明这一列有1个空值。
还可以用isnull()方法来判断哪个值是缺失值，如果是缺失值则返回True，如果不是缺失值返回False。

df.isna(): 检查相应的数据是否为缺失值同 df.isnull()。
df.notna()等同于notnull()

【示例】获取所有缺失值

data=pd.Series([3,4,np.nan,1,5,None])
print('isnull()方法判断是否是缺值：')
print(data.isnull())
print(data.isna())
print('获取缺值：')
print(data[data.isnull()])
print('获取非空值')
print(data[data.notnull()])

填充缺失值

调用fillna()方法对数据表中的所有缺失值进行填充，在fillna()方法
中输入要填充的值。还可以通过method参数使用前一个数和后一
个数来进行填充。
df.fillna(
value :用于填充缺失值的数值，也可以提供dict/Series/DataFrame 以进—步指明
哪些索引/列会被替换不能使用 list
method = None :有索引时具体的填充方法，向前填充，向后填充等
limit = None :指定了 method 后设定具体的最大填充步长，此步长不能填充
axis : index (0), columns (1)
inplace = False
)
【示例】Series对象缺失值填充

data=pd.Series([3,4,np.nan,1,5,None])
print('以0进行填充:')
print(data.fillna(0))
print('以前一个数进行填充:')
print(data.fillna(method='ffill'))
print('以后一个数进行填充:')
print(data.fillna(method='bfill'))
print('先按前一个，再按后一个')
print(data.fillna(method='bfill').fillna(method='ffill'))

【示例】DataFrame对象缺失值填充

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],
[5,6,7]])
print('使用数值0来填充：')
print(df.fillna(0))
print('使用行的前一个数来填充：')
print(df.fillna(method='ffill'))
print('使用列的后一个数来填充：')
print(df.fillna(method='bfill' ,axis=1))

【示例】列的平均值来填充

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],
[5,6,7]])
for i in df.columns:
    df[i]=df[i].fillna(np.nanmean(df[i]))
df

删除缺失值

调用dropna()方法删除缺失值，dropna()方法默认删除含有缺失值的行，也就是只要某一行有缺失值就把这一行删除。如果想按列为单位删除缺失值，需要传入参数axis=’columns’。
df.dropna(
axis = 0 : index (0), columns (1)
how = any : any、all
any :任何一个为 NA 就删除
all :所有的都是 NA 删除
thresh = None :删除的数量阈值，int
subset :希望在处理中包括的行/列子集
inplace = False
)

【示例】删除缺失值

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,6,7]])
print('默认为以行为单位剔除:')
print(df.dropna())
print('以列为单位剔除:')
df.dropna(axis='columns')

【示例】删除空白行

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,6,7]])
print('所有为nan时候才剔除:')
print(df.dropna(how='all'))
print('默认情况，只要有就剔除')
print(df.dropna(how='any'))

数据查重

标识出重复的行

标识出重复行的意义在于进一步检査重复原因，以便将可能的错误数据加以修改。

Duplicated

df['dup' ] = df.duplicated( ['课程','开设'])

利用索引进行重复行标识
df.index.duplicated()

df2 = df.set_index ( ['课程','开设'] )
df2.index.duplicated ()

直接删除重复的行

drop_duplicates (
subset=“ ”按照指定的行逬行去重
keep=‘first’ 、 ‘last’ 、 False 是否直接删除有重复的所有记录
)

df. drop_duplicates ( ['课程', '开设' ] )
df. drop_duplicates ( ['课程', '开设' ] , keep= False )

利用査重标识结果直接删除
df[~df.duplicated( )]

df[~df . duplicated ( ['课程', '开设' ] )]