27. Pandas

Hi, 大家好。我是茶桁。

先跟小伙伴们打个招呼，今天这节课呢，就是我们Python基础课程的最后一节课了。

在本节课之前，我们讲解了Python的基础，介绍了两个第三方库。而今天一样会介绍一个第三方库：Pandas。

虽然是最后一节课了，但是本节课的任务却是一点也不轻松。相比较而言，如果你以后从事的是数据治理和分析工作，那么本节课的内容可能会是你在今后工作中用到的最多的内容。我们需要学习行列索引的操作，数据的处理，数据的合并，多层索引，时间序列，数据的分组聚合（重点）。最后，我们会有一个案例的展示。

听着是不是很兴奋？那我们就开始吧。

在开始讲解pandas之前，我们讲解一些关于数据的小知识。

我们大部分人应该都用过Excel表格，而我们从数据库中拿到的数据，也基本上和Excel上的数据差不多，都是由行列组成的。可以直接导出为csv文件。

也就是说，我们大部分时候要处理的数据，基本上都一组二维数据。例如，我们今天最后案例要用到的一个电影数据(部分)，如图：

这里面，我们就将数据通过行列来展示和定位。

了解了这一点之后，我们来开始学习pandas。

Pandas简介

在之前的介绍中，我们发现很多的操作似乎都似曾相识，在NumPy中我们好像都接触过。

有这种感觉很正常，Pandas本身就是基于NumPy的一种工具，该⼯具是为了解决数据分析任务⽽创建的。Pandas 纳⼊了⼤量库和⼀些标准的数据模型，提供了⾼效地操作⼤型数据集所需的⼯具。pandas提供了⼤量能使我们快速 便捷地处理数据的函数和⽅法。

Series对象

Pandas基于两种数据类型：series与dataframe。

Series是Pandas中最基本的对象，Series类似⼀种⼀维数组。事实上，Series基本上就是基于NumPy的数组对象来的。和 NumPy的数组不同，Series能为数据⾃定义标签，也就是索引（index），然后 通过索引来访问数组中的数据。

Dataframe是⼀个⼆维的表结构。Pandas的dataframe可以存储许多种不同的数据类型，并且每⼀个坐标轴都有⾃⼰的标签。你可以把它想象成⼀个series的字典项。

在开始基于代码进行学习之前，我们需要应用一些必要项。

import numpy as np
import pandas as pd
from pandas import Series
from pandas import DataFrame as df

现在我们来看看Series的一些基本操作：

创建Series对象并省略索引

index 参数是可省略的，你可以选择不输⼊这个参数。如果不带 index 参数，Pandas 会⾃动⽤默认 index 进⾏索引，类似数组，索引值是 [0, ..., len(data) - 1]

sel = Series([1,2,3,4])
print(sel)

---
0    1
1    2
2    3
3    4
dtype: int64

我们之前在NumPy中学习了dtype, 以及它的相关数据类型。所以现在的dtype: int64我们应该能理解是什么意思了。

我们看打印的结果，在1,2,3,4前面，是Series默认生成的索引值。

通常我们会⾃⼰创建索引

sel = Series(data=[1,2,3,4], index= list('abcd'))
print(sel)

---
a    1
b    2
c    3
d    4
dtype: int64

这个时候，我们可以对这个Series对象操作分别获取内容和索引：

print(f'values: {sel.values}')
print(sel.index)

---
values: [1 2 3 4]
Index(['a', 'b', 'c', 'd'], dtype='object')

又或者，我们可以直接获取健值对（索引和值对）。

print(list(sel.iteritems()))

---
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

那么这种健值对的形式让你想到了什么？是字典对吧？

我们完全可以将字典转为Series:

dict={"red":100,"black":400,"green":300,"pink":900}
se3=Series(dict) 
print(se3)

---
red      100
black    400
green    300
pink     900
dtype: int64

Series数据获取

在Series拿到数据转为Series对象之后，诺大的数据中，我们如何定位并获取到我们想要的内容呢？

Series在获取数据上，支持位置、标签、获取不连续数据，使用切片等方式。我们一个个的看一下：

Series对象同时⽀持位置和标签两种⽅式获取数据

print('索引下标',sel['c'])
print('位置下标',sel[2])

---
索引下标 3
位置下标 3

获取不连续的数据

print('位置切⽚\n',sel[1:3])# 左包含右不包含
print('\n索引切⽚\n',sel['b':'d'])# 左右都包含

---
位置切⽚
b    2
c    3
dtype: int64

索引切⽚
b    2
c    3
d    4
dtype: int64

我们看到结果，发现两组数据数量不对，但是其实我们获取的位置都是一样的。这是因为，位置切片的方式会是「左包含右不包含」的，而索引切片则是「左右都包含」。

