pandas的高级使用

关注

原创最新推荐文章于 2026-07-21 18:45:22 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

第12章 pandas高级应用和其它许多开源项目一样，pandas仍然在不断的变化和进步中。和本书中其它地方一样，这里的重点是放在接下来几年不会发生什么改变且稳定的功能。为了深入学习pandas的知识，我建议你学习官方文档，并阅读开发团队发布的文档更新。我们还邀请你加入pandas的开发工作：修改bug、创建新功能、完善文档。阅读详情

pandas层次化索引

导入三剑客包

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

读取外部excel文件

# header 设置为列表，表示第0、1两行同时作为多层级索引读取
pd.read_excel('datas.xlsx', sheet_name=0, header=[0,1])

1. 创建多层列索引

隐式构造

最常见的方法是给DataFrame构造函数的index参数传递两个或更多的数组

array_ = [["一季度","一季度","一季度","二季度","二季度","二季度"],["A产品","B产品","C产品","A产品","B产品","C产品"]]

#Series创建多层索引
data1 = np.random.randint(0,100,size=6)
DataFrame(Series(data=data1, index=array_))	==>
		0
一季度	A产品	43
	B产品	93
	C产品	82
二季度	A产品	79
	B产品	57
	C产品	51

#DataFrame创建多层索引
data = np.random.randint(0,100,size=(3,6))
index = ["小张","小王","小李"]
 隐式构造，可以直接使用一个array的表达方式类设置多层级索引
df = DataFrame(data=data, index=index, columns=array_)
df	==>
	一季度	二季度
A产品	B产品	C产品	A产品	B产品	C产品
小张	59	40	7	25	91	21
小王	5	70	62	48	42	84
小李	63	4	96	31	85	50

显式构造使用pd.MultiIndex

#三种方式
1、使用数组
array_ = [["一季度","一季度","一季度","二季度","二季度","二季度"],["A产品","B产品","C产品","A产品","B产品","C产品"]]
columns1 = `pd.MultiIndex.from_arrays`(array_)
DataFrame(data=data, index=index, columns=columns1)

2、使用元组
tuple_ = [["一季度","A产品"],["一季度","B产品"],["一季度","C产品"],["二季度","A产品"],["二季度","B产品"],["二季度","C产品"]]
columns2 = `pd.MultiIndex.from_tuples`(tuple_)
DataFrame(data=data, index=index, columns=columns2)

3、使用全排列product
product_ = [["一季度","二季度"],["A产品","B产品","C产品"]]
columns3 = pd.MultiIndex.from_product(product_)
DataFrame(data=data, index=index, columns=columns3)

2. 创建多层行索引

除了列索引columns，行索引index也能用同样的方法创建多层索引

data = data.reshape((6,2))
df1 = DataFrame(data=data, index=columns, columns=index)	==>
张三	李四
期中	python	96	42
java	90	97
PHP	26	32
期末	python	50	67
java	35	23
PHP	93	99

3. 多层索引对象的索引与切片操作

Series的操作

对于Series来说，直接中括号[]与使用.loc()完全一样，推荐使用.loc中括号索引和切片。

索引

s[一级索引，二级索引]
s.loc[一级索引，二级索引]
切片
- 变成单级索引切片
- 使用隐式索引切片
- 利用stack、unstack变型之后再切

#索引
s1 ==>
期中  python    26
    java      63
    PHP       85
期末  python    85
    java      80
    PHP       45
Name: 张三, dtype: int32
s1["期中","python"]
s1.loc["期中","python"]	==>26

#切片
s1["期中"]["python":"PHP"]
python    26
java      63
PHP       85
Name: 张三, dtype: int32

DataFrame的操作

隐式访问与切片

df  ==>
	期中	期末
python	java	PHP	python	java	PHP
张三	99	13	68	64	3	15
李四	58	13	91	75	17	49
#访问
df.iloc[1,4]	==> 17
#切片
df.iloc[:,2:4] 	==>
	期中	期末
PHP	python
张三	68	64
李四	91	75

显式访问与切片

df1 ==>

		张三	李四	王五
期中	python	99	13	15
	java	68	64	71
	PHP	3	15	34
期末	python	58	13	4
	java	91	75	61
	PHP	17	49	42
    
  #访问并赋值
df2 = df1.copy()
#变成单机索引（拷贝副本不改变原表的值）
temp = df2.loc["期中"].copy()	==>
	张三	李四	王五
python	99	13	15
java	68	64	71
PHP	3	15	34
#赋值
temp.loc["python","张三"] = 0
#将副本的值赋给单级索引
df2.loc["期中"] = temp.values

行多级索引的索引和切片操作
- 访问行 df.loc[一级行索引，二级行索引]
- 访问元素 df.loc[(一级行索引，二级行索引)，列索引]

