![[python]14、pandas模块的具体使用和安装jupyter以及常用的,第1张](/aiimages/%5Bpython%5D14%E3%80%81pandas%E6%A8%A1%E5%9D%97%E7%9A%84%E5%85%B7%E4%BD%93%E4%BD%BF%E7%94%A8%E5%92%8C%E5%AE%89%E8%A3%85jupyter%E4%BB%A5%E5%8F%8A%E5%B8%B8%E7%94%A8%E7%9A%84.png "[python]14、pandas模块的具体使用和安装jupyter以及常用的,第1张")
目录
1、安装jupyter
1.1、启用jupyter
2、 pandas介绍
2.1、pip3和pip的区别
2.2、pip或者pip3换源
2.2.1、临时修改
2.2.2、永久修改
2.2.3、国内其他pip源
3、Pandas数据结构
3.1、Series
3.1.1、 仅有数据列表即可产生最简单的Series
3.1.2、创建一个具有标签索引的Series
3.1.3、根据标签索引查询数据
3.2、DataFrame
3.2.1、根据多个字典序列创建dataframe
3.2.2、根据从文件、mysql中读取创建dataframe
4、pandas的基本功能（pandas命令总结）
4.1、命令执行
4.2、查看信息类函数
5、Pandas查询选取数据
5.1、Pandas查询数据的几种方法
6、Pandas的数据转换函数map、apply、applymap ⭐⭐⭐
7、Pandas对缺失值的处理
步骤5：将分数列为空的填充为0分
步骤6：将姓名的缺失值填充
步骤7：将清洗好的excel保存
8、Pandas数据排序
8.1、读取数据
8.2、Series的排序
8.3、DataFrame的排序
8.3.1、单排序
8.3.2、多列排序
9、Pandas怎样实现DataFrame的Merge
merge的语法：
9.1、理解merge时数量的对齐关系
9.1.1、one-to-one 一对一关系的merge
9.1.2、one-to-many 一对多关系的merge
9.1.3、many-to-many 多对多关系的merge
9.2、理解left join、right join、inner join、outer join的区别
9.2.1、inner join，默认
9.2.2、left join
9.2.3、right join
9.2.4、outer join
9.3、如果出现非Key的字段重名怎么办
10、Pandas实现数据的合并concat
10.1、使用pandas.concat合并数据
10.1.1、默认的concat，参数为axis=0、join=outer、ignore_index=False
10.1.2、使用ignore_index=True可以忽略原来的索引
10.1.3、使用join=inner过滤掉不匹配的列
10.1.4、使用axis=1相当于添加新列
10.2、使用DataFrame.append按行合并数据
10.2.1、给1个dataframe添加另一个dataframe
10.2.2、忽略原来的索引ignore_index=True
10.2.3、可以一行一行的给DataFrame添加数据
10.3、merge和concat的区别
11、Pandas怎样实现groupby分组统计
12、Pandas处理日期数据
准备工作：
链接：https://pan.baidu.com/s/1njXR5DK1REh5xqSMMrRUWw
提取码：nlxx
下面的文件都需要用到这个文件夹
1、安装jupyter在windows里使用"win+r"，d窗出来之后敲击"cmd"，输入"pip install jupyter"就能够安装了。若是使用的是国外源且下载速度较慢的话，我们可以使用"pip install -i + 国内源 + jupyter"，来切换国内源，这样的话，下载速度就比较快了。
1.1、启用jupyter我们需要下载最上边提供的链接文件，并且在这个文件里"Git Bash Here"
进入Git之后，输入下面的内容
$ jupyter notebook
执行上边的代码之后，会d出一个窗口，然后执行就会得到下边的内容
2、 pandas介绍python数据分析三剑客：numpy、pandas、Matplotlib
NumPy(Numerical Python)：Python语言的一个扩展程序库，支持大量的维度数据与矩阵运算，针对数组提供大量的数学函数库 Pandas是一个强大的分析结构化数据的工具集；它的使用基础是Numpy（提供高性能的矩阵运算）；用于数据挖掘和数据分析，同时也提供数据清洗功能。 Matplotlib是一个python绘图包
pandas安装： 1、下载使用Python类库集成安装包：anaconda https://www.anaconda.com 当今最流行的Python数据分析发行版 已经安装了数据分析需要的几乎所有的类库
2、pip3 install pandas
本课程演示方式 使用jupyter Jupyter Notebook 的本质是一个 Web 应用程序，便于创建和共享文学化程序文档，支持实时代码，数学方程，可视化和 markdown。 安装： pip3 install jupyter（需要python3.3或更高版本，或python2.7） 运行： jupyter notebook
2.1、pip3和pip的区别使用pip install XXX
新安装的库会放在这个目录下面
python2.7/site-packages
使用pip3 install XXX
新安装的库会放在这个目录下面
python3.6/site-packages
如果使用python3执行程序，那么就不能import python2.7/site-packages中的库
那么问题来了，我没有py2.7啊
经过实践发现应该是这样的，应该是将包安装在路径里面第一个检索到的pip系列软件在的地方。
由图可以看到，我再一个没有pip的地方pip3了selenium包，所以，它自动检索，将包安装在了pip3第一次出现的地方。 c:\users\challenger\appdata\local\programs\python\python36\lib\site-packages
而且你用pip show是看不到相关信息的，只有pip3 show才行。
而在使用 pip 安装后
大家可以看到，安装位置已经变成：Location: d:\program\anaconda\envs\python36fordrl\lib\site-packages
因此，这也提示我们在使用pip包安装的时候，应该想好用哪个命令
原理
这个是我想起c语言里面 include“”和inluce<>的异同，一个首先检索当前路径是否有相关文件，一个直接进path环境变量里的库检索文件。
而这里也是如此，如果环境里有相关函数则直接使用，没有则到path路径找第一个符合的函数
因为国外源下载很慢，所以我们需要换国内源下载
2.2.1、临时修改# 临时换为清华源下载
pip3 install 库名 -i https://pypi.tuna.tsinghua.edu.cn/simple首先在当前用户目录下建立文件夹.pip，然后在文件夹中创建pip.conf文件，再将源地址加进去即可。
mkdir ~/.pip
vim ~/.pip/pip.conf
# 然后将下面这两行复制进去就好了
[global]
index-url = https://mirrors.aliyun.com/pypi/simple
注意：不管你用的是pip3还是pip，方法都是一样的，都是创建pip文件夹。
2.2.3、国内其他pip源- 清华大学：https://pypi.tuna.tsinghua.edu.cn/simple
- 阿里云:http://mirrors.aliyun.com/pypi/simple/
- 中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
- 华中理工大学：http://pypi.hustunique.com/
- 山东理工大学：http://pypi.sdutlinux.org/
- 豆瓣：http://pypi.douban.com/simple/
Series是一种类似于一维数组的对象，它由一组数据（不同数据类型）以及一组与之相关的数据标签（即索引）组成。Seriers的交互式显示的字符串表示形式是索引在左边，值在右边。 类似一个有序的字典。
3.1.1、 仅有数据列表即可产生最简单的Series>>> import pandas as pd
>>> s1 = pd.Series([1,5,2,7,'a'])
>>> s1
0 1
1 5
2 2
3 7
4 a
dtype: object # 这个是字符串型
>>> s1 = pd.Series([1,5,2,7])
>>> s1
0 1
1 5
2 2
3 7
dtype: int64
>>> s1.index
RangeIndex(start=0, stop=4, step=1)
>>> s1.values
array([1, 5, 2, 7])
>>> s1[0]
1
>>> s1[1]
5
改变s1中的一些类型，会强制改变总的数据类型变为一致的。所以数据类型是统一的。
3.1.2、创建一个具有标签索引的Series>>> s2 = pd.Series([1, 'a', 5.2, 7], index=['d','b','a','c'])
>>> s2
d 1
b a
a 5.2
c 7
dtype: object
>>> s2.index
Index(['d', 'b', 'a', 'c'], dtype='object')
# 可以重复标签
>>> s2 = pd.Series([1, 'a', 5.2, 7], index=['d','b','a','a'])
>>> s2
d 1
b a
a 5.2
a 7
dtype: object
类似Python的字典dict
>>> s2
d 1
b a
a 5.2
c 7
dtype: object
>>> s2['a']
5.2
>>> type(s2['a'])
>>> s2[['b','a']]
b a
a 5.2
dtype: object
>>> type(s2[['b','a']])
DataFrame是一个表格型的数据结构
- 每列可以是不同的值类型（数值、字符串、布尔值等）
- 既有行索引index,也有列索引columns
- 可以被看做由Series组成的字典
>>> data={
... 'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],
... 'year':[2000,2001,2002,2001,2002],
... 'pop':[1.5,1.7,3.6,2.4,2.9]
... }
>>> df = pd.DataFrame(data)
>>> df
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9
>>> df.dtypes
state object
year int64
pop float64
dtype: object
>>> df.columns # 查看有几个列
Index(['state', 'year', 'pop'], dtype='object')
>>> df.index
RangeIndex(start=0, stop=5, step=1)
>>> df['state']
0 Ohio
1 Ohio
2 Ohio
3 Nevada
4 Nevada
Name: state, dtype: object
>>> df['state'][1]
'Ohio'
>>> df[['state','year']] # 拿多列的话，要使用"[[]]"
state year
0 Ohio 2000
1 Ohio 2001
2 Ohio 2002
3 Nevada 2001
4 Nevada 2002
读取csv、txt文件 --> read_csv() 读取xlsx文件 --> read_excel() 读取mysql数据库 --> read_sql() 从网页读取table -->read_html()
>>> fpath = '/root/linux/script/pass_parameter/datas/read_test.csv'
>>> df = pd.read_csv(fpath)
>>> df
date prov isp pv uv
0 2020-04-26 hunan cmnet 2000 1000
1 2020-04-26 hunan cmnet 3000 1500
2 2020-04-26 hunan cmcc 4000 1000
3 2020-04-26 hubei ctc 2500 1000
4 2020-04-26 hubei cmcc 2000 1000
5 2020-04-26 hubei ctc 2100 1600
6 2020-04-27 hunan cmnet 4000 1700
7 2020-04-27 hunan cmnet 3200 1500
8 2020-04-27 hunan cmcc 2800 1600
9 2020-04-27 hubei ctc 2600 1400
10 2020-04-27 hubei cmcc 3800 1900
11 2020-04-27 hubei ctc 2400 1900
[从网页中拉取table数据]
>>> url = 'http://ranking.promisingedu.com/qs'
>>> df = pd.read_html(url)[0]
>>> df
Ranking University English Name ... Overall Score Free
0 1 Massachusetts Institute of Technology (MIT) ... 100.0 免费评估
1 2 牛津大学University of Oxford ... 99.5 免费评估
2 3 Stanford University ... 98.7 免费评估
3 3 剑桥大学University of Cambridge ... 98.7 免费评估
4 5 Harvard University ... 98.0 免费评估
.. ... ... ... ... ...
496 494 Dongguk University ... 24.1 免费评估
497 494 Iowa State University ... 24.1 免费评估
498 494 Sogang University ... 24.1 免费评估
499 494 University of Rome "Tor Vergata" ... 24.1 免费评估
500 494 York University ... 24.1 免费评估
[501 rows x 11 columns]
[从数据库中拉取]
新加内容到数据库里边
4、pandas的基本功能（pandas命令总结）- DataFrame() 创建一个DataFrame对象
- df.values 返回ndarray类型的对象
- df.shape 返回行列数
- df.index 获取行索引
- df.set_index 设置索引
- df.reset_index 重制索引
- df.columns 获取列索引
- df.rename 重新设置列名
- df.dtypes 查看每列数据类型
- df.axes 获取行及列索引
- df.T 行与列对调
- df.info() 打印DataFrame对象的信息
- df.head(i) 显示前 i 行数据
- df.tail(i) 显示后 i 行数据
- df.count() # 返回每一列中的非空值的个数
- df.value_counts() #按值计数
- df.unique() 唯一去从
- df.describe() 查看数据按列的统计信息
- df.sum() # 返回每一列的和, 无法计算返回空, 下同
- df.sum(numeric_only=True) # numeric_only=True代表只计算数字型元素, 下同
- df.max() # 返回每一列的最大值
- df.min() # 返回每一列的最小值
- df.argmax() # 返回最大值所在的自动索引位置，就是从0开始的系统下标
- df.argmin() # 返回最小值所在的自动索引位置
- df.idxmax() # 返回最大值所在的自定义索引位置
- df.idxmin() # 返回最小值所在的自定义索引位置
- df.mean() # 返回每一列的均值
- df.median() # 返回每一列的中位数
- df.var() # 返回每一列的方差
- df.std() # 返回每一列的标准差
- df.isnull() # 检查df中空值, NaN为True, 否则False, 返回一个布尔数组
- df.notnull() # 检查df中空值, 非NaN为True, 否则False, 返回一个布尔数组
pf是一个可变数据类型，若是我们使用"df2=df"的形式来给df2赋值的话，df改变那么df2也会发生改变
>>> fpath = '/root/linux/script/pass_parameter/datas/read_test.csv' # 这个路径是安装本文章中最上边这个链接的文件路径
>>> df = pd.read_csv(fpath) # 用csv格式打开这个文件
>>> df
date prov isp pv uv
0 2020-04-26 hunan cmnet 2000 1000
1 2020-04-26 hunan cmnet 3000 1500
2 2020-04-26 hunan cmcc 4000 1000
3 2020-04-26 hubei ctc 2500 1000
4 2020-04-26 hubei cmcc 2000 1000
5 2020-04-26 hubei ctc 2100 1600
6 2020-04-27 hunan cmnet 4000 1700
7 2020-04-27 hunan cmnet 3200 1500
8 2020-04-27 hunan cmcc 2800 1600
9 2020-04-27 hubei ctc 2600 1400
10 2020-04-27 hubei cmcc 3800 1900
11 2020-04-27 hubei ctc 2400 1900
[把df赋值给其他变量]
>>> df
date prov isp pv uv
0 2020-04-26 hunan cmnet 2000 1000
1 2020-04-26 hunan cmnet 3000 1500
2 2020-04-26 hunan cmcc 4000 1000
3 2020-04-26 hubei ctc 2500 1000
4 2020-04-26 hubei cmcc 2000 1000
5 2020-04-26 hubei ctc 2100 1600
6 2020-04-27 hunan cmnet 4000 1700
7 2020-04-27 hunan cmnet 3200 1500
8 2020-04-27 hunan cmcc 2800 1600
9 2020-04-27 hubei ctc 2600 1400
10 2020-04-27 hubei cmcc 3800 1900
11 2020-04-27 hubei ctc 2400 1900
# 返回ndarray类型的对象
>>> df.values
array([['2020-04-26', 'hunan', 'cmnet', 2000, 1000],
['2020-04-26', 'hunan', 'cmnet', 3000, 1500],
['2020-04-26', 'hunan', 'cmcc', 4000, 1000],
['2020-04-26', 'hubei', 'ctc', 2500, 1000],
['2020-04-26', 'hubei', 'cmcc', 2000, 1000],
['2020-04-26', 'hubei', 'ctc', 2100, 1600],
['2020-04-27', 'hunan', 'cmnet', 4000, 1700],
['2020-04-27', 'hunan', 'cmnet', 3200, 1500],
['2020-04-27', 'hunan', 'cmcc', 2800, 1600],
['2020-04-27', 'hubei', 'ctc', 2600, 1400],
['2020-04-27', 'hubei', 'cmcc', 3800, 1900],
['2020-04-27', 'hubei', 'ctc', 2400, 1900]], dtype=object)
# 查看数据的形状，返回（行数、列数）
>>> df.shape
(12, 5)
#查看行索引
>>> df.index
RangeIndex(start=0, stop=12, step=1)
>>> df2 = df.set_index('date') # 以"date"作为行标排序
>>> df2
prov isp pv uv
date
2020-04-26 hunan cmnet 2000 1000
2020-04-26 hunan cmnet 3000 1500
2020-04-26 hunan cmcc 4000 1000
2020-04-26 hubei ctc 2500 1000
2020-04-26 hubei cmcc 2000 1000
2020-04-26 hubei ctc 2100 1600
2020-04-27 hunan cmnet 4000 1700
2020-04-27 hunan cmnet 3200 1500
2020-04-27 hunan cmcc 2800 1600
2020-04-27 hubei ctc 2600 1400
2020-04-27 hubei cmcc 3800 1900
2020-04-27 hubei ctc 2400 1900
# "inplace=True"表示在原基础上作出修改；"drop=True"，表示把行标去掉
>>> df2.reset_index(inplace = True, drop = True)
>>> df2
prov isp pv uv
0 hunan cmnet 2000 1000
1 hunan cmnet 3000 1500
2 hunan cmcc 4000 1000
3 hubei ctc 2500 1000
4 hubei cmcc 2000 1000
5 hubei ctc 2100 1600
6 hunan cmnet 4000 1700
7 hunan cmnet 3200 1500
8 hunan cmcc 2800 1600
9 hubei ctc 2600 1400
10 hubei cmcc 3800 1900
11 hubei ctc 2400 1900
# 获得列索引
>>> df.columns
Index(['date', 'prov', 'isp', 'pv', 'uv'], dtype='object')
#重新设置列表名，必须要所有的列都打上
df2 = df.copy()
df2.columns=['a','b','c','d','e']
df2
#重新设置列表名,可以只设置一部分
>>>df2.rename(columns = {'a':'日期','b':'省份','c':'运营商','d':'pv','e':'uv'}, inplace = True)
>>> df2
日期 省份 运营商 pv uv
0 2020-04-26 hunan cmnet 2000 1000
1 2020-04-26 hunan cmnet 3000 1500
2 2020-04-26 hunan cmcc 4000 1000
3 2020-04-26 hubei ctc 2500 1000
4 2020-04-26 hubei cmcc 2000 1000
5 2020-04-26 hubei ctc 2100 1600
6 2020-04-27 hunan cmnet 4000 1700
7 2020-04-27 hunan cmnet 3200 1500
8 2020-04-27 hunan cmcc 2800 1600
9 2020-04-27 hubei ctc 2600 1400
10 2020-04-27 hubei cmcc 3800 1900
11 2020-04-27 hubei ctc 2400 1900
#查看每列数据类型，object为通用数据类型，一般某列中有多种数据类型，或者全为str，则类型为object。默认int、float类型的位数为 *** 作系统位数。
>>> df.dtypes
date object
prov object
isp object
pv int64
uv int64
dtype: object
- df[]按行列选取，这种情况一次只能选取行或者列
- df.loc方法，根据行、列的标签值查询
- df.iloc方法，根据行、列的数字位置查询，根据索引定位
- df.query方法
数据转换函数对比：map、apply、applymap：
- map：只用于Series，实现每个值->值的映射；
- apply：用于Series实现每个值的处理，用于Dataframe实现某个轴的Series的处理；
- applymap：只能用于DataFrame，用于处理该DataFrame的每个元素；
Pandas使用这些函数处理缺失值：
- isnull和notnull：检测是否是空值，可用于df和series
- dropna：丢弃、删除缺失值
- axis : 删除行还是列，{0 or ‘index’, 1 or ‘columns’}, default 0
- how : 如果等于any则任何值为空都删除，如果等于all则所有值都为空才删除
- inplace : 如果为True则修改当前df，否则返回新的df
- fillna：填充空值
- value：用于填充的值，可以是单个值，或者字典（key是列名，value是值）
- method : 等于ffill使用前一个不为空的值填充forword fill；等于bfill使用后一个不为空的值填充backword fill
- axis : 按行还是列填充，{0 or ‘index’, 1 or ‘columns’}
- inplace : 如果为True则修改当前df，否则返回新的df
实列：特殊Excel的读取、清洗、处理。前提准备：安装openpyxl或者xlrd
步骤1：读取excel的时候，忽略前几个空行
import pandas as pd
studf = pd.read_excel("student_excel.xlsx", skiprows=2)
>>> studf
Unnamed: 0 姓名 科目 分数
0 NaN 小明 语文 85.0
1 NaN NaN 数学 80.0
2 NaN NaN 英语 90.0
3 NaN NaN NaN NaN
4 NaN 小王 语文 85.0
5 NaN NaN 数学 NaN
6 NaN NaN 英语 90.0
7 NaN NaN NaN NaN
8 NaN 小刚 语文 85.0
9 NaN NaN 数学 80.0
10 NaN NaN 英语 90.0
若是出现“xlrd.biffh.XLRDError: Excel xlsx file; not supported”的情况，那就是你的xlrd版本过高。我安装的xlrd版本为2以上的版本，程序报错主要是xlrd的2.0以上版本不支持后缀名.xlsx文件的读取，支持.xls文件的读取。
那么你可以这么使用
# 两个命令，选其中一个就行了
studf = pd.read_excel("student_excel.xlsx", skiprows=2,engine="openpyxl")
# 或者安装"pip3 install xlrd==1.2.0"的版本，再执行下面那个命令
studf = pd.read_excel("student_excel.xlsx", skiprows=2)
步骤2：检测空值
# 没有空值的就为False，有就为True
>>> studf.isnull()
Unnamed: 0 姓名 科目 分数
0 True False False False
1 True True False False
2 True True False False
3 True True True True
4 True False False False
5 True True False True
6 True True False False
7 True True True True
8 True False False False
9 True True False False
10 True True False False
########################################################
>>> studf["分数"].isnull()
0 False
1 False
2 False
3 True
4 False
5 True
6 False
7 True
8 False
9 False
10 False
Name: 分数, dtype: bool
################################################
>>> studf["分数"].notnull()
0 True
1 True
2 True
3 False
4 True
5 False
6 True
7 False
8 True
9 True
10 True
Name: 分数, dtype: bool
###########################
# 筛选没有空分数的所有行
>>> studf.loc[studf["分数"].notnull(), :]
Unnamed: 0 姓名 科目 分数
0 NaN 小明 语文 85.0
1 NaN NaN 数学 80.0
2 NaN NaN 英语 90.0
4 NaN 小王 语文 85.0
6 NaN NaN 英语 90.0
8 NaN 小刚 语文 85.0
9 NaN NaN 数学 80.0
10 NaN NaN 英语 90.0
步骤3：删除掉全是空值的列
# 当列全为NAN就删除这列
>>> studf.dropna(axis="columns", how="all", inplace=True)
>>> studf
姓名 科目 分数
0 小明 语文 85.0
1 NaN 数学 80.0
2 NaN 英语 90.0
3 NaN NaN NaN
4 小王 语文 85.0
5 NaN 数学 NaN
6 NaN 英语 90.0
7 NaN NaN NaN
8 小刚 语文 85.0
9 NaN 数学 80.0
10 NaN 英语 90.0
步骤4：删除掉全是空值的行
>>> studf.dropna(axis="index", how='all', inplace=True)
>>> studf
姓名 科目 分数
0 小明 语文 85.0
1 NaN 数学 80.0
2 NaN 英语 90.0
4 小王 语文 85.0
5 NaN 数学 NaN
6 NaN 英语 90.0
8 小刚 语文 85.0
9 NaN 数学 80.0
10 NaN 英语 90.0
#下面两个命令都可以执行
# studf.loc[:, '分数'] = studf['分数'].fillna(0)
>>> studf["分数"] = studf["分数"].fillna(0)
>>> studf
姓名 科目 分数
0 小明 语文 85.0
1 NaN 数学 80.0
2 NaN 英语 90.0
4 小王 语文 85.0
5 NaN 数学 0.0
6 NaN 英语 90.0
8 小刚 语文 85.0
9 NaN 数学 80.0
10 NaN 英语 90.0
使用前面的有效值填充，用ffill：forward fill 向后填充，用bfill：before fill，向前填充
>>> studf['姓名'] = studf['姓名'].fillna(method="ffill")
>>> studf
姓名 科目 分数
0 小明 语文 85.0
1 小明 数学 80.0
2 小明 英语 90.0
4 小王 语文 85.0
5 小王 数学 1.0
6 小王 英语 90.0
8 小刚 语文 85.0
9 小刚 数学 80.0
10 小刚 英语 90.0
>>> studf2 = pd.read_excel("student_excel_clean.xlsx",engine="openpyxl")
>>> studf2
姓名 科目 分数
0 小明 语文 85
1 小明 数学 80
2 小明 英语 90
3 小王 语文 85
4 小王 数学 1
5 小王 英语 90
6 小刚 语文 85
7 小刚 数学 80
8 小刚 英语 90
#################################
>>> studf3 = pd.read_excel("student_excel_clean.xlsx",engine="openpyxl")
>>> studf3
Unnamed: 0 姓名 科目 分数
0 0 小明 语文 85
1 1 小明 数学 80
2 2 小明 英语 90
3 4 小王 语文 85
4 5 小王 数学 1
5 6 小王 英语 90
6 8 小刚 语文 85
7 9 小刚 数学 80
8 10 小刚 英语 90
Series的排序：
Series.sort_values(ascending=True, inplace=False)
参数说明：
- ascending：默认为True升序排序，为False降序排序
- inplace：是否修改原始Series
DataFrame的排序：
DataFrame.sort_values(by, ascending=True, inplace=False)
参数说明：
- by：字符串或者List<字符串>，单列排序或者多列排序
- ascending：bool或者List，升序还是降序，如果是list对应by的多列
- inplace：是否修改原始DataFrame
>>> import pandas as pd
>>> fpath = "beijing_tianqi_2018.csv"
>>> df = pd.read_csv(fpath)
>>> df["bWendu"] = df["bWendu"].str.replace("℃", "").astype('int64')
>>> df["yWendu"] = df["yWendu"].str.replace("℃", "").astype('int64')
>>> df.head()
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
0 2018-01-01 3 -6 晴~多云 东北风 1-2级 59 良 2
1 2018-01-02 2 -5 阴~多云 东北风 1-2级 49 优 1
2 2018-01-03 2 -5 多云 北风 1-2级 28 优 1
3 2018-01-04 0 -8 阴 东北风 1-2级 28 优 1
4 2018-01-05 3 -6 多云~晴 西北风 1-2级 50 优 1
>>> df["aqi"].sort_values()
271 21
281 21
249 22
272 22
301 22
...
317 266
71 287
91 287
72 293
86 387
Name: aqi, Length: 365, dtype: int64
####################################
>>> df["aqi"].sort_values(ascending=False)
86 387
72 293
91 287
71 287
317 266
...
301 22
272 22
249 22
281 21
271 21
Name: aqi, Length: 365, dtype: int64
####################################
# 用中文的万国码排序的，默认升序
>>> df["tianqi"].sort_values()
225 中雨~小雨
230 中雨~小雨
197 中雨~雷阵雨
196 中雨~雷阵雨
112 多云
...
191 雷阵雨~大雨
219 雷阵雨~阴
335 雾~多云
353 霾
348 霾
Name: tianqi, Length: 365, dtype: object
>>> df.sort_values(by='aqi')
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
271 2018-09-29 22 11 晴 北风 3-4级 21 优 1
281 2018-10-09 15 4 多云~晴 西北风 4-5级 21 优 1
249 2018-09-07 27 16 晴 西北风 3-4级 22 优 1
272 2018-09-30 19 13 多云 西北风 4-5级 22 优 1
301 2018-10-29 15 3 晴 北风 3-4级 22 优 1
.. ... ... ... ... ... ... ... ... ...
317 2018-11-14 13 5 多云 南风 1-2级 266 重度污染 5
71 2018-03-13 17 5 晴~多云 南风 1-2级 287 重度污染 5
91 2018-04-02 26 11 多云 北风 1-2级 287 重度污染 5
72 2018-03-14 15 6 多云~阴 东北风 1-2级 293 重度污染 5
86 2018-03-28 25 9 多云~晴 东风 1-2级 387 严重污染 6
[365 rows x 9 columns]
###################################
>>> df.sort_values(by="aqi", ascending=False)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
86 2018-03-28 25 9 多云~晴 东风 1-2级 387 严重污染 6
72 2018-03-14 15 6 多云~阴 东北风 1-2级 293 重度污染 5
71 2018-03-13 17 5 晴~多云 南风 1-2级 287 重度污染 5
91 2018-04-02 26 11 多云 北风 1-2级 287 重度污染 5
317 2018-11-14 13 5 多云 南风 1-2级 266 重度污染 5
.. ... ... ... ... ... ... ... ... ...
249 2018-09-07 27 16 晴 西北风 3-4级 22 优 1
301 2018-10-29 15 3 晴 北风 3-4级 22 优 1
272 2018-09-30 19 13 多云 西北风 4-5级 22 优 1
271 2018-09-29 22 11 晴 北风 3-4级 21 优 1
281 2018-10-09 15 4 多云~晴 西北风 4-5级 21 优 1
[365 rows x 9 columns]
# 按空气质量等级、最高温度排序，默认升序
>>> df.sort_values(by=["aqiLevel","bWendu"])
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
360 2018-12-27 -5 -12 多云~晴 西北风 3级 48 优 1
22 2018-01-23 -4 -12 晴 西北风 3-4级 31 优 1
23 2018-01-24 -4 -11 晴 西南风 1-2级 34 优 1
340 2018-12-07 -4 -10 晴 西北风 3级 33 优 1
21 2018-01-22 -3 -10 小雪~多云 东风 1-2级 47 优 1
.. ... ... ... ... ... ... ... ... ...
71 2018-03-13 17 5 晴~多云 南风 1-2级 287 重度污染 5
90 2018-04-01 25 11 晴~多云 南风 1-2级 218 重度污染 5
91 2018-04-02 26 11 多云 北风 1-2级 287 重度污染 5
85 2018-03-27 27 11 晴 南风 1-2级 243 重度污染 5
86 2018-03-28 25 9 多云~晴 东风 1-2级 387 严重污染 6
[365 rows x 9 columns]
############################################
>>> df.sort_values(by=["aqiLevel","bWendu"],ascending=False)
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
86 2018-03-28 25 9 多云~晴 东风 1-2级 387 严重污染 6
85 2018-03-27 27 11 晴 南风 1-2级 243 重度污染 5
91 2018-04-02 26 11 多云 北风 1-2级 287 重度污染 5
90 2018-04-01 25 11 晴~多云 南风 1-2级 218 重度污染 5
71 2018-03-13 17 5 晴~多云 南风 1-2级 287 重度污染 5
.. ... ... ... ... ... ... ... ... ...
362 2018-12-29 -3 -12 晴 西北风 2级 29 优 1
22 2018-01-23 -4 -12 晴 西北风 3-4级 31 优 1
23 2018-01-24 -4 -11 晴 西南风 1-2级 34 优 1
340 2018-12-07 -4 -10 晴 西北风 3级 33 优 1
360 2018-12-27 -5 -12 多云~晴 西北风 3级 48 优 1
[365 rows x 9 columns]
################################
>>> df.sort_values(by=["aqiLevel","bWendu"],ascending=[True,False])
ymd bWendu yWendu tianqi fengxiang fengli aqi aqiInfo aqiLevel
178 2018-06-28 35 24 多云~晴 北风 1-2级 33 优 1
149 2018-05-30 33 18 晴 西风 1-2级 46 优 1
206 2018-07-26 33 25 多云~雷阵雨 东北风 1-2级 40 优 1
158 2018-06-08 32 19 多云~雷阵雨 西南风 1-2级 43 优 1
205 2018-07-25 32 25 多云 北风 1-2级 28 优 1
.. ... ... ... ... ... ... ... ... ...
317 2018-11-14 13 5 多云 南风 1-2级 266 重度污染 5
329 2018-11-26 10 0 多云 东南风 1级 245 重度污染 5
335 2018-12-02 9 2 雾~多云 东北风 1级 234 重度污染 5
57 2018-02-27 7 0 阴 东风 1-2级 220 重度污染 5
86 2018-03-28 25 9 多云~晴 东风 1-2级 387 严重污染 6
[365 rows x 9 columns]
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=True, suffixes=('_x', '_y'), copy=True, indicator=False, validate=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或者seires的key
- left_index，right_index：使用index而不是普通的column做join
- suffixes：两个元素的后缀，如果列有重名，自动添加后缀，默认是('_x', '_y')
文档地址：pandas.DataFrame.merge — pandas 1.4.2 documentation
准备工作
>>> left = pd.DataFrame({'A': ['a0', 'a1', 'a2', 'a3'],
... 'B': ['b0', 'b1', 'b2', 'b3'],
... 'k1': ['x', 'x', 'y', 'y']})
>>> right = pd.DataFrame({'C': ['c1', 'c2', 'c3', 'c4'],
... 'D': ['d1', 'd2', 'd3', 'd4'],
... 'k1': ['y', 'y', 'z', 'z']})
>>> left
A B k1
0 a0 b0 x
1 a1 b1 x
2 a2 b2 y
3 a3 b3 y
>>> right
C D k1
0 c1 d1 y
1 c2 d2 y
2 c3 d3 z
3 c4 d4 z
# 默认inner，即取交集
>>> pd.merge(left,right,on="k1")
A B k1 C D
0 a2 b2 y c1 d1
1 a2 b2 y c2 d2
2 a3 b3 y c1 d1
3 a3 b3 y c2 d2
可以看到只有left和right的key1=y的行保留了下来，即默认合并后只保留有共同列项并且值相等行（即交集）。
本例中left和right的k1=y分别有2个，最终构成了2*2=4行
若是左右的key不一样的话，比如下面这种情况
>>> left = pd.DataFrame({'A': ['a0', 'a1', 'a2', 'a3'],
... 'B': ['b0', 'b1', 'b2', 'b3'],
... 'k1': ['x', 'x', 'y', 'y']})
>>> right = pd.DataFrame({'C': ['c1', 'c2', 'c3', 'c4'],
... 'D': ['d1', 'd2', 'd3', 'd4'],
... 'k2': ['y', 'y', 'z', 'z']})
########################################
>>> right
C D k2
0 c1 d1 y
1 c2 d2 y
2 c3 d3 z
3 c4 d4 z
>>> left
A B k1
0 a0 b0 x
1 a1 b1 x
2 a2 b2 y
3 a3 b3 y
#######################################
# 就用left_on和right_on，区别基准
>>> pd.merge(left,right,left_on='k1',right_on='k2')
A B k1 C D k2
0 a2 b2 y c1 d1 y
1 a2 b2 y c2 d2 y
以下关系要正确理解：
- one-to-one：一对一关系，关联的key都是唯一的
- 比如(学号，姓名) merge (学号，年龄)
- 结果条数为：1*1
- one-to-many：一对多关系，左边唯一key，右边不唯一key
- 比如(学号，姓名) merge (学号，[语文成绩、数学成绩、英语成绩])
- 结果条数为：1*N
- many-to-many：多对多关系，左边右边都不是唯一的
- 比如（学号，[语文成绩、数学成绩、英语成绩]） merge (学号，[篮球、足球、乒乓球])
- 结果条数为：M*N
3 a3 b3 y c2 d2
>>> left = pd.DataFrame({'sno': [11, 12, 13, 14],
... 'name': ['name_a', 'name_b', 'name_c', 'name_d']
... })
>>> left
sno name
0 11 name_a
1 12 name_b
2 13 name_c
3 14 name_d
########################
>>> right = pd.DataFrame({'sno':[11,12,13,14],'age':['21','22','23','24']})
>>> right
sno age
0 11 21
1 12 22
2 13 23
3 14 24
#########################
# 一对一关系，结果中有4条
>>> pd.merge(left,right,on='sno')
sno name age
0 11 name_a 21
1 12 name_b 22
2 13 name_c 23
3 14 name_d 24
注意：数据会被复制
>>> left = pd.DataFrame({'sno': [11, 12, 13, 14],
... 'name': ['name_a', 'name_b', 'name_c', 'name_d']
... })
>>> left
sno name
0 11 name_a
1 12 name_b
2 13 name_c
3 14 name_d
################################################
>>> right = pd.DataFrame({'sno': [11, 11, 11, 12, 12, 13],
... 'grade': ['语文88', '数学90', '英语75','语文66', '数学55', '英语29']
... })
>>> right
sno grade
0 11 语文88
1 11 数学90
2 11 英语75
3 12 语文66
4 12 数学55
5 13 英语29
############################
>>> pd.merge(left,right,on='sno')
sno name grade
0 11 name_a 语文88
1 11 name_a 数学90
2 11 name_a 英语75
3 12 name_b 语文66
4 12 name_b 数学55
5 13 name_c 英语29
>>> left = pd.DataFrame({'sno': [11, 11, 12, 12,12],
... '爱好': ['篮球', '羽毛球', '乒乓球', '篮球', "足球"]
... })
>>> left
sno 爱好
0 11 篮球
1 11 羽毛球
2 12 乒乓球
3 12 篮球
4 12 足球
>>> right = pd.DataFrame({'sno': [11, 11, 11, 12, 12, 13],
... 'grade': ['语文88', '数学90', '英语75','语文66', '数学55', '英语29']
... })
>>> right
sno grade
0 11 语文88
1 11 数学90
2 11 英语75
3 12 语文66
4 12 数学55
5 13 英语29
>>> pd.merge(left, right, on='sno')
sno 爱好 grade
0 11 篮球 语文88
1 11 篮球 数学90
2 11 篮球 英语75
3 11 羽毛球 语文88
4 11 羽毛球 数学90
5 11 羽毛球 英语75
6 12 乒乓球 语文66
7 12 乒乓球 数学55
8 12 篮球 语文66
9 12 篮球 数学55
10 12 足球 语文66
11 12 足球 数学55
>>> left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
... 'A': ['A0', 'A1', 'A2', 'A3'],
... 'B': ['B0', 'B1', 'B2', 'B3']})
>>>
>>> right = pd.DataFrame({'key': ['K0', 'K1', 'K4', 'K5'],
... 'C': ['C0', 'C1', 'C4', 'C5'],
... 'D': ['D0', 'D1', 'D4', 'D5']})
>>> left
key A B
0 K0 A0 B0
1 K1 A1 B1
2 K2 A2 B2
3 K3 A3 B3
>>> right
key C D
0 K0 C0 D0
1 K1 C1 D1
2 K4 C4 D4
3 K5 C5 D5
左边和右边的key都有，才会出现在结果里
>>> pd.merge(left,right,how='inner')
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
左边的都会出现在结果里，右边的如果无法匹配则为Null
>>> pd.merge(left,right,how='left')
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 NaN NaN
3 K3 A3 B3 NaN NaN
右边的都会出现在结果里，左边的如果无法匹配则为Null
>>> pd.merge(left,right,how='right')
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K4 NaN NaN C4 D4
3 K5 NaN NaN C5 D5
左边、右边的都会出现在结果里，如果无法匹配则为Null
>>> pd.merge(left,right,how='outer')
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 NaN NaN
3 K3 A3 B3 NaN NaN
4 K4 NaN NaN C4 D4
5 K5 NaN NaN C5 D5
>>> left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
... 'A': ['A0', 'A1', 'A2', 'A3'],
... 'B': ['B0', 'B1', 'B2', 'B3']})
>>>
>>> right = pd.DataFrame({'key': ['K0', 'K1', 'K4', 'K5'],
... 'A': ['A10', 'A11', 'A12', 'A13'],
... 'D': ['D0', 'D1', 'D4', 'D5']})
>>> left
key A B
0 K0 A0 B0
1 K1 A1 B1
2 K2 A2 B2
3 K3 A3 B3
>>> right
key A D
0 K0 A10 D0
1 K1 A11 D1
2 K4 A12 D4
3 K5 A13 D5
>>> pd.merge(left,right,on='key')
key A_x B A_y D
0 K0 A0 B0 A10 D0
1 K1 A1 B1 A11 D1
#####################################
# suffixes：两个元素的后缀，如果列有重名，自动添加后缀，默认是('_x', '_y')
>>> pd.merge(left, right, on='key', suffixes=('_left', '_right'))
key A_left B A_right D
0 K0 A0 B0 A10 D0
1 K1 A1 B1 A11 D1
使用场景：
批量合并相同格式的Excel、给DataFrame添加行、给DataFrame添加列
一句话说明concat语法：
- 使用某种合并方式(inner/outer)
- 沿着某个轴向(axis=0/1)
- 把多个Pandas对象(DataFrame/Series)合并成一个。
concat语法：pandas.concat(objs, axis=0, join='outer', ignore_index=False)
- objs：一个列表，内容可以是DataFrame或者Series，可以混合
- axis：默认是0代表按行合并，如果等于1代表按列合并
- join：合并的时候索引的对齐方式，默认是outer join，也可以是inner join
- ignore_index：是否忽略掉原来的数据索引
append语法：DataFrame.append(other, ignore_index=False)
append只有按行合并，没有按列合并，相当于concat按行的简写形式
- other：单个dataframe、series、dict，或者列表
- ignore_index：是否忽略掉原来的数据索引
参考文档：
- pandas.concat的api文档：pandas.concat — pandas 1.4.2 documentation
- pandas.concat的教程：Merge, join, concatenate and compare — pandas 1.4.2 documentation
- pandas.append的api文档：pandas.DataFrame.append — pandas 1.4.2 documentation
准备工作
>>> 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
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
###########################################
>>> df2 = pd.DataFrame({ 'A': ['A4', 'A5', 'A6', 'A7'],
... 'B': ['B4', 'B5', 'B6', 'B7'],
... 'C': ['C4', 'C5', 'C6', 'C7'],
... 'D': ['D4', 'D5', 'D6', 'D7'],
... 'F': ['F4', 'F5', 'F6', 'F7']
... })
>>> df2
A B C D F
0 A4 B4 C4 D4 F4
1 A5 B5 C5 D5 F5
2 A6 B6 C6 D6 F6
3 A7 B7 C7 D7 F7
>>> pd.concat([df1,df2])
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 B4 C4 D4 NaN F4
1 A5 B5 C5 D5 NaN F5
2 A6 B6 C6 D6 NaN F6
3 A7 B7 C7 D7 NaN F7
>>> pd.concat([df1,df2], ignore_index=True)
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
4 A4 B4 C4 D4 NaN F4
5 A5 B5 C5 D5 NaN F5
6 A6 B6 C6 D6 NaN F6
7 A7 B7 C7 D7 NaN F7
>>> pd.concat([df1,df2], ignore_index=True, join='inner')
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
>>> df1
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
（1）添加一列Series
>>> s1 = pd.Series(list(range(4)), name="F")
>>> pd.concat([df1,s1], axis=1)
A B C D E F
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）添加多列Series
>>> s2 = df1.apply(lambda x:x["A"]+"_GG",axis=1)
>>> s2
0 A0_GG
1 A1_GG
2 A2_GG
3 A3_GG
dtype: object
>>> s2.name="G"
# 原来基础上并没有发生改变
>>> pd.concat([df1,s1,s2], axis=1)
A B C D E F G
0 A0 B0 C0 D0 E0 0 A0_GG
1 A1 B1 C1 D1 E1 1 A1_GG
2 A2 B2 C2 D2 E2 2 A2_GG
3 A3 B3 C3 D3 E3 3 A3_GG
# 列表可以只有Series
>>> pd.concat([s1,s2], axis=1)
F G
0 0 A0_GG
1 1 A1_GG
2 2 A2_GG
3 3 A3_GG
##########################
# 列表是可以混合顺序的
>>> pd.concat([s1,df1,s2], axis=1)
F A B C D E G
0 0 A0 B0 C0 D0 E0 A0_GG
1 1 A1 B1 C1 D1 E1 A1_GG
2 2 A2 B2 C2 D2 E2 A2_GG
3 3 A3 B3 C3 D3 E3 A3_GG
>>> df1 = pd.DataFrame([[1,2], [3,4]], columns=list('AB'))
>>> df1
A B
0 1 2
1 3 4
>>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
>>> df2
A B
0 5 6
1 7 8
>>> df1.append(df2)
A B
0 1 2
1 3 4
0 5 6
1 7 8
>>> df1.append(df2, ignore_index=True)
A B
0 1 2
1 3 4
2 5 6
3 7 8
>>> df = pd.DataFrame(columns=['A'])
>>> df
Empty DataFrame
Columns: [A]
Index: []
（1）低性能版本
for i in range(5):
# 注意这里每次都在复制
df = df.append({'A': i}, ignore_index=True)
df
>>> for i in range(5):
... df = df.append({'A':i}, ignore_index=True)
...
>>> df
A
0 0
1 1
2 2
3 3
4 4
（2）性能好的版本
# 第一个入参是一个列表，避免了多次复制
pd.concat(
[pd.DataFrame([i], columns=['A']) for i in range(5)],
ignore_index=True
)
#####################
>>> pd.concat(
... [pd.DataFrame([i], columns=['A']) for i in range(5)],
... ignore_index=True
... )
A
0 0
1 1
2 2
3 3
4 4
merge一次只能 *** 作两个DataFrame，但是concat能 *** 作多个
11、Pandas怎样实现groupby分组统计类似SQL：
select city,max(temperature) from city_weather group by city;
groupby：先对数据分组，然后在每个分组上应用聚合函数、转换函数
本次演示：
一、分组使用聚合函数做数据统计
二、遍历groupby的结果理解执行流程
三、实例分组探索天气数据
Pandas日期处理的作用：将2018-01-01、1/1/2018等多种日期格式映射成统一的格式对象，在该对象上提供强大的功能支持
几个概念：
- pd.to_datetime：pandas的一个函数，能将字符串、列表、series变成日期形式
- Timestamp：pandas表示日期的对象形式
- DatetimeIndex：pandas表示日期的对象列表形式
其中：
- DatetimeIndex是Timestamp的列表形式
- pd.to_datetime对单个日期字符串处理会得到Timestamp
- pd.to_datetime对日期字符串列表处理会得到DatetimeIndex
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）