重新赋值索引的值

除了获取数据之外，我们还可以对数据进行重新索引。其实在之前我们将索引的时候，第二种自己赋值的方式实际上就是一个重新赋值了，将自己定义的值替换了默认值。这里让我们再来看一下：

sel.index = list('dcba')
print(sel)

---
d    1
c    2
b    3
a    4
dtype: int64

还有一种重新索引的方法reindex， 这会返回一个新的Series。调用reindex将会重新排序，缺失值这会用NaN填补。

print(sel.reindex(['b','a','c','d','e']))

---
b    3.0
a    4.0
c    2.0
d    1.0
e    NaN
dtype: float64

在重新索引的时候，我们特意多增加了一个索引。在最后一位没有数据的情况下，缺失值被NaN填补上了。

丢弃指定轴上的项

sel = pd.Series(range(10, 15))
print(sel)
print(sel.drop([2,3]))

---
0    10
1    11
2    12
3    13
4    14
dtype: int64
0    10
1    11
4    14
dtype: int64

使用drop，会丢弃掉轴上的项，例子中，我们将2，3进行了丢弃。

Series进⾏算术运算操作

对 Series 的算术运算都是基于 index 进⾏的。我们可以⽤加减乘除（+ - * /）这样的运算符对两个 Series 进⾏运算，Pandas 将会根据索引 index，对响应的数据进⾏计算，结果将会以浮点数的形式存储，以避免丢失精度。如果 Pandas 在两个 Series ⾥找不到相同的 index，对应的位置就返回⼀个空值 NaN。

# Series 算数运算
series1 = pd.Series([1,2,3,4],['London','HongKong','Humbai','lagos'])
series2 = pd.Series([1,3,6,4],['London','Accra','lagos','Delhi'])

print('series1-series2:')
print(series1-series2) 
print('\nseries1+series2:')
print(series1+series2) 
print('\nseries1*series2:')
print(series1*series2)

---
series1-series2:
Accra       NaN
Delhi       NaN
HongKong    NaN
Humbai      NaN
London      0.0
lagos      -2.0
dtype: float64

series1+series2:
Accra        NaN
Delhi        NaN
HongKong     NaN
Humbai       NaN
London       2.0
lagos       10.0
dtype: float64

series1*series2:
Accra        NaN
Delhi        NaN
HongKong     NaN
Humbai       NaN
London       1.0
lagos       24.0
dtype: float64

除此之外，Series的算术运算操作同样也支持NumPy的数组运算

sel = Series(data = [1,6,3,5], index = list('abcd'))
print(sel[sel>3]) # 布尔数组过滤
print(sel*2) # 标量乘法
print(np.square(sel)) # 可以直接加⼊到numpy的数学函数

---
b    6
d    5
dtype: int64
a     2
b    12
c     6
d    10
dtype: int64
a     1
b    36
c     9
d    25
dtype: int64

DataFrame

DataFrame（数据表）是⼀种2维数据结构，数据以表格的形式存储，分成若⼲⾏和列。通过 DataFrame，你能很⽅便地处理数据。常见的操作⽐如选取、替换⾏或列的数据，还能重组数据表、修改索引、多重筛选等。我们基本上可以把 DataFrame 理解成⼀组采⽤同样索引的 Series 的集合。调⽤ DataFrame()可以将多种格式的数据转换为DataFrame对象，它的的三个参数data、index和columns 分别为数据、⾏索引和列索引。

DataFrame的创建

我们可以使用二维数组

df1 = df(np.random.randint(0,10,(4,4)),index=[1,2,3,4],columns=['a','b','c','d']) 
print(df1)

---
   a  b  c  d
1  9  6  3  0
2  6  2  7  0
3  3  1  6  5
4  6  6  7  1

也可以使用字典创建

行索引由index决定，列索引由字典的键决定

dict={'Province': ['Guangdong', 'Beijing', 'Qinghai','Fujian'],'pop': [1.3, 2.5, 1.1, 0.7], 'year': [2022, 2022, 2022, 2022]}
df2= df(dict,index=[1,2,3,4]) 
print(df2)

---
    Province  pop  year
1  Guangdong  1.3  2022
2    Beijing  2.5  2022
3    Qinghai  1.1  2022
4     Fujian  0.7  2022

使用from_dict

dict2={"a":[1,2,3],"b":[4,5,6]}
df6=df.from_dict(dict2) 
print(df6)

---
   a  b
0  1  4
1  2  5
2  3  6

索引相同的情况下，相同索引的值会相对应，缺少的值会添加NaN