df1 ==>
		张三	李四	王五
期中	python	99	13	15
	java	68	64	71
	PHP	3	15	34
期末	python	58	13	4
	java	91	75	61
	PHP	17	49	42
# 访问行
df1.loc["期中","python"]
# 访问元素
# ("期中","python") 可以用来访问元素，但是不能用来切片
df1.loc[("期中","python"),"张三"]

列多级索引的索引和切片操作
- . 访问列 df[一级索引，二级索引]
- 访问元素 df.loc[行索引，(一级列索引，二级列索引)]

df  ==>
	期中			期末
	python	java PHP python	java PHP
张三	96	42	90	97	26	32
李四	50	67	35	23	93	99
#元素访问
df.loc["张三",("期中","python")]  ==>96

4、索引的堆（stack）

tack() 列索引变行索引

【使用技巧】使用stack()的时候，level等于哪一个，哪一个就消失，出现在行里
格式：df.stack(level=-1, dropna=True)
- level :# level 表示层级从外向内依次0123… ,从内到内依次-1，-2，-3…
使用

df   ==>
	期中	期末
python	java	PHP	python	java	PHP
张三	99	13	68	64	3	15
李四	58	13	91	75	17	49

# level=1  和 level=-1效果一样
df.stack(level=1)	==>
		期中	期末
张三	PHP	68	15
	java	13	3
	python	99	64
李四	PHP	91	49
	java	13	17
	python	58	75
    
  #level=0 和 level=-2效果一样
df3 = df.stack(level=0)
		PHP	java	python
张三	期中	68	13	99
	期末	15	3	64
李四	期中	91	13	58
	期末	49	17	75

unstack() 行索引变列索引

使用unstack()的时候，level等于哪一个，哪一个就消失，出现在列里。

#level=0
df3.unstack(level=0)	==>

	PHP	java	python
张三	李四	张三	李四	张三	李四
期中	90	35	42	67	96	50
期末	32	99	26	93	0	23

二者结合使用

df  ==>
	期中	期末
python	java	PHP	python	java	PHP
张三	96	42	90	0	26	32
李四	50	67	35	23	93	99
#列变行 行变列
df.stack(level=0).unstack(level=0)	==>
	PHP	java	python
张三	李四	张三	李四	张三	李四
期中	68	91	13	13	99	58
期末	15	49	3	17	64	75

df.stack(level=1).unstack(level=0)
	期中	期末
张三	李四	张三	李四
PHP	68	91	15	49
java	13	13	3	17
python	99	58	64	75

5、聚合操作

所谓的聚合操作：平均数，方差，最大值，最小值……

和numpy的区别
- DataFrame的聚合，默认是列方向的聚合，可以指定axis来改变。计算的时候假如列表中有NaN时，默认当做0计算
  
  score.sum()
  
  score.sum(axis=1)
- numpy默认是对整个数组聚合，假如求和的数组中有nan时，只能用np.nansum（arr）来处理数组中有nan的情况
  
  np.nansum(arr)

pandas的拼接操作

级联：pd.concat, pd.append

先定义一个生成DataFrame的函数：

# :
def make_DataFrame(index, columns):
    all_data = []
    for idx in index:
        row_data = []
        for col in columns:
            row_data.append(col + idx)
        all_data.append(row_data)
    return DataFrame(data=all_data, index=index, columns=columns)

#简易写法
def make_df(index, columns):
    return DataFrame({i:[i+str(j) for j in index] for i in columns}, index=index)

使用pd.concat()级联

pandas级联考虑索引, 索引对齐原则，对不齐补，numpy级联，只考虑数值

pandas使用pd.concat函数，与np.concatenate函数类似，只是多了一些参数：

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)
#
objs	df元组
axis=0	axis控制级联方向，axis=0横向
join='outer'	参数有outer(外联)、inner（内联）
join_axes=None	指定以某个索引进行级联，通常和axis一起使用
ignore_index=False	如果索引没什么实际意义 ignore_index
keys		如果想保留原始标签，可以使用keys参数，来设置多层级索引表格。一般情况下：ignore_index对行索引重新排列，keys对列索引进行分区

参数的简单使用

df1 = make_DataFrame(index=list("1234"),columns=list("ABCD"))
df2 = make_DataFrame(index=list("2345"), columns=list("ABCD"))
#numpy级联，只考虑数值
np.concatenate((df1.values, df2.values))	==>
array([['A1', 'B1', 'C1', 'D1'],
       ['A2', 'B2', 'C2', 'D2'],
       ['A3', 'B3', 'C3', 'D3'],
       ['A4', 'B4', 'C4', 'D4'],
       ['A2', 'B2', 'C2', 'D2'],
       ['A3', 'B3', 'C3', 'D3'],
       ['A4', 'B4', 'C4', 'D4'],
       ['A5', 'B5', 'C5', 'D5']], dtype=object)
