pandas相关函数sort

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 前言
• 一、排序函数sort_values()
• 二、字符串处理
• • 1.介绍
  • 2.代码介绍
• 三、pandas索引index
• • 1.介绍
  • 2.代码介绍
• 四、pandas的merge（）
• • 1.merge的语法
  • 2.理解merge的一对一、一对多、多对多的数量对齐关系
  • 3.理解how的left、right、inner、outer的区别
  • 4.如果出现非key的字段重名怎么办
• 五、数据合并concat
• • 1.cancat语法
  • 2.dataframe.append按行合并数据
• 六、分组统计groupby
• • 1.groupby的含义
  • 2.遍历groupby的结果理解执行流程
  • 3.多级索引
  • 4.groupby后的字符串合并拼接处理
  • 5.groupby.apply()
  • • 实例1：怎么对数值列按分组的归一化？
    • 实例2：怎么取每个分组的topn数据
• 七、pandas数据转换函数
• • 1.pandas 的数据转换函数
  • 2.map用于series值的转换
  • 3.apply用于series和dataframe的转换
  • 4.applymap用于dataframe所有值的转换
• 八、pandas的stack和pivot实现数据透视
• 总结

---

前言

提示：这里可以添加本文要记录的大概内容：
1、pandas排序函数sort_values()
2、pandas字符串处理
3、index
4、merge
5、contact
6、groupby
7、数据转换
8、数据透视
https://www.bilibili.com/video/BV1UJ411A7Fs?p=19

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、排序函数sort_values()

pandas数据排序sort_values()
1、series的排序：serie.sort_value(ascending=True,inplace=Flase)
参数：ascending：默认为true升序排列，false降序排列；inplace：是否修改原始series
2、dataframe：dataframe.sort_values(by,ascending=True,inplace=False)
参数说明：by：指定排序的列或多列，是一个字符串或list；ascebding同上，inplace同上

#单列降序排列
df.sort_values(by="最高温度",ascending=False)
#多列降序排列
df.sort_values(by=["最高温度"，"温差"],ascending=False)
#多列分别指定降序升序
df.sort_values(by=["最高温度"，"温差"],ascending=[True，False])

二、字符串处理 1.介绍

a。使用方法：先获取series的str属性，然后在属性上调用函数
b。只能在字符串列上使用，不能在数字列上使用
c。dataframe上没有str属性和处理方法
d。series.str并不是python上原生字符串，而是自己的一套方法，不过大部分和原生str很相似
e。pandas的字符串方法列表参考文档：https://pandas.pydata.org/pandas-docs/stable/reference/series.html#string-handling链接

2.代码介绍

1、获取series的str属性，然后使用各种字符串处理函数
2、使用str 的startswith、contains等bool类series可以做条件查询
3、需要多次str处理的链式操作
4、使用正则表达式处理

代码如下（示例）：

#获取列的数据类型
df.dtypes
#字符串替换函数
df["最高温度"].str.replace("℃","")
#判断是不是数字
df["最高温度"].str.isnumeric()
#查看字符串长度
df["最高温度"].str.len()

2、使用str 的startswith、contains等bool类series可以做条件查询

#下一步操作出来的结果是一个bool列
condition=df["日期"].str.startswith("2018-03")
#下一步出来的才是筛选列
df[condition]

3、需要多次str处理的链式操作
先将日期中018-03-02替换成20180302，再提取月份字符串201803

df["日期"].str.replace("-","").str.slice(0,6)
#以下也行
df["日期"].str.replace("-","").str[0:6]

4、使用正则表达式处理

def get_nianyueri(x):
    year,month,day=x["日期"].split("-")
    return f"{year}年{month}月{day}日"
df["中文日期"]=df.apply(get_nianyueri,axis=1)
df.head()
#去除年月日
df["中文日期"].str.replace("年","").str.replace("月","").str.replace("日","")
#正则表达式去除
df["中文日期"].str.replace("[年月日]","")

三、pandas索引index 1.介绍

index的用途：
1.更方便的数据查询；
2.使用index可以获得性能提升；
3.自动的数据对齐功能；
4.更多更强大的数据结构支持

2.代码介绍

1、使用index查询数据
代码如下（示例）：

#drop==false,让索引列还保持在column，将乡镇列设为索引，并且让索引列保存到原表中
df.set_index("乡(镇)",inplace=True,drop=False)
df.index
#使用index的查询方法
df.loc['蒙泉镇'].head()
#使用column的condition查询方法
df.loc[df["乡(镇)"]=='蒙泉镇'].head(3)