data = {
 'Name':pd.Series(['zs','ls','we'],index=['a','b','c']),
 'Age':pd.Series(['10','20','30','40'],index=['a','b','c','d']),
 'country':pd.Series(['中国','⽇本','韩国'],index=['a','c','b'])
}
df = pd.DataFrame(data)
print(df)

---
  Name Age country
a   zs  10      中国
b   ls  20      韩国
c   we  30      ⽇本
d  NaN  40     NaN

看了那么多DataFrame的转换方式，那我们如何将数据转为字典呢？DataFrame有一个内置方法to_dict()能将DataFrame对象转换为字典：

dict = df.to_dict()
print(dict)

---
{'Name': {'a': 'zs', 'b': 'ls', 'c': 'we', 'd': nan}, 'Age': {'a': '10', 'b': '20', 'c': '30', 'd': '40'}, 'country': {'a': '中国', 'b': '韩国', 'c': '⽇本', 'd': nan}}

DataFrame对象常⽤属性

让我们先来生成一组数据备用：

df_dict = {
'name':['James','Curry','Iversion'],
'age':['18','20','19'],
 'national':['us','China','us'] }
df = pd.DataFrame(data=df_dict,index=['0','1','2'])
print(df)

---
       name age national
0     James  18       us
1     Curry  20    China
2  Iversion  19       us

获取⾏数和列数

print(df.shape)

---
(3,3)

获取⾏索引

print(df.index.tolist())

---
['0', '1', '2']

获取列索引

print(df.columns.tolist())

---
['name', 'age', 'national']

获取数据的类型

print(df.dtypes)

---
name        object
age         object
national    object
dtype: object

获取数据的维度

print(df.ndim)

---
2

values属性也会以⼆维ndarray的形式返回DataFrame的数据

print(df.values)

---
[['James' '18' 'us']
 ['Curry' '20' 'China']
 ['Iversion' '19' 'us']]

展示df的概览

print(df.info())

---
<class 'pandas.core.frame.DataFrame'>
Index: 3 entries, 0 to 2
Data columns (total 3 columns):
 #   Column    Non-Null Count  Dtype 
---  ------    --------------  ----- 
 0   name      3 non-null      object
 1   age       3 non-null      object
 2   national  3 non-null      object
dtypes: object(3)
memory usage: 96.0+ bytes
None

显示头⼏⾏,默认显示5⾏

print(df.head(2))

---
    name age national
0  James  18       us
1  Curry  20    China

显示后⼏⾏

print(df.tail(1))

---
       name age national
2  Iversion  19       us

获取DataFrame的列

print(df['name'])

---
0       James
1       Curry
2    Iversion
Name: name, dtype: object

因为我们只获取⼀列，所以返回的就是⼀个Series

print(type(df['name']))

---
<class 'pandas.core.series.Series'>

如果获取多个列，那返回的就是⼀个DataFrame 类型：

print(df[['name','age']])
print(type(df[['name','age']]))

---
       name age
0     James  18
1     Curry  20
2  Iversion  19
<class 'pandas.core.frame.DataFrame'>

获取一行

print(df[0:1])

---
    name age national
0  James  18       us

去多⾏

print(df[1:3])

---
       name age national
1     Curry  20    China
2  Iversion  19       us

取多⾏⾥⾯的某⼀列（不能进⾏多⾏多列的选择）

print(df[1:3][['name','age']])

---
       name age
1     Curry  20
2  Iversion  19

⚠️ 注意：df[]只能进⾏⾏选择，或列选择，不能同时多⾏多列选择。比如在NumPy中的data[:,1:3]这种是不行的。当然，并不是没有办法获取，我们接着往下看:

df.loc通过标签索引⾏数据;df.iloc通过位置获取⾏数据

获取某⼀⾏某⼀列的数据

print(df.loc['0','name'])

---
James

⼀⾏所有列

print(df.loc['0',:])

---
name        James
age            18
national       us
Name: 0, dtype: object

某⼀⾏多列的数据

print(df.loc['0',['name','age']])

---
name    James
age        18
Name: 0, dtype: object

选择间隔的多⾏多列

print(df.loc[['0','2'],['name','national']]) 

---
       name national
0     James       us
2  Iversion       us

选择连续的多⾏和间隔的多列

print(df.loc['0':'2',['name','national']])

---
       name national
0     James       us
1     Curry    China
2  Iversion       us

取⼀⾏

print(df.iloc[1])

---
name        Curry
age            20
national    China
Name: 1, dtype: object

取连续多⾏

print(df.iloc[0:2])

---
    name age national
0  James  18       us
1  Curry  20    China

取间断的多⾏

print(df.iloc[[0,2],:])

---
       name age national
0     James  18       us
2  Iversion  19       us

取某⼀列