#pandas级联
pd.concat((df1, df2),axis=1)

	A	B	C	D	A	B	C	D
1	A1	B1	C1	D1	NaN	NaN	NaN	NaN
2	A2	B2	C2	D2	A2	B2	C2	D2
3	A3	B3	C3	D3	A3	B3	C3	D3
4	A4	B4	C4	D4	A4	B4	C4	D4
5	NaN	NaN	NaN	NaN	A5	B5	C5	D5
#外连接取并集
df5 = make_DataFrame(index=list("123"), columns=list("BCE"))
pd.concat((df1,df5), join="outer", axis=1) ==>
	A	B	C	D	B	C	E
1	A1	B1	C1	D1	B1	C1	E1
2	A2	B2	C2	D2	B2	C2	E2
3	A3	B3	C3	D3	B3	C3	E3
4	A4	B4	C4	D4	NaN	NaN	NaN

# 内联取交集
pd.concat((df1,df5), join="inner", axis=1)
	A	B	C	D	B	C	E
1	A1	B1	C1	D1	B1	C1	E1
2	A2	B2	C2	D2	B2	C2	E2
3	A3	B3	C3	D3	B3	C3	E3

#指定B和C列进行级联
pd.concat((df1,df5), join_axes=[pd.Index(["B","C"])])
	B	C
1	B1	C1
2	B2	C2
3	B3	C3
4	B4	C4
1	B1	C1
2	B2	C2
3	B3	C3

#横向级联，以2和3行为基准
pd.concat((df1, df5), join_axes=[pd.Index(["2","3"])], axis=1)
	A	B	C	D	B	C	E
2	A2	B2	C2	D2	B2	C2	E2
3	A3	B3	C3	D3	B3	C3	E3

#左连接
pd.concat((df1, df5), join_axes=[df1.columns])
A	B	C	D
1	A1	B1	C1	D1
2	A2	B2	C2	D2
3	A3	B3	C3	D3
4	A4	B4	C4	D4
1	NaN	B1	C1	NaN
2	NaN	B2	C2	NaN
3	NaN	B3	C3	NaN

#右连接
pd.concat((df1, df5), join_axes=[df5.columns])
	B	C	E
1	B1	C1	NaN
2	B2	C2	NaN
3	B3	C3	NaN
4	B4	C4	NaN
1	B1	C1	E1
2	B2	C2	E2
3	B3	C3	E3

# 如果索引没什么实际意义 ignore_index
pd.concat((df1, df3), ignore_index=True)
	0	1	2	3	4	5	6
1	A1	B1	C1	D1	B1	C1	E1
2	A2	B2	C2	D2	B2	C2	E2
3	A3	B3	C3	D3	B3	C3	E3
4	A4	B4	C4	D4	NaN	NaN	NaN

# 如果想保留原始标签，可以使用keys参数，来设置多层级索引表格
# 一般情况下：ignore_index对行索引重新排列
#             keys对列索引进行分区
pd.concat((df1, df3), axis=1, keys=["上学期","下学期"])
	上学期		下学期
	A	B	C	D	B	C	E
1	A1	B1	C1	D1	B1	C1	E1
2	A2	B2	C2	D2	B2	C2	E2
3	A3	B3	C3	D3	B3	C3	E3
4	A4	B4	C4	D4	NaN	NaN	NaN

使用append()函数添加
- 格式： df.append(other, ignore_index=False, verify_integrity=False)

注意:append函数只是沿着axis=0的方向进行级联

# df ==>	
	python	JAVA	c
李四	49	45	39
王老五	33	24	54
赵小六	37	57	95
df1 =DataFrame(data=np.random.randint(0,100,size=(1,3)),index=["张三"], columns=df.columns)
#
df.append(df1)
	python	JAVA	c
李四	49	45	39
王老五	33	24	54
赵小六	37	57	95
张三	58	59	6

合并：pd.merge, pd.join

merge与concat的区别在于，merge需要依据某一共同【列】来进行合并
使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。

注意:每一列元素的顺序不要求一致
merge()的要求：
- 以【列】（内容）合并参考项
- 内容【必须】是散列值（离散型）
- 参与合并参考的列必须要满足一对一、一对多、多对多关系中一种
格式：pd.merge(left, right, how=‘inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=(’_x’, ‘_y’), copy=True, indicator=False)


#读取外部文件数据
index_col = [0] 设置第一列为作为行索引读取
header = [0] 设置第一行为列索引读取
【注意】版本不同，要确认参数名称是否有变化 比如sheet_name\sheetname