2、使用index会提升查询性能
如果index是唯一的，pandas会使用哈希表优化，查询性能为O（1）
如果index不是唯一的，但是有序的，pandas会使用二分查找算法，查询性能为O（logn）
如果index是完全随机的，那么每次查询都要扫描全表，查询性能是O（n）

#查询索引是否递增
df.index.is_monotonic_increaseing
#查询索引是否唯一
df.index.is_unique

3.自动的数据对齐功能；

import pandas as pd
s1=pd.Series([1,2,3],index=list("abc"))
s1
s2=pd.Series([2,3,4],index=list("bcd"))
s2
s1+s2

4.index有更多更强大的数据结构支持；
很多强大的索引数据结构
a。CategoricalIndex,基于分类数据的index，提升性能；
b。MultiIndex,多维索引，用于groupby多维聚合后结果等；
C。DatetimeIndex，时间类型索引，强大的日期和时间的方法支持

四、pandas的merge（）

pandas的merge，相当于sql的join，将不同的表按key关联到一个表

1.merge的语法

pd.merge(left,right,how=‘inner’,on=None,left_on=None,right_on=None,left_index=False,right_index=False,sort=Ture,suffixes=(‘_x’,‘_y’),copy=Ture,indicator=False,volidate=None)
*left、right：要merge的dataframe或者有name的series
*how：join类型，有left、right、outer、inner
*on：join的key、left和right都需要有这个key
*left_on:left的df或者series的key
*right_on: right的df或者series的key
*left_index,right_index:使用index而不是普通的column做on
*suffixes：两个元素的后缀，如果列有重名，自动添加后缀，默认是_x _y

2.理解merge的一对一、一对多、多对多的数量对齐关系

1、一对一：关联的key都是唯一的

left=pd.DataFrame({'sno':[1,2,3,4],'name':['aaa','bbb','c','d']})
left
right=pd.DataFrame({'sno':[1,2,3,4],'age':['21','22','23','24']})
right
#一对一关系，结果中有四条
pd.merge(left,right,on='sno')

运行结果

   sno	name
0	1	aaa
1	2	bbb
2	3	c
3	4	d
   sno	age
0	1	21
1	2	22
2	3	23
3	4	24
   sno	name age
0	1	aaa	21
1	2	bbb	22
2	3	c	23
3	4	d	24

2、一对多：左边的表key唯一，右边不唯一

import pandas as pd
left=pd.DataFrame({'sno':[1,2,3,4],'name':['aaa','bbb','c','d']})
left
right=pd.DataFrame({'sno':[1,1,3,3,4],'grade':['math80','english91','chinese99','math24','english64']})
right
#有5行
pd.merge(left,right,on='sno')

   sno	name
0	1	aaa
1	2	bbb
2	3	c
3	4	d
	sno	grade
0	1	math80
1	1	english91
2	3	chinese99
3	3	math24
4	4	english64
	sno	name	grade
0	1	aaa	math80
1	1	aaa	english91
2	3	c	chinese99
3	3	c	math24
4	4	d	english64

3、多对多：左边、右边不唯一
结果会出现左边的行数*右边的行数

import pandas as pd
left=pd.DataFrame({'sno':[1,1,3,3],'爱好':['画画','篮球','c足球','d画画']})
left
right=pd.DataFrame({'sno':[1,1,3,3,4],'grade':['math80','english91','chinese99','math24','english64']})
right
pd.merge(left,right,on='sno')

 	sno	爱好
0	1	画画
1	1	篮球
2	3	c足球
3	3	d画画
	sno	grade
0	1	math80
1	1	english91
2	3	chinese99
3	3	math24
4	4	english64
   sno	爱好	grade
0	1	画画	math80
1	1	画画	english91
2	1	篮球	math80
3	1	篮球	english91
4	3	c足球	chinese99
5	3	c足球	math24
6	3	d画画	chinese99
7	3	d画画	math24

3.理解how的left、right、inner、outer的区别

4.如果出现非key的字段重名怎么办 五、数据合并concat

使用场景：批量合并相同格式的EXCEl、给DataFrame添加行、列

1.cancat语法

pandas.concat(objs,axis=0,join=‘outer’,ignore_index=False)
*objs:一个列表，内容可以是DataFrame或者series，也可以混合
*axis：默认是0代表行合并，1是列合并
*join：合并的时候索引的对齐方式，默认是outer join,也可以是inner join