print(df.iloc[:,1])

---
0    18
1    20
2    19
Name: age, dtype: object

某⼀个值

print(df.iloc[1,0])

---
Curry

修改值

df.iloc[0,0]='panda'
print(df)

---
       name age national
0     panda  18       us
1     Curry  20    China
2  Iversion  19       us

dataframe中的排序⽅法

df = df.sort_values(by='age', ascending*=False) 
print(df)

---
       name age national
1     Curry  20    China
2  Iversion  19       us
0     panda  18       us

ascending=False是降序排列，默认为True，也就是升序。

dataframe修改index**、**columns

一样，让我们先创建一组新的数据供我们使用：

df1 = pd.DataFrame(np.arange(9).reshape(3, 3), index = ['bj', 'sh', 'gz'], columns=['a', 'b', 'c'])
print(df1)

---
    a  b  c
bj  0  1  2
sh  3  4  5
gz  6  7  8

修改 df1 的 index

df1.index可以打印出df1的索引值，同时也可以为其赋值。

print(df1.index) # 可以打印出print的值，同时也可以为其赋值
df1.index = ['beijing', 'shanghai', 'guangzhou']
print(df1)

---
Index(['bj', 'sh', 'gz'], dtype='object')
           a  b  c
beijing    0  1  2
shanghai   3  4  5
guangzhou  6  7  8

⾃定义map函数（x是原有的⾏列值）

# ⾃定义map函数（x是原有的⾏列值） 
def test_map(x):
    return x+'_ABC'
print(df1.rename(index=test_map, columns=test_map, inplace=True))
print(df1)

---
None
               a_ABC  b_ABC  c_ABC
beijing_ABC        0      1      2
shanghai_ABC       3      4      5
guangzhou_ABC      6      7      8

其中的inplace传入一个布尔值，默认为False。指定是否返回新的DataFrame。如果为True，则在原df上修改， 返回值为None。

rename 可以传⼊字典，为某个 index 单独修改名称

df3 = df1.rename(index={'beijing_ABC':'beijing'}, columns = {'a_ABC':'aa'})
print(df3)

---
               aa  b_ABC  c_ABC
beijing         0      1      2
shanghai_ABC    3      4      5
guangzhou_ABC   6      7      8

列转化为索引

df1=pd.DataFrame({'X':range(5),'Y':range(5),'S':list("abcde"),'Z': [1,1,2,2,2]})
print(df1)

---
   X  Y  S  Z
0  0  0  a  1
1  1  1  b  1
2  2  2  c  2
3  3  3  d  2
4  4  4  e  2

指定⼀列为索引 (drop=False 指定同时保留作为索引的列)

result = df1.set_index('S',drop=False)
result.index.name=None
print(result)

---
   X  Y  S  Z
a  0  0  a  1
b  1  1  b  1
c  2  2  c  2
d  3  3  d  2
e  4  4  e  2

⾏转为列索引

result = df1.set_axis(df1.iloc[0],axis=1,inplace=False)
result.columns.name=None
print(result)

---
   0  0  a  1
0  0  0  a  1
1  1  1  b  1
2  2  2  c  2
3  3  3  d  2
4  4  4  e  2

添加数据

先增加一组数据：

df1 = pd.DataFrame([['Snow','M',22],['Tyrion','M',32],['Sansa','F',18], ['Arya','F',14]],columns=['name','gender','age'])
print(df1)

---
     name gender  age
0    Snow      M   22
1  Tyrion      M   32
2   Sansa      F   18
3    Arya      F   14

在数据框最后加上score⼀列，注意增加列的元素个数要跟原数据列的个数⼀样。

df1['score']=[80,98,67,90] 
print(df1)

---
     name gender  age  score
0    Snow      M   22     80
1  Tyrion      M   32     98
2   Sansa      F   18     67
3    Arya      F   14     90

在具体某个位置插⼊⼀列可以⽤insert的⽅法, 语法格式：列表.insert(index, obj)

index --->对象 obj 需要插⼊的索引位置。

obj ---> 要插⼊列表中的对象（列名）

将数据框的列名全部提取出来存放在列表⾥

col_name=df1.columns.tolist() 
print(col_name)

---
['name', 'gender', 'age', 'score']

在列索引为2的位置插⼊⼀列,列名为:city

col_name.insert(2,'city')
print(col_name)

---
['name', 'gender', 'city', 'age', 'score']

刚插⼊时不会有值，整列都是NaN,我们使用DataFrame.reindex()对原⾏/列索引重新构建索引值

df1=df1.reindex(columns=col_name)
print(df1)

---
     name gender  city  age  score
0    Snow      M   NaN   22     80
1  Tyrion      M   NaN   32     98
2   Sansa      F   NaN   18     67
3    Arya      F   NaN   14     90