tb1 = pd.read_excel('data/关系表.xlsx',sheetname=1)

tb2 = pd.read_excel('data/关系表.xlsx',sheetname=2)

tb3 = pd.read_excel('data/关系表.xlsx',sheetname=3)

tb4 = pd.read_excel('data/关系表.xlsx',sheetname=4)

#各个标的数据
td1  ==>
	手机型号	参考价格
0	windowsPhone	2500
1	iPhone	7500
2	Android	4000
td2   ==>
	手机型号	重量
0	windowsPhone	0.50
1	iPhone	0.40
2	Android	0.45
3	other	0.60

tb3		==>
	经销商	发货地区	手机型号
0	dancer	beijing	iPhone
1	lucy	beijing	Android
2	tom	guangzhou	iPhone
3	petter	shenzhen	windowsPhone
4	mery	guangzhou	Android


tb4 	==>		
	发货地区	手机型号	价格
0	beijing	iPhone	7000
1	beijing	windowsPhone	2300
2	beijing	Android	3600
3	guangzhou	iPhone	7600
4	guangzhou	windowsPhone	2800
5	guangzhou	Android	4200
6	shenzhen	iPhone	7400
7	shenzhen	windowsPhone	2750
8	shenzhen	Android	3900

代码实现

 #默认会把相同的列标签的列作为合并参考，进行合并
  #如果存在多个列都可以合并，则同时以多列作为合并参考
pd.merge(tb1, tb2)		==>
手机型号	参考价格	重量
0	windowsPhone	2500	0.50
1	iPhone	7500	0.40
2	Android	4000	0.45

#how inner 取交集
#     outer 取并集 如果存在不同项目，以NaN填充
#     left  以left参数指定的表为准   
#     right 以right参数指定的表为准
pd.merge(tb1, tb2, how="right")		==>
手机型号	参考价格	重量
0	windowsPhone	2500.0	0.50
1	iPhone	7500.0	0.40
2	Android	4000.0	0.45
3	other	NaN	0.60

#使用on=显式指定哪一列为key,当有多个key相同时使用
#suffixes 当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名
可以使用suffixes=自己指定后缀
pd.merge(tb3, tb4, on="手机型号", suffixes=["_上半年","_下半年"])		==>
经销商	发货地区_上半年	手机型号	发货地区_下半年	价格
0	dancer	beijing	iPhone	beijing	7000
1	dancer	beijing	iPhone	guangzhou	7600


#这里把表5的数据的列索引改为‘型号’再和表一进行合并
tb5 = tb2.copy()
tb5.columns = ["型号","重量"]
# left_on right_on 用于当合并的列名称不一样时，可以分别指定参考的列的列标签
pd.merge(tb1, tb5, left_on="手机型号", right_on="型号").drop(labels=["型号"],axis=1)	==>
手机型号	参考价格	重量
0	windowsPhone	2500	0.50
1	iPhone	7500	0.40
2	Android	4000	0.45

#set_index 把某一列设置为DataFrame的行索引
tb6 = tb5.copy()
tb6 = tb6.set_index("型号")	==>
		重量
型号	
windowsPhone	0.50
iPhone	0.40
Android	0.45
other	0.60
#right_index 指定右表的行索引为合并列的标签
pd.merge(tb1, tb6, left_on="手机型号", right_index=True)

pd.merge(tb6, tb1, left_index=True, right_on="手机型号")

案例分析：美国各州人口数据分析

读取数据

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
#表一
abb = pd.read_csv('data/state-abbrevs.csv')
abb.head()		===>
state	abbreviation
0	Alabama	AL
1	Alaska	AK
2	Arizona	AZ
3	Arkansas	AR
4	California	CA

#表二
area = pd.read_csv('data/state-areas.csv')
area.head()	==>
	state	area (sq. mi)
0	Alabama	52423
1	Alaska	656425
2	Arizona	114006
3	Arkansas	53182
4	California	163707

#表三
pop = pd.read_csv('data/state-population.csv')
pop.head()
state/region	ages	year	population
0	AL	under18	2012	1117489.0
1	AL	total	2012	4817528.0
2	AL	under18	2010	1130966.0
3	AL	total	2010	4785570.0
4	AL	under18	2011	1125763.0

合并pop与abbrevs两个DataFrame，分别依据state/region列和abbreviation列来合并。为了保留所有信息，使用外合并。

pop_abb = pd.merge(pop, abb, how="outer", left_on="state/region", right_on="abbreviation")
pop_abb.head()		表一和表三合并 ==>
	state/region	ages	year	population	state	abbreviation