DataFrame.append(other,ignore_index=False)
append只有按行合并，没有按列合并，相当于cancat 的简写形式
*other：单个dataframe、series、dict、列表
*ignore_index:是否忽略原来的数据索引

import pandas as pd
import warnings
warnings.filterwarnings('ignore')
df1=pd.DataFrame({'A':['A0','A1','A2','A3'],'B':['B0','B1','B2','B3'],'C':['C0','C1','C2','C3'],'D':['D0','D1','D2','D3'],'E':['E0','E1','E2','E3'],})
df1
df2=pd.DataFrame({'A':['A4','A5','A6','A7'],'B':['B0','B1','B2','B7'],'C':['C0','C1','C2','C7'],'D':['D0','D1','D2','D7'],'F':['f0','f1','F2','F3'],})
df2
#默认的concat，参数为axis=0，join=outer，ignore_index=False
df=pd.concat([df1,df2])
df
#过滤掉不匹配的列
dfa=pd.concat([df1,df2],ignore_index=True,join='inner')
dfa
#axis=1相当于添加新列
s1=pd.Series(list(range(4)),name='new')
pd.concat([df1,s1],axis=1)
#添加多列
s2=df1.apply(lambda x:x['A']+"_XX",axis=1)
s2.name='G'
pd.concat([df2,s1,s2],axis=1)

	A	B	C	D	E      
0	A0	B0	C0	D0	E0
1	A1	B1	C1	D1	E1
2	A2	B2	C2	D2	E2
3	A3	B3	C3	D3	E3
	A	B	C	D	F
0	A4	B0	C0	D0	f0
1	A5	B1	C1	D1	f1
2	A6	B2	C2	D2	F2
3	A7	B7	C7	D7	F3
A	B	C	D	E	F
0	A0	B0	C0	D0	E0	NaN
1	A1	B1	C1	D1	E1	NaN
2	A2	B2	C2	D2	E2	NaN
3	A3	B3	C3	D3	E3	NaN
0	A4	B0	C0	D0	NaN	f0
1	A5	B1	C1	D1	NaN	f1
2	A6	B2	C2	D2	NaN	F2
3	A7	B7	C7	D7	NaN	F3
	A	B	C	D	E	new
0	A0	B0	C0	D0	E0	0
1	A1	B1	C1	D1	E1	1
2	A2	B2	C2	D2	E2	2
3	A3	B3	C3	D3	E3	3

2.dataframe.append按行合并数据

df1=pd.DataFrame([[1,2],[3,4]],columns=list('AB'))
df1
df2=pd.DataFrame([[5,6],[7,8]],columns=list('AB'))
df2
df1.append(df2,ignore_index=True)
#一个空的df
df=pd.DataFrame(columns=['A'])
df
#低性能版本
for i in range(5):
    df=df.append({'A':i},ignore_index=True)
df
#性能较好版本
pd.concat([pd.DataFrame([i],columns=['A']) for i in range(5)],ignore_index=True)

六、分组统计groupby 1.groupby的含义

groupby：先对数据分组，然后在每个分组上应用聚合函数、转换函数
本次：
1.分组使用聚合函数做数据统计
2.遍历groupby的结果理解执行流程
3.多级索引

import pandas as pd
import numpy as np
df=pd.DataFrame({'A':['xiao1','xiao2','xiao1','xiao2','xiao2'],'B':['c','d','d','c','c'],'C':np.random.randn(5),'D':np.random.randn(5)})
df
#1、单个列groupby，查询所有数据列的统计
#A列变成了数据的索引列
#因为要统计sum，B列不是数字就被自动忽略了
df.groupby('A').sum()
#2、多个列groupby，查询所有数据列的统计,mean是求平均值
#（A,B)成对变成了二级索引
df.groupby(['A','B']).mean()
df.groupby(['A','B'],as_index=False).mean()#这就避免了（A，B）变成索引
#3、同时查看多钟数据统计，这使得列表变成了多级索引
df.groupby('A').agg([np.sum,np.mean,np.std])#np.std是标准差
#python中的agg函数通常用于调用groupby（）函数之后，对数据做一些聚合操作，包括sum，min,max以及其他一些聚合函数
#4、查看单列的结果数据统计
#方法1：预过滤，性能更好
df.groupby('A')['C'].agg([np.sum,np.mean,np.std])
#方法2
df.groupby('A').agg([np.sum,np.mean,np.std])['C']
#不同列分别使用不同的聚合函数
df.groupby('A').agg({"C":np.sum,"D":np.mean})

2.遍历groupby的结果理解执行流程