给city列赋值

df1['city']=['北京京','⼭⻄西','湖北北','澳⻔门'] 
print(df1)

---
     name gender city  age  score
0    Snow      M  北京京   22     80
1  Tyrion      M  ⼭⻄西   32     98
2   Sansa      F  湖北北   18     67
3    Arya      F  澳⻔门   14     90

df中的insert是插⼊⼀列。语法和关键参数为：

df.insert(iloc,column,value)

iloc:要插⼊的位置

colunm:列名

value:值

刚才我们插入city列的时候省略了value,所以新建列值全部为NaN，这次我们加上再看：

df1.insert(2,'score2',[80,98,67,90]) 
print(df1)

---
     name gender  score2 city  age  score
0    Snow      M      80  北京京   22     80
1  Tyrion      M      98  ⼭⻄西   32     98
2   Sansa      F      67  湖北北   18     67
3    Arya      F      90  澳⻔门   14     90

插⼊⼀⾏

# 插⼊⼀⾏
row=['111','222','333','444','555','666'] 
df1.iloc[1]=row
print(df1)

---
    name gender score2 city  age score
0   Snow      M     80  北京京   22    80
1    111    222    333  444  555   666
2  Sansa      F     67  湖北北   18    67
3   Arya      F     90  澳⻔门   14    90

插入行的时候，列个数必须对应才可以，否则会报错。

目前这组数据已经被我们玩乱了，我们再重新生成一组数据来看后面的：

df1 = pd.DataFrame([['Snow','M',22],['Tyrion','M',32],['Sansa','F',18],['Arya','F',14]],columns=['name','gender','age'])
print(df1)

---
     name gender  age
0    Snow      M   22
1  Tyrion      M   32
2   Sansa      F   18
3    Arya      F   14

再继续创建一组数据，我们将尝试将两组数据进行合并, 新创建的这组数据⽤来增加进数据框的最后⼀⾏。

new=pd.DataFrame({'name':'lisa','gender':'F','age':19},index=[0])
print(new)

---
   name gender  age
0  lisa      F   19

在原数据框df1最后⼀⾏新增⼀⾏，⽤append⽅法

df1=df1.append(new,ignore_index=True) 
print(df1)

---
     name gender  age
0    Snow      M   22
1  Tyrion      M   32
2   Sansa      F   18
3    Arya      F   14
4    lisa      F   19

ignore_index=False,表示不按原来的索引， 从0开始⾃动递增。

objs:合并对象

axis:合并⽅式，默认0表示按列合并，1表示按⾏合并

ignore_index:是否忽略索引

df1 = pd.DataFrame(np.arange(6).reshape(3,2),columns=['four','five'])
df2 = pd.DataFrame(np.arange(6).reshape(2,3),columns=['one','two','three'])
print(df1)
print(df2)

---
   four  five
0     0     1
1     2     3
2     4     5
   one  two  three
0    0    1      2
1    3    4      5

按行合并

result = pd.concat([df1,df2],axis=1)
print(result)

---
   four  five  one  two  three
0     0     1  0.0  1.0    2.0
1     2     3  3.0  4.0    5.0
2     4     5  NaN  NaN    NaN

按列合并

   four  five  one  two  three
0   0.0   1.0  NaN  NaN    NaN
1   2.0   3.0  NaN  NaN    NaN
2   4.0   5.0  NaN  NaN    NaN
3   NaN   NaN  0.0  1.0    2.0
4   NaN   NaN  3.0  4.0    5.0

看结果我们能看出来，在合并的时候，如果对应不到值，那么就会默认添加NaN值。

DataFrame的删除

df2 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['one','two','three'])
print(df2)
df3=df2.drop(['one'],axis=1, inplace=True)
print(df2)
print(df3)

---
   one  two  three
0    0    1      2
1    3    4      5
2    6    7      8
   two  three
0    1      2
1    4      5
2    7      8
None

lables：要删除数据的标签

axis：0表示删除⾏，1表示删除列，默认0

inplace:是否在当前df中执⾏此操作

最后的返回值为None，原因是我们设置inplace为True，在当前df中执行操作。如果我们将其设置为False，则会将操作后的值进行返回，生成一个新的对象。

df3=df2.drop([0,1],axis=0, inplace=False)
print(df2)
print(df3)

---
   one  two  three
0    0    1      2
1    3    4      5
2    6    7      8
   one  two  three
2    6    7      8

数据处理

在我们查看完DataFrame的基础操作之后，我们现在来正式开始数据处理。

我们可以通过通过dropna()滤除缺失数据，先让我们创建一组数据：