0	AL	under18	2012	1117489.0	Alabama	AL
1	AL	total	2012	4817528.0	Alabama	AL
2	AL	under18	2010	1130966.0	Alabama	AL
3	AL	total	2010	4785570.0	Alabama	AL
4	AL	under18	2011	1125763.0	Alabama	AL
## 对比pop_abb表中，相同的两列的信息是否一致
pop_abb["state/region"].unique()
pop_abb["abbreviation"].unique()
# 2. 查看不同的信息出现的次数
pop_abb["state/region"].value_counts()
pop_abb["abbreviation"].value_counts()

# 可以使用info函数，查看一个DataFrame的整体信息
pop_abb.info()

#经过比较决定去除abbreviation的那一列（axis=1）
# 删除一列，改变输入的内存，注意不要多次运行，只运行一次
pop_abb.drop(labels="abbreviation",axis=1, inplace=True)

使用.isnull().any()，只有某一列存在一个缺失数据，就会显示True。

#获取行bool_list 用来过滤缺失值
bool_list = pop_abb.isnull().any(axis=1)
empty_df = pop_abb.loc[bool_list]	==>
	state/region	ages	year	population	state	abbreviation
2448	PR	under18	1990	NaN	NaN	NaN
2449	PR	total	1990	NaN	NaN	NaN
2450	PR	total	1991	NaN	NaN	NaN
2451	PR	under18	1991	NaN	NaN	NaN
2452	PR	total	1993	NaN	NaN	NaN
#找到有哪些state/region使得state的值为NaN，使用unique()查看非重复值
# 如果返回的是True，说明该列都是空置
empty_df["state"].isnull().all()
empty_df["state/region"].unique()
PR_COND = pop_abb["state/region"] == "PR"
USA_COND = pop_abb["state/region"] == "USA"
#给PR州赋值 
pop_abb.loc[PR_COND,"state"] = "Puerto Rico"
pop_abb.loc[USA_COND,"state"] = "USA"

#检测列方向是否还有空值
pop_abb.isnull().any()		==>
state/region    False
ages            False
year            False
population       True	#为空的行删除
state           False
abbreviation     True
dtype: bool
#检测人口空值 
pop_abb.loc[pop_abb.isnull().any(axis=1)] 

#检测表2和pop_abb表的不同
area["state"].size	==>52
pop_abb["state/region"].unique().size	==>53
#左联两个表
total = pd.merge(pop_abb, area, how="left")
# 先查看列是否存在缺失
total.isnull().any()
# 查找包含空值的行
total.loc[total.isnull().any(axis=1)]
# 获取所有包含空值的行索引
drop_index = total.loc[total.isnull().any(axis=1)].index
# 删除包含空值的行
total.drop(labels=drop_index, axis=0, inplace=True)
total.isnull().any()	#此时总表里没有空值

找出2010年的全民人口数据,对查询结果进行处理，以state列作为新的行索引:set_index ，计算人口密度。注意是Series/Series，其结果还是一个Series。排序，并找出人口密度最高的五个州sort_values()

#常规做法
year_conditon = total["year"] == 2010
total_2010 = total.loc[year_conditon]
total_2010_result = total_2010.loc[total_2010["ages"] == "total"]
#把州名设置为行索引
total_2010_result.set_index("state",inplace=True)


#使用query语句简化版，query直接接收一个字符串表达式  多个条件使用&连接 
rest1 = total_2010.query('year == 2010 & ages == "total"').set_index("state")
#计算人口密度
ret1 = rest1["population"]/rest1["area (sq. mi)"]

#绘直方图
import matplotlib.pyplot as plt
%matplotlib inline
plt.figure(figsize=(24,8))
ret1.plot(kind="bar")


#排序，并找出人口密度最高的五个州sort_values()
#ascending 默认为升序,改为降序切片取前五个
ret3 = ret1.sort_values(ascending=False)[:5]
ret3.plot(kind="bar")

pandas 数据处理

1.删除数据

删除数据三个方式
- drop(labels, axis) 删除指定的行或列
- dropna(axis, how) 删除包含空值的一行或一列
- drop_duplicated() 删除重复的行
使用duplicated()函数查看重复的行

使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True

格式： df.duplicated(subset=None, keep=‘first’)
- 默认把第一次出现的值保留 keep=“first”
- 保留最后一次出现的 keep=“last”

condition = df.duplicated(keep="last")  ==>
0     True
1    False
2     True
3    False
4    False
5     True
6    False
7    False
dtype: bool
#利用condition过滤出行索引
df.loc[condition].index			==>
Int64Index([0, 2, 5], dtype='int64')
#删除相同的数据
df.drop(labels=df.loc[condition].index)

使用drop_duplicates()函数删除重复的行
- 格式：df.drop_duplicates(subset=None, keep=‘first’, inplace=False)
  - inplace 直接改变df，只能使用一次

