pandas的高级使用

最新推荐文章于 2024-04-14 15:58:48 发布
最新推荐文章于 2024-04-14 15:58:48 发布
阅读量995 收藏 8
点赞数
分类专栏： 爬虫与数据分析 文章标签： pandas的高级使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pythoncsdn111/article/details/98115758
版权

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

在这里插入图片描述

Are you ready
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Pandas分组聚合与透视表的创建
Junds0的博客
05-09 530
第1关：Pandas分组聚合 本关任务：使用Pandas加载drinks.csv文件中的数据，根据数据信息求每个大洲红酒消耗量的最大值与最小值的差以及啤酒消耗量的和。 import pandas as pd import numpy as np # 返回最大值与最小值的和 def sub(df): ########## Begin ######### return df.max() - df.min() ########## End ######### def
pandas高级操作总结
JasonStudy
07-15 999
1.pandas中的列的分位数 # 查看列的分位数 import pandas as pd # set columns type my_df['col'] = my_df['col'].astype(np.float64) # computations for 4 quantiles : quartiles bins_col = pd.qcut(my_df['col'], 4) bins_c...
pandas的高级用法
weixin_59246157的博客
04-18 184
以上是使用Pandas的一些高级用法示例。更多详细信息，请参阅Pandas官方文档。
50 个 Pandas 高级操作，建议收藏！
最新发布
Pythonxiaoxin6的博客
04-14 880
↓推荐关注↓转自：https://zhuanlan.zhihu.com/p/568250201在数据分析和数据建模的过程中需要对数据进行清洗和整理等工作，有时需要对数据增删字段。下面为大家介绍Pandas对数据的实际业务需求往往需要按照一定的条件甚至复杂的组合条件来查询数据,接下来为大家介绍如何发挥Pandas数据筛选的无限可能，随心所欲地取用数据。
pandas高级操作
m0_46926492的博客
04-21 2313
分组后,也可以使用transform和apply提供自定义函数实现更多的运算。替换操作可以同步作用于Series和DataFrame中。注意:map是Series的方法，只能被Series调用。,分组后进行多种不同的聚合操作。
pandas进阶02--高级应用篇
平原的博客
06-22 3724
Pandas高级应用 目录介绍： 1、pandas高级应用–数据合并 2、pandas高级应用–数据重塑和旋转 3、pandas高级应用–数据转化、清除重复数据 4、pandas高级应用–数据替换 5、pandas高级应用–数据拆分 1、pandas高级应用–数据合并 from pandas import Series,DataFrame import pandas as ...
pandas 使用指南1
08-03
**Pandas 使用指南1** 在Python数据分析领域，Pandas库是一个不可或缺的工具，它提供了高效的数据操作和分析功能。Pandas有两个主要的数据结构，即Series和DataFrame，它们构成了数据分析的基础。 **1. Series** ...
pandas高级操作-附带测试数据源.zip
03-26
**Pandas高级操作详解** Pandas是Python中最常用的数据处理库，它提供了高效的数据结构，如DataFrame和Series，便于我们进行数据清洗、分析和建模。在这个教程中，我们将深入探讨Pandas的一些高级操作，包括替换...
pandas1.4.3官方文档
06-25
* 10分钟了解pandas：了解pandas的基础知识和使用 * 对象创建：了解如何创建pandas对象 * 查看数据：了解如何查看和处理数据 * 选择数据：了解如何选择和过滤数据 * 缺失数据：了解如何处理缺失数据 * 操作：了解...
Pandas高级操作: 时间序列与数据可视化
01-05
本资源集成了一系列深入探讨Pandas库高级功能的Python脚本，涵盖数据合并、重塑、分组聚合操作以及复杂的时间序列分析，并辅以直观的数据可视化实例。内容详尽、案例丰富，适合已具备Pandas基础知识的数据分析师、...
高级数据操纵控件Pandas的使用
06-14
Pandas是一款用于数据采集、数据处理和数据分析的可编程的利器，比电子表格功能更加强大，使用更加灵活，是进行数据分析与数据挖掘所依赖的重要工具。本课程将主要讲述Pandas的常用使用方法，授课内容包括：数据加载...
python之高阶pandas的使用（一）
小k要加油的博客
01-19 1221
用维度表表示重复的值 values=pd.Series(['apple','orange','lemon','apple']*2) values 去重 pd.unique(values) 计算每个种类出现次数 pd.value_counts(values) 我们可以用不同的数字来编码不同的值 value=pd.Series([0,1,2,0]*2) value take用于恢复之前的字符串 dim=pd.Series(['apple','e...
用 Python 做数据处理必看：12 个使效率倍增的 Pandas 技巧（下）
GUANGZHAN的专栏
02-09 1万+
点击打开链接 7 – 数据框合并 当我们有收集自不同来源的数据时，合并数据框就变得至关重要。假设对于不同的房产类型，我们有不同的房屋均价数据。让我们定义这样一个数据框： prop_rates = pd.DataFrame([1000, 5000, 12000], index=['Rural','Semiurban','Urban'],columns=['rates'])
第1章 Pandas基础操作（使用pandas进行数据分析，从小白逆袭大神，你会了吗？）
youif的博客
04-21 1591
文章目录第1章 Pandas基础查看Pandas版本一、文件读取与写入1. 读取（a）csv格式（b）txt格式（c）xls或xlsx格式2. 写入（a）csv格式（b）xls或xlsx格式二、基本数据结构1. Series（a）创建一个Series对于一个Series，其中最常用的属性为值（values），索引（index），名字（name），类型（dtype）（b）访问Series属性（c）取...
Python2与Python3中sum()函数对于NaN+NaN结果区别
漫步量化
11-26 3736
在量化数据处理中,会遇到一个问题,两列数据相加,取非空值. #python2中如下操作即可 df['col3'] = df[['col1','col2']].sum(axis=1) #python3中就会出错 df['col3'] = df[['col1','col2']].sum(axis=1) 因为Python3改版,函数有所变化,增加一个参数即可 #python3中增加参数 df['...
Python pandas数据分析中常用方法
热门推荐
心之所向
03-20 10万+
官方教程 读取写入文件 官方IO 读取 写入 read_csv 　　　　　　to_csv read_excel 　　　　　to_excel read_hdf 　　　　　　to_hdf read_sql 　　　　　　to_sql read_json　　　　　　to_json read_msgpack (experimenta...
python中transform用法_Python Pandas Series.transform()用法及代码示例
weixin_39779467的博客
12-05 2621
Pandas 系列是带有轴标签的一维ndarray。标签不必是唯一的，但必须是可哈希的类型。该对象同时支持基于整数和基于标签的索引，并提供了许多方法来执行涉及索引的操作。Pandas Series.transform()函数在self上调用func(传递的函数)，生成具有转换后的值的序列，并且该序列具有与self相同的轴长。用法： Series.transform(func, axis=0, *a...
numpy与pandas学习笔记
qq_42878057的博客
04-03 477
#导入numpy库 import numpy as np （1）创建矩阵： a=np.array([ [1,2,3], [2,3,4], [4,5,6]],dtype=np.int64) 函数 说明 np.ones((3,4)) 全是1的矩阵 np.zeros() 全是0的矩阵 np.empty() 全部元素都几乎接近于0的矩阵 np.random.random((3...
Pandas之stack()和unstack()用法
lightis_tian的博客
04-06 2万+
学习pandas的时候一直搞不清stack()和unstack()，看起来就是把df转了转但一直不知道具体原理。 看了【Python】pandas轴旋转stack和unstack用法详解后，觉得清楚了很多，再结合《利用python进行数据分析》的解释和例子，写下这篇博客作一个总结和思考。 stack()即“堆叠”，作用是将列旋转到行 unstack()即stack()的反操作，将行旋转到列 看个栗...
pandas高级应用
07-29
以下是一些常见的Pandas高级应用： 1. 数据清洗：Pandas提供了一系列的函数和方法来处理缺失值、重复值、异常值等数据清洗任务。例如，使用dropna()函数删除包含缺失值的行或列，使用fillna()函数填充缺失值，使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值