se=pd.Series([4,NaN,8,NaN,5]) 
print(se)

---
0    4.0
1    NaN
2    8.0
3    NaN
4    5.0
dtype: float64

尝试清除缺失数据，也就是NaN值：

print(se.dropna())

---
0    4.0
2    8.0
4    5.0
dtype: float64

在清除数据之前，我们有两个方法可以判断当前数据中是否有缺失数据，不过这两个方法的判断方式是相反的，一个是判断不是缺失数据，一个判断是缺失数据：

print(se.notnull())
print(se.isnull())

---
0     True
1    False
2     True
3    False
4     True
dtype: bool
0    False
1     True
2    False
3     True
4    False
dtype: bool

那既然有方法可以进行判断当前数据是否为缺失数据，那么我们用之前的方法与其配合，一样可以做滤除操作：

print(se[se.notnull()])

---
0    4.0
2    8.0
4    5.0
dtype: float64

当然，除了Series对象之外，我们还需要进行处理DataFrame对象

df1=pd.DataFrame([[1,2,3],[NaN,NaN,2],[NaN,NaN,NaN],[8,8,NaN]]) 
print(df1)

---
     0    1    2
0  1.0  2.0  3.0
1  NaN  NaN  2.0
2  NaN  NaN  NaN
3  8.0  8.0  NaN

默认滤除所有包含NaN：

print(df1.dropna())

---
     0    1    2
0  1.0  2.0  3.0

传⼊how=‘all’滤除全为NaN的⾏：

print(df1.dropna(how='all')) 

---
     0    1    2
0  1.0  2.0  3.0
1  NaN  NaN  2.0
3  8.0  8.0  NaN

可以看到，除了下标为2的那一行之外，其余含NaN值的行都被保留了。

之前操作最后只留下一行，原因是how的默认值为how='any'。只要是nan就删除

传⼊axis=1滤除列：

print(df1.dropna(axis=1,how="all"))

---
     0    1    2
0  1.0  2.0  3.0
1  NaN  NaN  2.0
2  NaN  NaN  NaN
3  8.0  8.0  NaN

为什么没有变化？按列来查看，没有一列是全是NaN值的。

除了how值外，我们还可以可以使用thresh来精准操作，它可以传入一个数值n，会保留至少n个非NaN数据的行或列：

print(df1.dropna(thresh=2))

---
     0    1    2
0  1.0  2.0  3.0
3  8.0  8.0  NaN

仅有一个非NaN的行和全部为NaN的行就都被滤除了。

那NaN是不是就只能被删除了呢？并不是，还记得我们之前操作的时候我提到过，我们大多数遇到NaN值的时候，基本都是用平均值来进行填充，这是一个惯例操作。

那么，我们来看看如何填充缺失数据

df1=pd.DataFrame([[1,2,3],[NaN,NaN,2],[NaN,NaN,NaN],[8,8,NaN]]) 
print(df1)

---
     0    1    2
0  1.0  2.0  3.0
1  NaN  NaN  2.0
2  NaN  NaN  NaN
3  8.0  8.0  NaN

⽤常数填充fillna

print(df1.fillna(0))

---
     0    1    2
0  1.0  2.0  3.0
1  0.0  0.0  2.0
2  0.0  0.0  0.0
3  8.0  8.0  0.0

传⼊inplace=True直接修改原对象：

df1.fillna(0,inplace=True) 
print(df1)

---
     0    1    2
0  1.0  2.0  3.0
1  0.0  0.0  2.0
2  0.0  0.0  0.0
3  8.0  8.0  0.0

通过字典填充不同的常数

print(df1.fillna({0:10,1:20,2:30}))

---
      0     1     2
0   1.0   2.0   3.0
1  10.0  20.0   2.0
2  10.0  20.0  30.0
3   8.0   8.0  30.0

还有我们之前提到过的，填充平均值：

print(df1.fillna(df1.mean()))

---
     0    1    2
0  1.0  2.0  3.0
1  4.5  5.0  2.0
2  4.5  5.0  2.5
3  8.0  8.0  2.5

当然，我们可以只填充某一列

print(df1.iloc[:,1].fillna(5,inplace = True)) 
print(df1)

---
None
     0    1    2
0  1.0  2.0  3.0
1  NaN  5.0  2.0
2  NaN  5.0  NaN
3  8.0  8.0  NaN

传⼊method=” “会改变插值⽅式，先来一组数据，并在其中加上NaN值

df2=pd.DataFrame(np.random.randint(0,10,(5,5))) 
df2.iloc[1:4,3]=NaN
df2.iloc[2:4,4]=NaN
print(df2)

---
   0  1  2    3    4