for循环可以直接遍历每个group

#1、遍历单个列聚合的分组
g=df.groupby('A')
g
for name,group in g:
    print(name)
    print(group)
    print()
#可以获得单个分组的数据
g.get_group('xiao2')
#2、遍历多个列聚合的分组
b=df.groupby(['A','B'])
for name,group in b:
    print(name)
    print(group)
    print()
#上面的话那么是一个有2个元素的tuple，代表不同的列
b.get_group(('xiao1','c'))
#可以直接查询group后的某几列，生成series或者子Dataframe
b['C']
for name,group in b['C']:
    print(name)
    print(group)
    print(type(group))
    print()

3.多级索引

当groupby（[‘A’,‘B’]）时表会变成多级索引，所以需要对多级索引进行处理，以下代码有对series多维索引的处理，也有对dataframe多维索引的处理

import pandas as pd
import numpy as np
df=pd.DataFrame({'A':['xiao1','xiao2','xiao1','xiao2','xiao2','baidu','baidu'],'B':['20210101','20210101','20210103','20210104','20210105','20210105','20210101'],'C':np.random.randn(7),'D':np.random.randn(7)})
ser=df.groupby(['A','B'])['C'].mean()
ser#ser里是一个多维索引
ser.index
#unstack把二级索引变成列,A列变成竖着的表头，B列变成横着的表头
ser.unstack()
#删除二级索引
#ser.reset_index()
#有多层索引MultiIndex怎么筛选数据？
ser
ser.loc['xiao1']
#多层索引，可以用元组的形式筛选
ser.loc[('xiao1','20210101')]
ser.loc[:,'20210101']
#DataFrame的多层索引MultiIndex
df.head()
df.set_index(['A','B'],inplace=True)
df.index
#排序后性能会好很多
df.sort_index(inplace=True)
df
#***DataFrame有多层索引MultiIndex怎样筛选数据
#[重要知识]在选择数据时：
#1、元祖（key1，key2）代表筛选多层索引，其中key1是索引第一级，key2是第二级，比如key1=xiao1，key2=c
#2、列表[key1,key2]代表同一层的多个key，其中key1和key2是并列的同级索引,比如key1=xiao1，key2=baidu
df.loc['baidu']
df.loc[('baidu','20210101'),:]
df.loc[['xiao1','baidu'],:]
df.loc[(['xiao1','baidu'],'20210101'),:]
df.loc[(['xiao1','baidu'],'20210101'),'C']
df.loc[('baidu',['20210101','20210105']),:]
#slice(None)代表筛选这一索引的所有内容
df.loc[(slice(None),['20210101','20210103']),:]
#删除多维索引
df.reset_index()

4.groupby后的字符串合并拼接处理

import pandas as pd
import numpy as np
df=pd.DataFrame({'A':['xiao1','xiao1','xiao1','baidu','baidu','baidu','baidu'],'B':['a01','b1','c3','a4','b5','c5','d101'],'C':['a','a','a','a','a','a','a']})
data=df.groupby('A')['B'].apply(lambda x:x.str.cat()).reset_index()
data
data=df.groupby('A')['B'].apply(lambda x:x.str.cat(sep=':')).reset_index()
data
#相关数据如下，C列是后面加的
A	B
0	xiao1	a01
1	xiao1	b1
2	xiao1	c3
3	baidu	a4
4	baidu	b5
5	baidu	c5
6	baidu	d101
#运行结果
	A	B
0	baidu	a4b5c5d101
1	xiao1	a01b1c3
      A	        B
0	baidu	a4:b5:c5:d101
1	xiao1	a01:b1:c3

5.groupby.apply()

知识点：pandas的groupby遵从split、apply、combine模式：
这个split指的是groupby，apply是我们自己实现的函数，apply返回的结果有pandas进行combine得到结果

groupby.apply(function)
*function的第一个参数是dataframe
*function的返回结果，可以是datafr、series、单个值、甚至和输入dataframe完全没关系
本次实例演示：
1、怎样对数字列按照分组的归一化
2、怎么取每个分组的topN数据

实例1：怎么对数值列按分组的归一化？

将不同范围的数值列进行归一化，映射到[0,1]区间：
*更容易做数据横向对比，比如价格字段是几百到几千，增幅字段是0到几百
*归一化后，机器学习模型学的更快性能更好
归一化的公式：

