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

---

前言

提示：这里可以添加本文要记录的大概内容：
1、pandas排序函数sort_values()
2、pandas字符串处理
3、index
4、merge
5、contact
6、groupby
7、数据转换
8、数据透视
9、日期处理
10、图相关

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("[年月日]","")

3.Categorical类型降低数据存储提升计算速度

运行原理：比如有一列性别都是男女这样的字符串，将其变成数字存储，男变成1，女变成2

运用场景：数据量特别大，已经超过100MB 的情况下使用。比如像以下的dataframe：存储量43.9+，这个+是因为数据类型是Object，object是对象的指针，并没有算指针指向的字符串的大小，指向存储数据的地方，所以这就导致实际存储数据的大小要比43.9要大得多，这种情况下，数据量一大就严重拖累运算速度。使用了categorical后，字符串变成了数字，字符串不会重复存储了，并且这样运行速度会大幅度提高

代码如下（示例）：

import pandas as pd
import numpy as np
df=pd.read_excel(r"F:\work\ashimen\数据.xlsx")
df.info()
#找指针指向的字符串一起的存储大小
df.info(memory_usage="deep")
df_cat=df.copy()#使用categorical类型降低存储量
df_cat["街道乡镇"]=df_cat["街道乡镇"].astype('category')
df_cat["社区村组"]=df_cat["社区村组"].astype('category')
df_cat.info(memory_usage="deep")
df_cat.head()#可以看到不影响数据
df_cat["街道乡镇"].value_counts()

关于变化后，存储大小的比对：

三、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   dsno    age
0   1   21
1   2   22
2   3   23
3   4   24sno   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   dsno    grade
0   1   math80
1   1   english91
2   3   chinese99
3   3   math24
4   4   english64sno    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   english64sno    爱好  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  E3A 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 F3A 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   a01b1c3A            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:\360Downloads\myself\zuoye\groupby后字符串合并处理\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()

6.groupby的一些函数使用【统计函数】

知识点：pandas的groupby后的函数使用：

#使用月份和乡镇两列聚合后，两种使用sum求和函数的方法，结果完全不一样，agg这种所有的列都sum了，而第二种写法只针对数据列求和
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"]).agg({'sum'})
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"])["证件号码"].agg(pv=np.sum)
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"]).sum()
#这个函数相当于excel的count（）计数函数
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"]).size()
#怎么对增加的计数列命名
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"])["证件号码"].agg(pv=np.size)
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"])["证件号码"].agg([("count","count")])
#这是新增多列的命名方式
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"])["证件号码"].agg([("count","count"),("size1","size")]).reset_index()

七、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:\360Downloads\myself\zuoye\groupby后字符串合并处理\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的语法
应用场景：

import pandas as pd
import numpy  as np
import matplotlib.pyplot as plt
fpath=r"G:\360Downloads\myself\zuoye\try\月份grouby.xlsx"
df=pd.read_excel(fpath)
df=df[["证件号码","乡镇（街道）","村（社区）","开始时间","总额","自费金额"]]
df.head()
df["date"]=pd.to_datetime(df["开始时间"])
#按月份统计乡镇出现次数
df_group=df.groupby([df["date"].dt.month,"乡镇（街道）"])["证件号码"].agg([("count","count")])
df_group
#对于有这种多重索引的格式，想查看按月份，不同乡镇的出现次数趋势是没办法实现的
#需要将数据变换成每个评分是一列才可以实现#2.使用unstack实现数据二维透视
#目的是想要画图对比按照月份的不同评分的数量趋势
df_stack=df_group.unstack()#这样的表就把二层索引变成好画图的表
df_stack
df_stack.plot()
#unstack和stack是互逆的操作
df_stack.stack().head()#3.使用pivot简化透视
#pivot方法相当于对df使用set_index创建分层索引，然后调用unstack
df_group.head(20)
df_reset=df_group.reset_index()
df_reset.head(20)
df_pivot=df_reset.pivot("date","乡镇（街道）","count")
df_pivot.head()
df_pivot.plot()#4.stack、unstack、pivot的语法
#satck：DataFrame。stack(level=-1,dropna=True),将column变成index，类似把横放的书籍变成竖放
#level=-1代表多层索引的最内层，可以通过==0,1,2，指定多层索引的对应层

九、快速实现周月季度的日期聚合统计DatatimeIndex

1.介绍