0  3  5  9  9.0  3.0
1  0  1  2  NaN  8.0
2  6  5  8  NaN  NaN
3  5  6  5  NaN  NaN
4  5  3  5  8.0  2.0

现在，我们用前面的值来填充， method ='ffill'

print(df2.fillna(method='ffill'))

---
   0  1  2    3    4
0  3  5  9  9.0  3.0
1  0  1  2  9.0  8.0
2  6  5  8  9.0  8.0
3  5  6  5  9.0  8.0
4  5  3  5  8.0  2.0

用后面的值来填充method='bfill':

print(df2.fillna(method='bfill',limit=1))

---
   0  1  2    3    4
0  7  1  8  0.0  0.0
1  6  8  4  NaN  5.0
2  6  2  5  NaN  NaN
3  4  8  0  1.0  3.0
4  8  0  2  1.0  3.0

以上代码中，我们还传入了limit， 用于限制填充行数。

当我们传入axis的时候，会修改填充方向：

print(df2.fillna(method="ffill",limit=1,axis=1))

---
     0    1    2    3    4
0  0.0  8.0  9.0  4.0  7.0
1  2.0  8.0  0.0  0.0  9.0
2  1.0  8.0  5.0  5.0  NaN
3  0.0  0.0  3.0  3.0  NaN
4  2.0  9.0  4.0  6.0  3.0

接着，我们再来看看如何移除重复数据，俗称「去重」：

DataFrame中经常会出现重复⾏，利⽤duplicated()函数返回每⼀⾏判断是否重复的结果（重复则为 True)

df1=pd.DataFrame({'A':[1,1,1,2,2,3,1],'B':list("aabbbca")})
print(df1)
print(df1.duplicated())

---
   A  B
0  1  a
1  1  a
2  1  b
3  2  b
4  2  b
5  3  c
6  1  a

0    False
1     True
2    False
3    False
4     True
5    False
6     True
dtype: bool

去除全部的重复⾏

print(df1.drop_duplicates())

---
   A  B
0  1  a
2  1  b
3  2  b
5  3  c

指定列去除重复行

print(df1.drop_duplicates(['A']))

---
   A  B
0  1  a
3  2  b
5  3  c

保留重复⾏中的最后⼀⾏

df1=pd.DataFrame({'A':[1,1,1,2,2,3,1],'B':list("aabbbca")})
print(df1.drop_duplicates(['A'],keep='last'))

---
   A  B
4  2  b
5  3  c
6  1  a

去除重复的同时改变DataFrame对象

df1.drop_duplicates(['A','B'],inplace=True) 
print(df1)

---
   A  B
0  1  a
2  1  b
3  2  b
5  3  c

数据合并

我们平时会与拿到的数据可能存储在不同的数据表中，这需要我们对数据进行合并，然后再进行操作。

使⽤join合并，着重关注的是⾏的合并。

简单合并（默认是left左连接,以左侧df3为基础）

df3=pd.DataFrame({'Red':[1,3,5],'Green':[5,0,3]},index=list('abc'))
df4=pd.DataFrame({'Blue':[1,9,8],'Yellow':[6,6,7]},index=list('cde')) 
print(df3)
print(df4)
df3.join(df4,how='left')

---
   Red  Green
a    1      5
b    3      0
c    5      3
   Blue  Yellow
c     1       6
d     9       6
e     8       7


	Red	Green	Blue	Yellow
a	1		5			NaN		NaN
b	3		0			NaN		NaN
c	5		3			1.0		6.0

右链接

df3.join(df4,how='outer')

---
	Red	Green	Blue	Yellow
a	1.0	5.0		NaN		NaN
b	3.0	0.0		NaN		NaN
c	5.0	3.0		1.0		6.0
d	NaN	NaN		9.0		6.0
e	NaN	NaN		8.0		7.0

合并多个DataFrame对象

df5=pd.DataFrame({'Brown':[3,4,5],'White':[1,1,2]},index=list('aed')) 
df3.join([df4,df5])

---

	Red	Green	Blue	Yellow	Brown	White
a	1.0	5.0		NaN		NaN			3.0		1.0
b	3.0	0.0		NaN		NaN			NaN		NaN
c	5.0	3.0		1.0		6.0			NaN		NaN

使⽤merge，着重关注的是列的合并。

我们先来构建两组数据：

df1=pd.DataFrame({'名字':list('ABCDE'),'性别':['男','⼥','男','男','⼥'],'职称': ['副教授','讲师','助教','教授','助教']},index=range(1001,1006))
df1.columns.name='学院⽼师'
df1.index.name='编号'
df1

---
学院⽼师	名字	性别	职称
编号			
1001		A			男		副教授
1002		B			⼥		讲师
1003		C			男		助教
1004		D			男		教授
1005		E			⼥		助教