import pandas as pd
import numpy as np
#构造用户的电影评分表，然后对其中一列归一化
ratings=pd.DataFrame({"userid":[1,1,1,1,1],"movieid":[110,111,112,221,902],"rating":[5,3,3,4,5],"timestamp":[978300760,978302109,978301968,978300275,978824291]})
ratings
#实现按照用户ID分组，然后对其中一列归一化
def ratings_norm(df):
    min_value=df["rating"].min()
    max_value=df["rating"].max()
    df["rating_norm"]=df["rating"].apply(
        lambda x: (x-min_value)/(max_value-min_value)
    )
    return df
ratings =ratings.groupby("userid").apply(ratings_norm)
ratings[ratings["userid"]==1].head()
#可以看到1这个用户，最低评分是3，我们将3分归一到0分

提示：相关数据

实例2：怎么取每个分组的topn数据

获取2018年每个月份最高温度的2天数据

import pandas as pd
import numpy as np
import pandas as pd
import numpy as np
fpath=r"G:360Downloadsmyselfzuoyegroupby后字符串合并处理tianqi.xlsx"
df=pd.read_excel(fpath)
df.head()
#替换℃
df.loc[:,"bwendu"]=df["bwendu"].str.replace("℃","").astype('int32')
df.loc[:,"ywendu"]=df["ywendu"].str.replace("℃","").astype('int32')
#新增一列为月份，这种方法只有月份没有年份
df["ymd"]=pd.to_datetime(df["ymd"])
df["month"]=df["ymd"].dt.month
#新增一列为月份的还一种方法
df["month2"]=df["ymd"].astype('str').str[:7]
df.head()
def getWenduTopN(df,topn):
    """这里的df是每个月份分组group的df"""
    return df.sort_values(by="bwendu")[["ymd","bwendu"]][-topn:]
df.groupby("month2").apply(getWenduTopN,2).head()

七、pandas数据转换函数

数据转换的大概理解就是将某列英文（或其他东西）按照某种对应规则把它转换成汉语

1.pandas 的数据转换函数

有map、apply、applymap
1、map：只用于series，实现每个值到值的映射
2、apply：用于series实现对每个值的处理，也可用于dataframe实现某个轴的series的处理
3、applymap：只能用于Dataframe，用于处理dataframe的每个元素

2.map用于series值的转换

实例：将英语公司名称转换成中文
series.map(dict)orseries.map(function)
代码如下（示例）：

import pandas as pd
import numpy as np
fpath=r"G:360Downloadsmyselfzuoyegroupby后字符串合并处理tianqi.xlsx"
df=pd.read_excel(fpath)
df.head()
#公司列去重，查看有哪些数据
df["公司"].unique()
#公司名称都是小写
dict_company_names={
    "bidu":"百度",
    "baba":"阿里",
    "iq":"爱奇艺",
    "jd":"京东"
}
#方法1,lower是把字母都变成小写
df["gongsi"]=df["公司"].str.lower().map(dict_company_names)
df
#方法2，series.map(function)
#function的参数是series的每个元素的值
df["gs"]=df["公司"].map(lambda x: dict_company_names[x.lower()])
df

3.apply用于series和dataframe的转换

*series.apply(function),函数参数是每个值
*dataframe.apply(function)函数参数是series

代码如下（示例）：

df["gs"]=df["公司"].apply(lambda x: dict_company_names[x.lower()])
#DataFrame.apply(function)function的参数是对应轴的series
df["gs3"]=df.apply(
    lambda x: dict_company_names[x["公司"].lower()],
    axis=1
)
#ps：apply是在df这个DataFrame上调用
#lambda x的x是一个serise,因为指定了axis=1，所以series的key是列名，可以用x["公司"]获取
df.head()

4.applymap用于dataframe所有值的转换

代码如下（示例）：

sub_df=df[["收盘","开盘"]]
sub_df.head()
#将这些数字取整数，应用于所有元素
sub_df.applymap(lambda x: int(x))
#直接修改原df的这几行
df.loc[:,["收盘","开盘"]]=sub_df.applymap(lambda x: int(x))
df.head()

八、pandas的stack和pivot实现数据透视

提示：将列式数据变成二维交叉形式，便于分析，叫做重塑或透视
1.经过统计得到多维度指标数据
2.使用unstack实现数据二维透视
3.使用pivot简化透视
4.stack、unctack、pivot的语法
应用场景：

#单列降序排列
df.sort_values(by="最高温度",ascending=False)
#多列降序排列
df.sort_values(by=["最高温度"，"温差"],ascending=False)
#多列分别指定降序升序
df.sort_values(by=["最高温度"，"温差"],ascending=[True，False])

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。