链接：https://www.bilibili.com/video/BV1eJ411Q7Vd?spm_id_from=333.337.search-card.all.click
Pandas日期处理的作用：将2018-01-01、1/1/2018等多种日期格式映射成统一的格式对象，在该对象上提供强大的功能支持
几个概念：
a。pd.to_datetime:pandas的一个函数，能将字符串、列表、series变成日期形式
b。Timestamp：pandas表示日期的对象形式
c。DatetimeIndex：pandas表示日期的对象列表形式
其中：
DatetimeIndex是Timestamp的列表形式
pd.to_datetime对单个日期字符串处理会得到Timestamp
pd.to_datetime对日期字符串列表处理会得到DatetimeIndex

Timestamp、DatetimeIndex支持大量的属性可以获取日期分量：
http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#time-date-components

2.代码介绍

可以试用于的场景：已有每天一条数据的表格（比如天气表、股票表），怎么统计每周、每月、每季度的最高温度呢？

代码如下（示例）：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt#1.读取天气数据
df=pd.read_excel(r"G:\360Downloads\myself\zuoye\code\10年天气数据.xlsx")
df.head()
df.loc[:,"最高温"]=df["最高温"].str.replace("°","").astype('int32')
df.loc[:,"最低温"]=df["最低温"].str.replace("°","").astype('int32')
#df.info()
df.head(20)
df.loc[:,"日期"]=df["日期"].str[0:10]
df.head()
#只需要2018年的数据
condition=df["日期"].str.startswith("2018")
df=df[condition]
df.info()#2.将日期列转换成pandas的日期
df.set_index(pd.to_datetime(df["日期"]),inplace=True)
df.head()
df.index
#DatetimeIndex是Timestamp的列表形式
df.index[0]#3.方便对DatetimeIndex进行查询
#如果不是DatetimeIndex的话，没办法用这样的前缀筛选，需要上面的startswith
#筛选固定的某一天
df.loc['2018-01-05']
#日期区间
df.loc['2018-01-05':'2018-01-15']
#按月份前缀筛选
df.loc['2018-03'].head(10)
#按月份前缀筛选
df.loc['2018-03':'2018-05'].index
#按年份前缀筛选
df.loc['2018'].head()#4.方面的获取周、月、季度
df.index.week
df.index.month
df.index.quarter#5.统计每周、每月、每个季度的最高温度
df.groupby(df.index.week)["最高温"].max().head(20)
df.groupby(df.index.week)["最高温"].max().plot()df.groupby(df.index.month)["最高温"].max().head(12)
df.groupby(df.index.month)["最高温"].max().plot()df.groupby(df.index.quarter)["最高温"].max()
df.groupby(df.index.quarter)["最高温"].max().plot()

3.怎么处理日期索引的缺失

可以试用于的场景：按日期统计的数据，缺失了某天，导致数据不全怎么补充日期？
可以用两种方法实现：
1、DataFrame.reindex,调整dataframe的索引以适应新的索引
2、DataFrame.resample,可以对时间序列重采样，支持补充缺失值
resample的采样规则参数：http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases

代码如下（示例）：

from textwrap import fill
import pandas as pd
import numpy as np
import matplotlib.pyplot as pltdf=pd.DataFrame({"pdate":["2019-01-01","2019-01-02","2019-01-04","2019-01-05"],"pv":[100,200,400,500],"uv":[10,20,40,50]})
dfdf.set_index("pdate").plot()
#这样打出来的图像有个标记，缺了1月3号数据#方法1：使用pandas.reindex方法
#1。将df的索引标称日期索引
df_date=df.set_index("pdate")
df_date
df_date.index#索引还是dtype='object'
#将df索引设置为日期索引
df_date=df_date.set_index(pd.to_datetime(df_date.index))
df_date.index#索引还是dtype='datetime64[ns]'
#2。使用pandas.reindex填充缺失的索引
#生成完整的日期序列
pdates=pd.date_range(start="2019-01-01",end="2019-01-05")
pdates
df_date_new=df_date.reindex(pdates, fill_value=0)
df_date_new.plot()#方法2：使用pandas。resample方法
#resample的含义：改变数据的时间频率，比如把天数据变成月数据（由小变大），或者把小时数据变成分钟级别（由大变小）
#resample语法：DataFrame/Series.resample(arguments).(aggregate function)
#resample的采样规则参数：http://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases
df_new2=df.set_index(pd.to_datetime(df["pdate"])).drop("pdate",axis=1)
df_new2
#由于采样会让区间变成一个值，所以需要制定mean等采样值的设定方法
df_new2=df_new2.resample("D").mean().fillna(0)
df_new2
#D是天，2D是2天
df_new2.resample("2D").mean()

