Pandas 是一个开源的 Python 库，提供了高性能、易用的数据结构和数据分析工具。它建立在 NumPy 之上，旨在使“关系”或“标签”数据的处理工作变得既简单又直观。Pandas 非常适合于进行数据分析、数据清洗和准备，以及数据可视化等任务。

虚拟变量变换

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

多个数据源的合并

df.append(
other :希望添加的 DF/Series/字典/上述对象的列表使用列表方式，就可以实现一次合并多个新对象
ignore_index = False :添加时是否忽略索引
verify_integrity = False :是否检查索引值的唯一性，有重复时报错
)

df = df.append( [df2, df3, df4])
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])
#append合并
df1.append(df2)
#多个df对象合并
df3 = make_df('AB',[5,6])
df1.append([df2,df3])
#ignore_index
df1=make_df('AB',[1,2])
df2=make_df('AB',[1,2])
df1.append(df2)
df1.append(df2,ignore_index=True)

数据的横向合并

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','k3'],'C':['C0','C1','C2','C3'],'D'['D0','D1','D2','D3'],})
result=pd.merge(left,right)
#how参数的使用
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'],})
result=pd.merge(left,right,how='left')
#left_on  right_on
left=pd.DataFrame({'key1':['k0','k1','k2','k3'],'A':['A0','A1','A2','A3'],'B'['B0','B1','B2','B3'],})
right=pd.DataFrame({'key2':['k0','k1','k2','k4'],'C':['C0','C1','C2','C3'],'D'['D0','D1','D2','D3'],})
result=pd.merge(left,right,how='left',left_on='key1',right_on='key2')
#left_index right_index
left = left.set_index(keys='key1')
right = right.set_index(keys='key2')
pd.merge(left,right,left_index=True,right_index=True)

concat 命令

同时支持横向合并与纵向合并
pd.concat(
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])

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])
pd.concat([df1,df2])

两个df对象拼接，按列进行拼接

df1=make_df('AB',[1,2])
df2=make_df('AB',[3,4])
pd.concat([df1,df2],axis=1)
#或者
pd.concat([df1,df2],axis='columns')

两个df对象拼接，如果索引重复

x=make_df('AB',[1,2])
y=make_df('AB',[1,2])
pd.concat([x,y])
#解决索引重复问题加ignore_index属性
pd.concat([x,y],ignore_index=True)
#解决索引重复问题，加keys属性
pd.concat([x,y],keys=list('xy'))

两个df对象拼接，join参数的使用

a=make_df('ABC',[1,2])
b=make_df('BCD',[3,4])
pd.concat([a,b],join='inner')
a=make_df('ABC',[1,2,3,4])
b=make_df('BCD',[3,4,5])
pd.concat([a,b],join='outer',axis=1)

处理缺失值

认识缺失值

系统默认的缺失值 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]])

缺失值查看

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

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,6,7]])
df.info()

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

检查多个单元格的取值是否为指定缺值

df.any(
axis : index (0), columns (1)
skipna = True :检查时是否忽略缺失值
level = None :多重索引时指定具体的级别
)
df.all(
axis : index (0), columns (1)
skipna = True :检查时是否忽略缺失值
level = None :多重索引时指定具体的级别
）

df=pd.DataFrame([[1,2,np.nan],[4,np.nan,6],[5,6,7]])
df.info()
#默认检测的是列值
df.isna().any()
#检测行值
df.isna().any(1)
df[df.isna().any(1)]

填充缺失值

调用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'))

数据查重

标识出重复的行

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

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 )