df2=pd.DataFrame({'名字':list('ABDAX'),'课程':['C++','计算机导论','汇编','数据结构','马克思原理'],'职称':['副教授','讲师','教授','副教授','讲师']},index= [1001,1002,1004,1001,3001])
df2.columns.name='课程'
df2.index.name='编号'
print(df2)

---
课程	名字	课程				职称
编号			
1001	A		C++				副教授
1002	B		计算机导论		讲师
1004	D		汇编				教授
1001	A		数据结构		副教授
3001	X		马克思原理	讲师

默认下是根据左右对象中出现同名的列作为连接的键，且连接⽅式是how=’inner’ 

print(pd.merge(df1,df2)) # 返回匹配的

---
  名字 性别   职称     课程
0  A  男  副教授    C++
1  A  男  副教授   数据结构
2  B  ⼥   讲师  计算机导论
3  D  男   教授     汇编

指定列名合并

pd.merge(df1,df2,on='名字',suffixes=['_1','_2']) # 返回匹配的

---

	名字	性别	职称_1	课程		职称_2
0	A			男		副教授		C++			副教授
1	A			男		副教授		数据结构	副教授
2	B			⼥		讲师		计算机导论	讲师
3	D			男		教授		汇编			教授

连接⽅式，根据左侧为准

pd.merge(df1,df2,how='left')

---
	名字	性别	职称	课程
0	A			男	副教授	C++
1	A			男	副教授	数据结构
2	B			⼥	讲师	计算机导论
3	C			男	助教	NaN
4	D			男	教授	汇编
5	E			⼥	助教	NaN

根据右侧为准

pd.merge(df1,df2,how='right')

---
	名字	性别	职称	课程
0	A		男	副教授	C++
1	B		⼥	讲师	计算机导论
2	D		男	教授	汇编
3	A		男	副教授	数据结构
4	X		NaN	讲师	马克思原理

所有的数据

pd.merge(df1,df2,how='outer')

---

名字	性别	职称	课程
0		A	男	副教授	C++
1		A	男	副教授	数据结构
2		B	⼥	讲师	计算机导论
3		C	男	助教	NaN
4		D	男	教授	汇编
5		E	⼥	助教	NaN
6		X	NaN	讲师	马克思原理

根据多个键进⾏连接

pd.merge(df1,df2,*on*=['职称','名字'])

---
	名字	性别	职称	课程
0	A			男	副教授	C++
1	A			男	副教授	数据结构
2	B			⼥	讲师	计算机导论
3	D			男	教授	汇编

除此之外，我们还有一种轴向连接的方式：Concat

Series对象的连接

s1=pd.Series([1,2],index=list('ab'))
s2=pd.Series([3,4,5],index=list('bde')) 
print(s1)
print(s2)
pd.concat([s1,s2])

---
a    1
b    2
dtype: int64
b    3
d    4
e    5
dtype: int64
a    1
b    2
b    3
d    4
e    5
dtype: int64

横向连接

pd.concat([s1,s2],*axis*=1)

---
	0		1
a	1.0	NaN
b	2.0	3.0
d	NaN	4.0
e	NaN	5.0

⽤内连接求交集(连接⽅式，共有’inner’,’left’,right’,’outer’)

pd.concat([s1,s2],axis=1,join='inner')

---
	0	1
b	2	3

创建层次化索引

pd.concat([s1,s2],keys=['A','B'])

---
A  a    1
   b    2
B  b    3
   d    4
   e    5
dtype: int64

当纵向连接时keys为列名

pd.concat([s1,s2],keys=['A','D'],axis=1)

----
	A		D
a	1.0	NaN
b	2.0	3.0
d	NaN	4.0
e	NaN	5.0

DataFrame对象的连接

df3=pd.DataFrame({'Red':[1,3,5],'Green':[5,0,3]},index=list('abd')) 
df4=pd.DataFrame({'Blue':[1,9],'Yellow':[6,6]},index=list('ce'))
pd.concat([df3,df4])

---

	Red	Green	Blue	Yellow
a	1.0	5.0		NaN		NaN
b	3.0	0.0		NaN		NaN
d	5.0	3.0		NaN		NaN
c	NaN	NaN		1.0		6.0
e	NaN	NaN		9.0		6.0

⽤字典的⽅式连接同样可以创建层次化列索引

pd.concat({'A':df3,'B':df4},axis=1)

---
	A					B
	Red	Green	Blue	Yellow
a	1.0	5.0		NaN		NaN
b	3.0	0.0		NaN		NaN
d	5.0	3.0		NaN		NaN
c	NaN	NaN		1.0		6.0
e	NaN	NaN		9.0		6.0