# 如果需要对级联后的表进行去重， 最好把索引进行重排操作
df3 = pd.concat((df,df), ignore_index=True)
df3.drop_duplicates()		==>
	name	语文	数学	英语
0	王伟	67	76	65
1	张小凡	87	54	87
2	陆雪琪	56	98	67
3	黎明	56	67	65
4	碧瑶	54	56	90

2、映射

映射的含义：创建一个映射关系列表，把values元素和一个特定的标签或者字符串绑定，包含三种操作：

replace()函数：替换元素（DataFrame\Series的函数)
最重要：map()函数：新建一列(Series的函数)
rename()函数：替换索引(DataFrame的函数)

1) replace()函数：替换元素

格式

df.replace(to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad', axis=None)
method：对指定的值使用相邻的值填充
limit：设定填充次数

DataFrame操作

df			==>
	A	B	C	D	E
0	lucy	65	43.0	6.836381	22.0
1	mery	57	NaN	NaN	85.0
2	tom	66	80.0	2.858967	11.0
3	jack	42	66.0	8.044660	NaN
4	rose	79	17.0	0.047589	31.0

# 单值替换
df.replace(to_replace="lucy", value="魏淑芬")
# 列表替换
df.replace(to_replace=["lucy","mery",np.nan], value=["魏淑芬","王可",0])
# 字典替换
# 1. 要替换的值，字典里没有 , 默认保留原始值
# 2. 字典里存在的值，在要替换的 值里没有， 所以，根据以上的特征，我们可以直接维护一个字典，对所有的表进行替换
df.replace(to_replace={
    "lucy":"魏淑芬",
    "mery":"王小可",
    "noname":"不知道"
})

Series替换操作
- 单值替换
  - 普通替换
  - 字典替换
- 多值替换
  - 列表替换
  - 字典替换（推荐）

2) map()函数：新建一列

s.map(arg, na_action=None)

map函数并不是DataFrame的函数，而是Series的函数, 所以map函数主要用于某一列数据的映射处理

注意

map()中不能使用sum之类的函数，for循环
map(字典) 字典的键要足以匹配所有的数据，否则出现NaN

map函数可以接收如下三种值:

字典一般用于处理离散型数据
lambda 表达式可以处理离散型和连续型数据
function 自定义函数

df     ===>
	name	语文	数学	英语
0	王伟	67	76	65
1	张小凡	87	54	87
2	陆雪琪	56	98	67
3	黎明	56	67	65
4	碧瑶	54	56	90


#接收字典
map_dic = {
    "黎明":"Tom",
    "碧瑶":"Green",
    "陆雪琪":"Rose",
    "王伟":"Jery",
    "张小凡":"Lucy",
    "张学友":"Friend"
}
# 新增一列
df["english_name"] = df["name"].map(map_dic)
# 修改一列
df["name"] = df["name"].map(map_dic)

#1. 字典里面的键值对如果多于要映射的列的数据,可以维护一个大字典，对多列数据进行映射处理
df["name"].map(map_dic)
# 2. 字典里面的键值对少于要映射的列的数据, 没有对应映射数据将会返回一个NaN，可以使用函数，如果字典里有对应的映射值就返回映射至，否则返回原始值
map_dic = {
    "黎明":"Tom",
    "碧瑶":"Green"
}
df["name"].map(map_dic)


#接收函数
def function1(x):
    return map_dic.get(x,x)
df["name"].map(function1)
def map_score(x):
    if x >=90:
        return "A"
    elif x>=80:
        return "B"
    elif x >= 70:
        return "C"
    elif x >= 60:
        return "D"
    else:
        return "E"
  df["语文"] = df["语文"].map(map_score)


# lambda 函数
df["英语"].map(lambda x:x-10)

3）transform()和map()类似

格式

 s.transform(func, *args, **kwargs)

4) rename()函数：替换索引

df.rename(index=None, columns=None, **kwargs)

仍然是新建一个字典,使用rename()函数替换行索引

mapper 替换所有索引
index 替换行索引
columns 替换列索引
level 指定多维索引的维度

#原数据
df	==>
name	语文	数学	英语	english_name
0	王伟	67	76	65	Jery
1	张小凡	87	54	87	Lucy
2	陆雪琪	56	98	67	Rose
3	黎明	56	67	65	Tom
4	碧瑶	54	56	90	Green

# 改变列索引
df.rename(columns={
    "name":"姓名"
})

#改变行索引
df.rename(index={
    0:"first"
})

#mapper用于指定替换行和列索引的字典,axis用于指定替换的是行索引还是列索引
df.rename(mapper={
    0:"first",
    "name":"姓名"
},axis=1)