十、图相关

1.通过折线图发现产品流量问题

折线图是随着时间而变化的连续数据，展现时间间隔相等的时候的数据趋势

实例数据来自kaggle网站地址：https://www.kaggle.com/datasets/aerodinamicc/ecommerce-website-funnel-analysis
总共有四个页面数据：
1.home_page_table.csv ,首页用户访问数据
2.payment_confirmation_table.csv 支付成功页面用户访问数据
3.payment_page_table.csv 支付信息页面用户访问数据
4.search_page_table.csv搜索页面用户访问数据
5.user_table.csv 用户信息表
目标：绘制转化率的折线图，查询是否有异常情况

代码

import pandas as pd
import numpy as np
import pyecharts.options as opts
from pyecharts.charts import Line#1、读取数据
df_home_page=pd.read_csv(r"D:\搜狗高速下载\archive\home_page_table.csv")
df_search_page=pd.read_csv(r"D:\搜狗高速下载\archive\search_page_table.csv")
df_payment_page=pd.read_csv(r"D:\搜狗高速下载\archive\payment_page_table.csv")
df_payment_confirmation_page=pd.read_csv(r"D:\搜狗高速下载\archive\payment_confirmation_table.csv")
df_user_table=pd.read_csv(r"D:\搜狗高速下载\archive\user_table.csv")
#查看每张表的构造，页面表就是用户id和访问页面名称
#用户表是id加时间、设备、性别
df_user_table.head()
df_home_page.head()
df_search_page.head()#2、关联5个数据表为一个大表
df_merge=df_user_table
for df_inter in [df_home_page,df_search_page,df_payment_page,df_payment_confirmation_page]:#每次循环都在df_merge中添加新列df_merge =pd.merge(df_merge,df_inter,on="user_id",how="left")
df_merge.head()
#对列新命名
df_merge.columns=["user_id","date","device","sex","home_page","search_page","payment_page","confirmation_page"]
df_merge.head()
#对时间列进行处理
df_merge["date"]=pd.to_datetime(df_merge["date"])
df_merge.head()#3、展现每个页面整体的PV曲线
df_data=(df_merge.groupby("date").agg(home_page=("home_page", lambda x:x.dropna().size),search_page=("search_page", lambda x:x.dropna().size),payment_page=("payment_page",lambda x:x.dropna().size),confirmation_page=("confirmation_page",lambda x:x.dropna().size))
)
df_data.head()
#绘制折线图
c =(Line().add_xaxis(df_data.index.to_list()).add_yaxis("home_page",df_data["home_page"].to_list()).add_yaxis("search_page",df_data["search_page"].to_list()).add_yaxis("payment_page",df_data["payment_page"].to_list()).add_yaxis("confirmation_page",df_data["confirmation_page"].to_list()).set_global_opts(title_opts=opts.TitleOpts(title="整体PV折线"))
)
c.render_notebook()#4、查看分设备的PV曲线
df_data = (df_merge.groupby(["date","device"])["search_page"].agg(search_page=lambda x:x.dropna().size).unstack()
)
df_data.head()
c=(Line().add_xaxis(df_data.index.to_list()).add_yaxis("desktop",df_data[("search_page","Desktop")].to_list()).add_yaxis("mobile",df_data[("search_page","Mobile")].to_list()).set_global_opts(title_opts=opts.TitleOpts(title="搜索页面PV")))
c.render_notebook()

分析

1.引入的数据表长啥样

2.5个表关联成大表后，更改列名后：

3.1对数据进行处理后，得出每天访问各个页面的人数

3.2整体PV图，可以看出搜索页数据有明显的波动

4.对搜索页的设备端进行统计，进行详细分析试图找出问题


3月1号手机端搜索量下降不正常

---

总结

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

pandas相关函数sort_values、字符串处理、index、merge、数据合并cancat、groupby分组统计相关推荐

1. Pandas数据分析—groupby分组统计

   13.Pandas中groupby分组统计 文章目录 13.Pandas中groupby分组统计 前言 一.分组使用聚合函数做数据统计 1.准备数据 二.遍历groupby的结果理解执行流程 三.实例 ...