# level 用于指定多层级索引的替换层级
df1 = pd.concat((df, df), axis=1, keys=["上学期","下学期"])
df1.rename(mapper={
    "上学期":"第一学期",
    "name":"姓名"
}, axis=1, level=1)

3. 使用聚合操作对数据异常值检测和过滤

异常值界定不同业务有不同的标准

假设某一个数据的绝对值 > 3*该列的标准差就被认定为异常数据

df = DataFrame(data = np.random.randn(10000,3), columns=list("ABC"))

# describe() 函数查看数据集的基本数学指标
df.describe()		==>
	A	B	C
count	10000.000000	10000.000000	10000.000000
mean	-0.002205	-0.002600	-0.000615
std	1.010709	1.000173	1.013830
min	-4.053966	-4.535207	-3.455074
25%	-0.684367	-0.690652	-0.688193
50%	-0.009133	0.000911	0.014746
75%	0.675410	0.675980	0.695004
max	3.808636	3.865321	4.074260
#最大值
df["A"].max()
#标准差	#接近1,使用std()函数可以求得DataFrame对象每一列的标准差
df["A"].std()
# 确定异常值的检测条件
condition = np.abs(df) > 3*df.std() 		==>
	A	B	C
0	False	False	False
1	False	False	False
2	False	False	False
''''''
# 获取满足条件的行
bool_list = condition.any(axis=1)
# 获取满足条件的行的索引
drop_index = df[bool_list].index
# 根据满足条件的行的索引，删除行
df.drop(labels=drop_index)

4、排序

使用.take()函数排序：f.take(indices, axis=0, convert=True, is_copy=True, **kwargs)
- take()函数接受一个索引列表，用数字表示
- eg:df.take([1,3,4,2,5])

可以借助np.random.permutation()函数随机排序

df = DataFrame(data=np.random.randint(0,10,size=(5,5)), columns=list("ABCDE"))
	A	B	C	D	E
0	2	2	6	4	1
1	7	1	6	7	7
2	2	5	4	1	7
3	3	0	1	2	9
4	9	0	5	7	5
#列方向取
df.take([0,1,0,1],axis=1)	==>

A	B	A	B
0	2	2	2	2
1	7	1	7	1
2	2	5	2	5
3	3	0	3	0
4	9	0	9	0

# 使用permutation函数随机生成数组
np.random.permutation(5)		生成随机排序数组==>
array([0, 1, 2, 4, 3])
df.take(np.random.permutation(5),axis=1)
##
df.take(indices,axis)
np.random.permutation()  # 随机排序
np.random.randint()      # 随机抽样

5. 数据分类处理【重点】

数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。

数据分类处理：

分组：先把数据分为几组
用函数处理：为不同组的数据应用不同的函数以转换数据
合并：把不同组得到的结果合并起来

数据分类处理的核心：

 groupby()函数
  groups属性查看分组情况

根据item分组,查看结果

总结：数据类型是离散的可以分组，连续的没有意义

获取weight的总和
把总和跟df进行merge合并
使用列表进行多列分组，得到的结果是多层级索引

df = pd.read_excel('cai.xlsx')
	item	color	price	weight
0	萝卜	红	0.5	50
1	白菜	白	0.3	30
2	白菜	青	1.0	16
3	萝卜	青	1.0	32
4	辣椒	青	2.0	36
5	白菜	红	3.0	18
6	冬瓜	青	1.5	29
7	辣椒	红	4.0	18
8	辣椒	黄	0.5	19
9	冬瓜	白	2.0	23

# 分组 根据item列进行分组
ret = df.groupby("item")		==>
<pandas.core.groupby.DataFrameGroupBy object at 0x000000000A6FA390>

# 查看分组情况
ret.groups	==>
{'冬瓜': Int64Index([6, 9], dtype='int64'),
 '白菜': Int64Index([1, 2, 5], dtype='int64'),
 '萝卜': Int64Index([0, 3], dtype='int64'),
 '辣椒': Int64Index([4, 7, 8], dtype='int64')}

# 查看不同菜品的总重量
# 可以直接对分组对象做聚合操作
ret.sum()["weight"]
item
冬瓜    52
白菜    64
萝卜    82
辣椒    73
Name: weight, dtype: int64
#每种蔬菜均价
ret.mean()["price"]    
item
冬瓜    1.750000
白菜    1.433333
萝卜    0.750000
辣椒    2.166667
Name: price, dtype: float64
# 聚合之前，先确认要聚合的列是否能运算
df.dtypes
# 同时查看价格的平均值和重量的总和
ret.agg({"price":"mean", "weight":"sum"})

# 多层级索引分组，可以用于查看两个列之间的对应关系
df.groupby(["color","item"]).sum()["weight"]
df.groupby(["item","color"]).sum()["weight"]
item  color
冬瓜    白        23
      青        29
白菜    白        30
      红        18
      青        16
萝卜    红        50
      青        32
辣椒    红        18
      青        36
      黄        19
Name: weight, dtype: int64

6.0 高级数据聚合

使用groupby分组后，也可以使用transform和apply提供自定义函数实现更多的运算

df.groupby(‘item’)[‘price’].sum() <==> df.groupby(‘item’)[‘price’].apply(sum)
transform和apply都会进行运算，在transform或者apply中传入函数即可
transform和apply也可以传入一个lambda表达式

df.groupby('item').sum()["price"]		==>
item
冬瓜    3.5
白菜    4.3
萝卜    1.5
辣椒    6.5
Name: price, dtype: float64
df.groupby('item').apply(sum)["price"]	==>
item
冬瓜    3.5
白菜    4.3
萝卜    1.5
辣椒    6.5
Name: price, dtype: float64

 #使用函数       
def function(items):
    result = 0
    for item in items:
        result += item
    return result
r1 = df.groupby("item")["price"].apply(function)
item
冬瓜    3.5
白菜    4.3
萝卜    1.5
辣椒    6.5
Name: price, dtype: float64
 #
r2.name = "price_sum"
pd.concat((df, r2),axis=1)		==>
item	color	price	weight	price_sum
0	萝卜	红	0.5	50	1.5
1	白菜	白	0.3	30	4.3
2	白菜	青	1.0	16	4.3
3	萝卜	青	1.0	32	1.5
4	辣椒	青	2.0	36	6.5
5	白菜	红	3.0	18	4.3
6	冬瓜	青	1.5	29	3.5
7	辣椒	红	4.0	18	6.5
8	辣椒	黄	0.5	19	6.5
9	冬瓜	白	2.0	23	3.5

 注意
transform 会自动匹配列索引返回值，不去重
apply 会根据分组情况返回值，去重

7、统计函数

corr相关性函数

DataFrame.corr(method='pearson', min_periods=1)
参数说明：

method：可选值为{‘pearson’, ‘kendall’, ‘spearman’}

               pearson：Pearson相关系数来衡量两个数据集合是否在一条线上面，即针对线性数据的相关系数计算，针对非线性                                           数据便会有误差。

                kendall：用于反映分类变量相关性的指标，即针对无序序列的相关系数，非正太分布的数据

                spearman：非线性的，非正太分析的数据的相关系数

min_periods：样本最少的数据量

返回值：各类型之间的相关系数DataFrame表格。

为区分不同参数之间的区别，我们实验如下：


from pandas import DataFrame
import pandas as pd
x=[a for a in range(100)]
#构造一元二次方程，非线性关系
def y_x(x):
    return 2*x**2+4
y=[y_x(i) for i in x]
 
data=DataFrame({'x':x,'y':y})
 
#查看下data的数据结构
data.head()
Out[34]: 
   x   y
0  0   4
1  1   6
2  2  12
3  3  22
4  4  36
 
data.corr()
Out[35]: 
          x         y
x  1.000000  0.967736
y  0.967736  1.000000
 
data.corr(method='spearman')
Out[36]: 
     x    y
x  1.0  1.0
y  1.0  1.0
 
data.corr(method='kendall')
Out[37]: 
     x    y
x  1.0  1.0
y  1.0  1.0

因为y经由函数构造出来，x和y的相关系数为1，但从实验结构可知pearson系数，针对非线性数据有一定的误差。

接下来是房价分析的例子：

corr_matrix = housing.corr()
corr_matrix["median_house_value"].sort_values(ascending=False)	==>

out:
median_house_value 1.000000
median_income 0.687160
total_rooms 0.135097
housing_median_age 0.114110
households 0.064506
total_bedrooms 0.047689
population -0.026920
longitude -0.047432
latitude -0.142724
Name: median_house_value, dtype: float64

可以看出，房价与收入有比较强的相关性，而与纬度的相关性很低。

scatter_matrix

pandas.plotting.scatter_matrix(frame, alpha=0.5, figsize=None, ax=None, grid=False, diagonal=‘hist’, marker=’.’, density_kwds=None, hist_kwds=None, range_padding=0.05, **kwds)
画任意两列数值属性的散点图，最后画一个散点图的矩阵，对角线为分布直方图。

 df = DataFrame(np.random.randn(1000, 4), columns=['A','B','C','D'])
  scatter_matrix(df, alpha=0.2)

在这里插入图片描述
继续分析房价的例子，通过计算相关系数，只看几个与房价相关性较大的数据

from pandas.tools.plotting import scatter_matrix
attributes = ["median_house_value", "median_income", "total_rooms",
"housing_median_age"]
scatter_matrix(housing[attributes], figsize=(12, 8))