2. MySQL 优化之 index merge(索引合并)

   深入理解 index merge 是使用索引进行优化的重要基础之一.理解了 index merge 技术,我们才知道应该如何在表上建立索引. 1. 为什么会有index merge 我们的 where ...

3. mysql+index组合索引_MySQL 优化之 index merge(索引合并)

   标签: MySQL5.0之前,一条语句中一个表只能使用一个索引,无法同时使用多个索引.但是从5.1开始,引入了 index merge 优化技术,对同一个表可以使用多个索引.理解了 index mer ...

4. pandas：根据行间差值进行数据合并

   1. 问题描述 在处理用户上网数据时,用户的上网行为数据之间存在时间间隔,按照实际情况,若时间间隔小于阈值(next_access_time_app),则可把这几条上网行为合并为一条行为数据:若时间间 ...

5. 【Python】挑战SQL：图解Pandas的数据合并merge

   公众号:尤而小屋 作者:Peter 编辑:Peter 在实际的业务需求中,我们的数据可能存在于不同的库表中.很多情况下,我们需要进行多表的连接查询来实现数据的提取,通过SQL的join,比如left ...

6. 图解pandas的数据合并merge

   公众号:尤而小屋 作者:Peter 编辑:Peter 大家好,我是Peter~ 在实际的业务需求中,我们的数据可能存在于不同的库表中.很多情况下,我们需要进行多表的连接查询来实现数据的提取,通过SQL ...

7. pandas——数据移位、数据转换、数据合并、数据导出和日期数据的处理，时间序列等

   pandas统计分析(下) 本文主要介绍使用pandas进行数据移位.数据转换.数据合并.数据导出和日期数据的处理,时间序列等. 数据移位 数据移位就是在分析数据时,需要移动到上一条,在pandas中 ...

8. mysql 索引合并_MySQL 索引合并（Index Merge）优化

   本文问题 什么是Index Merge?Index Merge的限制有哪些? 如何查看语句是否使用了Index Merger? Index Merge有哪几种?分别适用于那些情景? 如何控制优化器是否 ...

9. mysql merge查询速度_MySQL 查询优化之 Index Merge

   MySQL 查询优化之 Index Merge 索引合并访问方法可以在查询中对一个表使用多个索引,对它们同时范围扫描,并且合并结果(intersects/unions/unions-of-inters ...

最新文章

1. 人群场景的属性--Deeply Learned Attributes for Crowded Scene Understandin
2. 从零到一：用Phaser.js写意地开发小游戏（Chapter 4 - 游戏即将开始）
3. 《疯狂Java讲义》7
4. codejam题目_嵌套深度-Google CodeJam 2020资格回合问题解决方案
5. Minimum Mean Squared Error (MMSE)最小均方误差
6. php 创建目录_使用 Zephir 轻松构建 PHP 扩展
7. php搜索所有路线,php包含文件路径查找规则
8. [VMware] vSphere 5 安装手记[1]-VMware ESXi 5.0.0 安装基本设置
9. php excel 添加图片不显示图片,excel表格中使用宏批量插入图片,发给别人打开图片不显示...
10. 深入理解GBDT回归算法
11. 游戏行业如何上云？阿里云架构师解读四大主流游戏架构
12. 计算机单位pt,iOS尺寸单位pt、ppi与px之间换算关系
13. 基于QT实现的可视化链表(单链表、循环链表、双向链表)
14. php mysqli操作数据库
15. php GD库做水印功能，合并图片
16. 我是一只IT小小鸟里面牛人的博客
17. 上海之旅，再让键盘长几天草
18. win10 你的手机
19. 数据到底能做什么？ ——谷歌、腾讯、高德告诉你答案
20. Matlab：随机整数

热门文章

1. 关于“无法读取 KSR data-disk 1 扇区。。”蓝屏问题
2. 生产制造管理系统MES
3. 傲慢的上校的fragment讲解
4. background-image
5. python：实现Triplets with zero sum零和三元组(附完整源码)
6. mysql audit 表_关于MySQL AUDIT(审计)那点事
7. html文件是一种使用超文本标记语言,超文本标记语言HTML HTML(Hyper Text Markup Language,.ppt...
8. 8天3城50店，带你去广东吃遍虾饺、烧腊、猪脚饭、潮汕牛肉火锅……
9. 抖音SEO优化源码，企业号搜索排名系统，矩阵同步分发。
10. // 和 \\ 都表示什么意思