【Python基础】pandas 使用指南（超详细！）_pandas教程

pandas指南

学习目的：

• 掌握pandas中series与dataframe
• pandas数据清洗
• 使用pandas进行数据基本统计
• 时间序列分析
• 数据分析常用方法

1 Pandas基础

• pandas是python中数据分析核心库，能够快速，灵活的对大量数据进行分析，是Python进行数据分析的必要利器；
• pandas支持多种数据导入，支持数据合并，拆分，基本统计，时间序列分析，透视表等多种操作；

1.1 Series数据结构

Series：一维的带索引数据结构(单列)

Series类：
pd.Series(data=None,index=None,dtype=None,name=None,copy=False,fastpath=False)

1. 创建Series对象

   第一列为索引，第二列为Series数据

import pandas as pd
import numpy as np
sdata = pd.Series(np.arange(1,4), index=list('abc'))
sdata
1
2
3
4
'
运行
运行

a    1
b    2
c    3
dtype: int32
1
2
3
4

2. Series对象访问

   .iloc[]确保你按位置而不是标签访问Series对象的元素。

# 默认数字索引
print(sdata.iloc[0])
# 使用标签[a,b,c]
print(sdata['b'])
# 使用loc方式，只能使用标签
print(sdata.loc['c'])
1
2
3
4
5
6

1
2
3
1
2
3

3. 获取index与value

# 获取索引
sdata.index.values
1
2

array(['a', 'b', 'c'], dtype=object)
1

# 获取索引
sdata.values
1
2

array([1, 2, 3])
1

4. 将index与value转成列表

# 将索引转成列表
sdata.index.values.tolist()
1
2

['a', 'b', 'c']
1

# 将数据转成列表
sdata.values.tolist()
1
2

[1, 2, 3]
1

# Series对象访问
for item in sdata.items():
    print(item)
1
2
3

('a', 1)
('b', 2)
('c', 3)
1
2
3

1.2 dataframe

DataFrame：多种类型的列构成的二维标签数据结构(多列)；

DataFrame类：

pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)

• data:一维数据，二维数据
• index:行标签
• columns:列标签

1.2.1 Dataframe创建

1. 一行一列

# 一维数据
pd.DataFrame(data=np.arange(1,4))
1
2

2. 多列

# 多维数据 data为4X4
data = np.arange(16).reshape(4,4)
pd.DataFrame(data=data)
1
2
3

3. 设置index与columns

# 设置index与columns
data = np.arange(16).reshape(4,4)
pdata = pd.DataFrame(data=data, index=list('abcd'), columns=['c1','c2','c3','c4'])
pdata
1
2
3
4

4. 设置index与columns

# 设置index与columns
data = {'c1':[1,2,3], 'c2':[4,5,6]}
pdata = pd.DataFrame(data=data)
pdata
1
2
3
4

5. 设置列标签

# 设置列标签
pdata.columns = ['t1','t2']
pdata
1
2
3

1.2.2 DataFrame对象访问

data = {'c1':[1,2,3], 'c2':[4,5,6], 'c3':[7,8,9]}
pdata = pd.DataFrame(data=data)
pdata
1
2
3

1. 获取指定列

# 获取一列数据，返回Series对象
pdata['c1']
1
2

0    1
1    2
2    3
Name: c1, dtype: int64
1
2
3
4

# 取多列数据
pdata[['c1','c2']]
1
2

2. loc操作

   loc操作：使用类似列表方式去对数据进行访问，支持bool索引;

import pandas as pd
data = {'c1':[1,2,3], 'c2':[4,5,6], 'c3':[7,8,9]}
pdata = pd.DataFrame(data=data)
pdata
1
2
3
4
'
运行
运行

3. 获取指定行

# 获取第一行
pdata.loc[0]
1
2

c1    1
c2    4
c3    7
Name: 0, dtype: int64
1
2
3
4

# 获取第一行指定c1,c2列
pdata.loc[0,['c1','c2']]
1
2

c1    1
c2    4
Name: 0, dtype: int64
1
2
3

4. 遍历DataFrame对象

# 获取列索引
for item in pdata:
    print(item)
1
2
3

c1
c2
c3
1
2
3

# 按列遍历
for item in pdata.items():
    print(item)
1
2
3

('c1', 0    1
1    2
2    3
Name: c1, dtype: int64)
('c2', 0    4
1    5
2    6
Name: c2, dtype: int64)
('c3', 0    7
1    8
2    9
Name: c3, dtype: int64)
1
2
3
4
5
6
7
8
9
10
11
12

# 按行遍历
for item in pdata.iterrows():
    print(item)
1
2
3

(0, c1    1
c2    4
c3    7
Name: 0, dtype: int64)
(1, c1    2
c2    5
c3    8
Name: 1, dtype: int64)
(2, c1    3
c2    6
c3    9
Name: 2, dtype: int64)
1
2
3
4
5
6
7
8
9
10
11
12

1.2.3 DataFrame修改

1. 修改元素

# 修改元素
import pandas as pd
data = {'c1':[1,2,3], 'c2':[4,5,6], 'c3':[7,8,9]}
pdata = pd.DataFrame(data=data)
# 修改c1列值
pdata['c1'] = 0
pdata
1
2
3
4
5
6
7
'
运行
运行

2. DataFrame插入列

# DataFrame插入列
import pandas as pd
data = {'c1':[1,2,3], 'c2':[4,5,6], 'c3':[7,8,9]}
pdata = pd.DataFrame(data=data)
# 修改c1列值
pdata['c4'] = [-1,-1,-1]
pdata
1
2
3
4
5
6
7
'
运行
运行

3. DataFrame插入行

# DataFrame插入行
import pandas as pd
data = {'c1':[1,2,3], 'c2':[4,5,6], 'c3':[7,8,9]}
pdata = pd.DataFrame(data=data)
# 修改c1列值
pdata.loc[3] = [-1,-1,-1]
pdata
1
2
3
4
5
6
7
'
运行
运行

2 pandas数据导入与保存

目的：

• 数据导入：excel, csv文件
• 数据导出
• 基本统计
• 缺省数据处理

2.1 数据导入

数据是分析基础，实际工作中，数据来自于企业内部数据，网络数据，开源数据集；

1. 读取excel文件

import pandas as pd
import numpy as np
# 读取excel文件
fpath = r'data\test.xlsx'
pdata = pd.read_excel(fpath)
pdata
1
2
3
4
5
6

2. 读取csv文件

# 读取csv文件
fpath = r'data\GDP.csv'
pdata = pd.read_csv(fpath, encoding='gbk')
pdata
1
2
3
4

264 rows × 62 columns

# 导入指定列
fpath = r'data\GDP.csv'
pdata = pd.read_csv(fpath,usecols = ['Country Name','1990'], encoding='gbk')
pdata
1
2
3
4

264 rows × 2 columns

# 导入指定表头
fpath = r'data\GDP.csv'
pdata = pd.read_csv(fpath,header=1, encoding='gbk')
pdata
1
2
3
4

263 rows × 62 columns

# 无表头指定None
pdata = pd.read_csv(fpath,header=None, encoding='gbk')
pdata
1
2
3

265 rows × 62 columns

2.2 数据保存

# 保存文件
import pandas as pd
import numpy as np
# 读取excel文件
fpath = r'data\GDP.csv'
csv_path1 = r'data\new_GDP_1.csv'
csv_path2 = r'data\new_GDP_2.csv'
csv_path3 = r'data\new_GDP_3.csv'
pdata = pd.read_csv(fpath, encoding='gbk')
# 保存格式带索引
pdata.to_csv(csv_path1)
# 保存格式不带索引
pdata.to_csv(csv_path2, index=False)
# 保存格式不带索引,保存指定列
pdata.to_csv(csv_path3, index=False, columns=['1990','1991'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

pdata = pd.read_csv(csv_path1, encoding='gbk')
pdata
1
2

264 rows × 63 columns

pdata = pd.read_csv(csv_path2, encoding='gbk')
pdata
1
2

264 rows × 62 columns

pdata = pd.read_csv(csv_path3, encoding='gbk')
pdata
1
2

264 rows × 2 columns

3 缺失数据处理

3.1 缺失值与空值

缺省值：数据集中数值为空的值, pandas使用Nan / NaT 表示

空值：空字符串 ""

s1 = [10, 10.5, None, 11]
s2 = [7, 6.9,7.5,None]
pdata = pd.DataFrame({'s1':s1, 's2':s2})
pdata
1
2
3
4

3.2 缺失值判断

判断方法：

• pd.isnull()：缺省值对应的值为True，返回值为Boolean的Series或者DataFrame对象
• pd.notnull()：缺省值对应的值为False，返回值为Boolean的Series或者DataFrame对象
• pdata.isnull() / pdata.notnull() ：同上

sdata = pd.Series([1,2,3, np.NaN])
pd.isnull(sdata)
1
2

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

s1 = [10, 10.5, None, 11]
s2 = [7, 6.9,7.5,None]
pdata = pd.DataFrame({'s1':s1, 's2':s2})
pd.isnull(pdata)
1
2
3
4

3.3 判断是否有缺失值

1. 方式：np.all 与 pd.notnull结合

s1 = [10, 10.5, None, 11]
s2 = [7, 6.9,7.5,None]
pdata = pd.DataFrame({'s1':s1, 's2':s2})
# pd.notnull,若包含缺省值，缺省值对应值为False
# np.all：若对象中包含假，返回False， 否则返回真
np.all(pd.notnull(pdata))
# 返回False， 说明包含缺省值，否则不包含缺省值
1
2
3
4
5
6
7

False
1

s1 = [10, 10.5, 11]
s2 = [7, 6.9,7.5]
pdata = pd.DataFrame({'s1':s1, 's2':s2})
np.all(pd.notnull(pdata))
1
2
3
4

True
1

2. 方式：np.any 与 pd.isnull结合

s1 = [10, 10.5, 11]
s2 = [7, 6.9,7.5]
pdata = pd.DataFrame({'s1':s1, 's2':s2})
# isnull：缺省值对应值为True
# any:对象中包含真，返回True
np.any(pd.isnull(pdata))
# 返回False,说明不含缺省值，返回True说明包括缺省值
1
2
3
4
5
6
7

False
1

3.4 缺省值处理方式

缺省值处理：

• 过滤缺省值(按行列)
• 删除缺省值(按行列)
• 填充值，填充值方式：
• 插入均值，中位数,最大值，最小值等
• 插入特殊值
• 插入前(后)值入前(后)值

3.4.1 缺省值过滤

1. 举例：某两只股票1周收盘值，None表示当前停盘

   需求：获取两只股票都没有停牌的数据

# 数据：某两只股票1周收盘值，None表示当前停盘
s1 = [10, 10.5, None, 11]
s2 = [7, 6.9,7.5,None]
pdata = pd.DataFrame({'s1':s1, 's2':s2})
pdata
1
2
3
4
5

# 需求：获取两只股票都没有停牌的数据
# 获取boolean索引
bindex = np.all(pdata.notnull(), axis=1)
bindex
1
2
3
4

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

# 获取没有停牌数据
pdata[bindex]
1
2

3.4.2 删除缺省值

pdata.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

主要参数：

准备数据：

s1 = [10, 10.5, None, 11]
s2 = [7, 6.9,7.5,None]
s3 = [7, 6.9,7.5,7]
s4 = [None, 6.9,None,7.2]
pdata = pd.DataFrame({'s1':s1, 's2':s2, 's3':s3,'s4':s4})
pdata
1
2
3
4
5
6

需求：

1. 删除包含缺省值的行
2. 删除包含2个缺省值行
3. 删除指定列包含缺省值
4. 删除包含缺省值的列

# 删除包含缺省值行
pdata.dropna()
1
2

# 缺省值数量大于1，thresh设置为3
# thresh:指定非Na数量(非Na数量>=thresh，不删除)
pdata.dropna(thresh=3)
1
2
3

# 指定列：['s1','s4']
pdata.dropna(subset=['s1','s4'])
1
2

# 删除包含缺省值列
pdata.dropna(axis=1)
1
2

注意：

• 以上数据删除都不对原始数据进行修改
• 指定inplace为True，在原始数据中进行修改

3.4.3 缺失值填充

填充方法：

pdata.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)

pdata
1

需求：

• 缺省值填充固定值0
• 使用前/后面数据填充
• 使用均值填充
• 插入均值插入均值

# 固定值0
pdata.fillna(0)
1
2

# 使用前一行数据填充
pdata.fillna(method='ffill')
# 使用向前填充 (ffill) 替代 fillna
pdata.ffill()
1
2
3
4

# 使用后一行数据填充
pdata.fillna(method='bfill')
# 使用向后填充 (bfill) 替代 fillna
pdata.bfill()
1
2
3
4

# 使用后一列数据填充
pdata.fillna(axis=1,method='bfill')
# 使用向后填充 (bfill) 替代 fillna
pdata.bfill(axis=1)
1
2
3
4

对于股票缺省值，我们倾向于，使用前一天数据填充缺失值

3.4.4 插入均值，中位数，最大值，最小值

pdata.mean/max/min/median(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

主要参数：

pdata
1

1. 插入均值

#插入均值
pdata.fillna(pdata.mean())
1
2

2. 插入中位数

#插入中位数
pdata.fillna(pdata.median())
1
2

4 数据清洗

4.1 准备数据

某次考试成绩

import pandas as pd
import numpy as np

names = list('ABCD')
math = [90,100,50,80]
chinese = [89,96,58,77]
pdata = pd.DataFrame({'name':names, 'math':math, 'chinese':chinese})
pdata
1
2
3
4
5
6
7
8
'
运行
运行

4.2 获取指定列

通过列名，直接获取值

# 通过列名，直接获取值
pdata['name']
1
2

0    A
1    B
2    C
3    D
Name: name, dtype: object
1
2
3
4
5

4.3 获取指定多列

基本方法：pdata[[col1, col2]]

获取姓名与数学成绩

# 获取指定多列
# 基本方法：pdata[[col1, col2]]
pdata[['name', 'math']]
1
2
3

4.4 根据指定条件获取数据

1. 需求1：数学成绩大于80的所有成绩;

   实现思路：

   • 根据条件生成boolean索引
   • 通过boolean索引获取数据

# 需求1：数学成绩大于80的所有成绩;
bindex = pdata['math'] > 80
pdata[bindex]
1
2
3

2. 需求2：获取同学A的成绩

   实现思路：

   • 根据条件生成boolean索引
   • 通过boolean索引获取数据

# 需求2：获取同学A的成绩;
pdata[pdata['name']=='A']
1
2

4.5 根据指定多个条件获取数据

1. 需求1：获取数学语文都及格成绩
   • 条件1：数学成绩大于59,
   • 条件2：语文成绩大于59
   • 条件3：两个条件与操作:&
   • 基本语法：pdata[condition1&condition2]

# 需求1：获取数学语文都及格成绩
# 注意：两个条件要加括号
pdata[(pdata['math']>59) & (pdata['chinese']>59)]
1
2
3

2. 需求2：获取数学语文有一门大于等于80分
   • 条件1：数学成绩大于等于80,
   • 条件2：语文成绩大于等于80
   • 条件3：两个条件与操作:|
   • 基本语法：pdata[condition1|condition2]

# 需求2：获取数学语文有一门大于等于80分
# 注意：两个条件要加括号
pdata[(pdata['math']>=80) | (pdata['chinese']>=80)]
1
2
3

# 根据集合获取数据
bindex = pdata['math'].isin([100, 90])
pdata[bindex]
1
2
3

3. 根据集合获取数据

   获取数学成绩为100或者90的学生成绩

   • 多个值判断： pdata.isin(values)，返回boolean索引

bindex = pdata['math'].isin([100, 90])
pdata[bindex]
1
2

4.6 根据数据排序

• 排序方式1：根据索引排序

  pdata.sort_index(axis=0,level=None,ascending=True,...)

• 排序方式2：根据指定列内容排序

  pdata.sort_values(by,axis=0,ascending=True,...)

# 根据数据排序
import pandas as pd
import numpy as np
names = list('ABCD')
math = [90,100,80,80]
chinese = [89,96,58,77]
pdata = pd.DataFrame({'name':names, 'math':math, 'chinese':chinese})
pdata
1
2
3
4
5
6
7
8
'
运行
运行

# 根据索引排序，降序,ascending=False
pdata.sort_index(ascending=False)
1
2

# 根据数学成绩排序，降序,ascending=False
pdata.sort_values(['math'], ascending=False)
1
2

# 根据数学与语文成绩排序，降序,ascending=False
# sort_values中加入两列数据
pdata.sort_values(['math', 'chinese'], ascending=False)
1
2
3

5 pandas汇总与描述性统计

pandas计算与统计相关方法：

• 最大值：pdata.max(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
• 最小值：pdata.min(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
• 均值：pdata.mean(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
• 中位数：pdata.median(axis=None,skipna=None,level=None,numeric_only=None, **kwargs)
• 求和：pdata.sum(axis=None,skipna=None,level=None,numeric_only=None,min_count=0,**kwargs)
• 方差：pdata.var(axis=None,skipna=None,level=None,ddof=1,numeric_only=None,**kwargs)
• 标准差：pdata.std(axis=None,skipna=None,level=None,ddof=1,numeric_only=None,**kwargs)
• 累加和：pdata.cumsum(axis=None, skipna=True, *args, **kwargs)
• 分位数：pdata.quantile(q=0.5, axis=0, numeric_only=True, interpolation='linear')
• 每个数值到均值的平均差：pdata.mad(axis=None, skipna=None, level=None)
• 元素与先前元素的相差百分比：pdata.pct_change(periods=1,fill_method='pad',limit=None,freq=None,**kwargs)
• 偏度：pdata.skew(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
• 峰度：pdata.kurt(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
• 数据描述：pdata.describe(percentiles=None, include=None, exclude=None)

1. 产生数据

import pandas as pd
import numpy as np

names = list('ABCD')
math = [90,100,80,80]
chinese = [89,96,58,77]
pdata = pd.DataFrame({'name':names, 'math':math, 'chinese':chinese})
pdata
1
2
3
4
5
6
7
8
'
运行
运行

2. 基本描述与计算

#最大值，最小值，四分位数，均值，数量，标准差
pdata.describe()
1
2

#计算每个学生总分,平均分
print(pdata.iloc[:, 1:].sum(axis=1))
print(pdata.iloc[:, 1:].mean(axis=1))
1
2
3

0    179
1    196
2    138
3    157
dtype: int64
0    89.5
1    98.0
2    69.0
3    78.5
dtype: float64
1
2
3
4
5
6
7
8
9
10

3. 分位数

   计算：下四分位数，中位数，上四分位数

#下四分位数
print(pdata.iloc[:, 1:].quantile(q=0.25))
#中位数
print(pdata.iloc[:, 1:].quantile(q=0.5))
#上位数
print(pdata.iloc[:, 1:].quantile(q=0.75))
1
2
3
4
5
6

math       80.00
chinese    72.25
Name: 0.25, dtype: float64
math       85.0
chinese    83.0
Name: 0.5, dtype: float64
math       92.50
chinese    90.75
Name: 0.75, dtype: float64
1
2
3
4
5
6
7
8
9

6 索引/多级索引

主要内容：

• 重置索引
• 索引变换
• 多级索引索引

import pandas as pd
import numpy as np
names = list('ABCDABCD')
pdata = pd.DataFrame(np.random.randint(30,100, size=(8,2)),columns=['math','chinese'])
pdata['team'] = [1]*4+[2]*4
pdata['name'] = names
pdata
1
2
3
4
5
6
7
'
运行
运行

6.1 设置索引

• name设置为索引

• 重置索引方法：pdata.set_index(keys,drop=True,append=False,inplace=False)

# 设置索引
# set_index:inplace返回副本，新数据
ndata = pdata.set_index('name')
ndata
1
2
3
4

6.2 多级索引

需求：通过索引获取指定学期数据

pd.MultiIndex.from_arrays(arrays, sortorder=None, names=None)

import pandas as pd
import numpy as np
names = list('ABCDABCD')
pdata = pd.DataFrame(np.random.randint(30,100, size=(8,2)),columns=['math','chinese'])
pdata
1
2
3
4
5
'
运行
运行

lv1 = [1]*4+[2]*4
lv2 = list('ABCDABCD')
# 创建MultiIndex对象
mindex = pd.MultiIndex.from_arrays([lv1, lv2])
data = pdata.set_index(mindex)
data
1
2
3
4
5
6

6.3 通过多级索引取值

需求：

• 获取第一学期数据
• 获取第一学期A同学数据
• 获取A同学所有数据有数据

#第一学期数据
data.loc[1]
1
2

#第一学期A同学数据
data.loc[(1,'A')]
1
2

math       53
chinese    71
Name: (1, A), dtype: int32
1
2
3

# 如何获取A同学所有数据？
# 索引交换
data = data.swaplevel(0,1)
data
1
2
3
4

data.loc['A']
1

6.4 行列变换

• pdata.stack(level=-1, dropna=True):将列“旋转”为行
• pdata.unstack(level=-1, fill_value=None):将行“旋转”为列

import pandas as pd
import numpy as np
names = list('ABCDABCD')
pdata = pd.DataFrame(np.random.randint(30,100, size=(8,2)),columns=['math','chinese'])
lv1 = [1]*4+[2]*4
lv2 = list('ABCDABCD')
mindex = pd.MultiIndex.from_arrays([lv1, lv2])
pdata = pdata.set_index(mindex)
pdata
1
2
3
4
5
6
7
8
9
'
运行
运行

需求：

• 将学期转到列
• 获取所有学生数学成绩
• 获取第一学期数据数据

1. 将学期转到列

# 将学期转到列
tmp = pdata.unstack(level=0)
tmp
1
2
3

2. 获取所有学生数学成绩

# 获取所有学生数学成绩
tmp['math']
1
2

3. 获取第一学期数据

# 列索引层级交换，获取第一学期数据
tmp.swaplevel(axis=1)[1]
1
2

tmp
1

t = tmp.stack(level=0)
t
1
2

# 获取A同学第一学期成绩
t.loc['A'][1]
1
2

chinese    96
math       84
Name: 1, dtype: int32
1
2
3

t.sort_index(level = 1)
1

7 时间与时间序列

时间是数据分析重要维度，pandas中时间主要知识点：

• 时间戳
• 周期
• 时间间隔
• 时间索引
• 时间滑动窗口间滑动窗口

7.1 时间戳

时间处理中常见的对象；

时间戳方法：

• pd.Timestamp(ts_input=<object object at 0x00000258D4E907F0>,freq=None, tz=None,...)，详情见说明案例
• pd.to_datetime(arg,errors='raise', dayfirst=False,...)

#年
print(pd.Timestamp(2020))
#年月日
print(pd.Timestamp(2020, 6, 2))
#字符串
print(pd.Timestamp('2020-05-07'))
#字符串时间
print(pd.Timestamp('2020-05-07 04:02:01'))
#字符串时间
print(pd.Timestamp('2017-01-01T12'))
#时间戳
print(pd.Timestamp(1513393355.5, unit='s'))
#2017-03-01与format对应
print(pd.to_datetime('2017-02-01',format="%Y-%m-%d"))
#20170301与年月日对应
print(pd.to_datetime('20170301',format="%Y%m%d"))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1970-01-01 00:00:00.000002020
2020-06-02 00:00:00
2020-05-07 00:00:00
2020-05-07 04:02:01
2017-01-01 12:00:00
2017-12-16 03:02:35.500000
2017-02-01 00:00:00
2017-03-01 00:00:00
1
2
3
4
5
6
7
8

print(pd.to_datetime('2017-02-01',format="%Y-%m-%d"))
#生成时间索引
print(pd.to_datetime(['2017-02-01'],format="%Y-%m-%d"))
1
2
3

2017-02-01 00:00:00
DatetimeIndex(['2017-02-01'], dtype='datetime64[ns]', freq=None)
1
2

pd.Timestamp.now()
1

Timestamp('2024-02-01 10:45:29.038280')
1

7.2 时间索引

pd.date_range(start=None,end=None,periods=None,freq=None,tz=None, ... **kwargs)：生成DatetimeIndex

官方文档：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.date_range.html
(https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.date_range.html)

freq的主要参数：

# 周期单位为Day
print(pd.date_range('2017-01-01', periods=2))
# 周期单位为hour
print(pd.date_range('2017-01-01 02', periods=2, freq='H'))
# 每个月月初
print(pd.date_range('2017-01', periods=3, freq='MS'))
# 每个月月底
print(pd.date_range('2017-01', periods=3, freq='M'))
1
2
3
4
5
6
7
8

DatetimeIndex(['2017-01-01', '2017-01-02'], dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2017-01-01 02:00:00', '2017-01-01 03:00:00'], dtype='datetime64[ns]', freq='H')
DatetimeIndex(['2017-01-01', '2017-02-01', '2017-03-01'], dtype='datetime64[ns]', freq='MS')
DatetimeIndex(['2017-01-31', '2017-02-28', '2017-03-31'], dtype='datetime64[ns]', freq='M')
1
2
3
4

7.3 周期

通过时间段与固定时间间隔一系列时间；

周期作用：可以获取指定年，指定月，指定日等的数据

• 周期：pd.Period(value=None,freq=None,ordinal=None,year=None,...)
• 周期序列：pd.period_range(start=None, end=None, periods=None, freq=None, name=None)：生成PeriodIndex
• pdata.to_period(freq=None, axis=0, copy=True)

import pandas as pd
import numpy as np
print(pd. Timestamp('2017-01-02'))
print(pd.Period('2017-01-02'))
print(pd.Period('2017-01'))
print(pd.Period('2017'))
1
2
3
4
5
6
'
运行
运行

2017-01-02 00:00:00
2017-01-02
2017-01
2017
1
2
3
4

# 周期单位为Day
print(pd.period_range('2017-01-01', periods=2))
# 周期单位为月
print(pd.period_range('2017-01', periods=2, freq='M'))
# 周期单位为小时
print(pd.period_range('2017-01-02', periods=2, freq='H'))
1
2
3
4
5
6

PeriodIndex(['2017-01-01', '2017-01-02'], dtype='period[D]')
PeriodIndex(['2017-01', '2017-02'], dtype='period[M]')
PeriodIndex(['2017-01-02 00:00', '2017-01-02 01:00'], dtype='period[H]')
1
2
3

tmp = pd.to_datetime(['2017-01-02', '2017-03-04'])
tmp.to_period('M')
1
2

PeriodIndex(['2017-01', '2017-03'], dtype='period[M]')
1

7.4 时间索引

很多数据及数据集中都会有时间维度，可以将其设置为时间索引；

内容：

• 获取指定时间数据
• 获取时间段数据
• 获取某个时期数据时期数据

# 准备数据
import pandas as pd
import numpy as np
# 注意这里是字符串
ts = ['2019-03-25','2019-03-26','2019-03-27','2019-03-28','2019-03-29','2019-03-30','2019-03-31',
 '2019-04-01','2019-04-02','2019-04-03','2019-04-04','2019-05-01','2019-04-05',]
values = np.arange(len(ts))
pdata = pd.DataFrame({'ts':ts, 'values':values})
pdata
1
2
3
4
5
6
7
8
9
'
运行
运行

pdata.ts.values
1

array(['2019-03-25', '2019-03-26', '2019-03-27', '2019-03-28',
       '2019-03-29', '2019-03-30', '2019-03-31', '2019-04-01',
       '2019-04-02', '2019-04-03', '2019-04-04', '2019-05-01',
       '2019-04-05'], dtype=object)
1
2
3
4

需求：

• 获取三月份数据
• 获取4月1号到4号数据
• 获取第2季度数据

# 生成时间索引
# 方式1：
tindex = pd.to_datetime(pdata['ts'])
tindex
1
2
3
4

0    2019-03-25
1    2019-03-26
2    2019-03-27
3    2019-03-28
4    2019-03-29
5    2019-03-30
6    2019-03-31
7    2019-04-01
8    2019-04-02
9    2019-04-03
10   2019-04-04
11   2019-05-01
12   2019-04-05
Name: ts, dtype: datetime64[ns]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 创建时间索引
tmp = pdata.set_index(tindex)
tmp.index
1
2
3

DatetimeIndex(['2019-03-25', '2019-03-26', '2019-03-27', '2019-03-28',
               '2019-03-29', '2019-03-30', '2019-03-31', '2019-04-01',
               '2019-04-02', '2019-04-03', '2019-04-04', '2019-05-01',
               '2019-04-05'],
              dtype='datetime64[ns]', name='ts', freq=None)
1
2
3
4
5

# 三月数据
tmp.loc['2019-03']
1
2

# 4月1号到4号数据：切片操作
tmp = tmp.sort_index()
tmp.loc['2019-04-01':'2019-04-05']
1
2
3

# 获取第2季度数据
# 按季度生成索引
qindex = tmp.index.to_period('Q')
qdata = tmp.set_index(qindex)
qdata.loc['2019Q2']
1
2
3
4
5

tmp.index.to_period('Q')
1

PeriodIndex(['2019Q1', '2019Q1', '2019Q1', '2019Q1', '2019Q1', '2019Q1',
             '2019Q1', '2019Q2', '2019Q2', '2019Q2', '2019Q2', '2019Q2',
             '2019Q2'],
            dtype='period[Q-DEC]', name='ts')
1
2
3
4

7.5 时间差值

• timedalte：两个datetime值之间的差(如日,秒和微妙)的类型

• pd.Timedelta(value=<object object at 0x0000023DD1424CC0>, unit=None, **kwargs)

# Timestamp相减
pd.Timestamp('2019-01-02')-pd.Timestamp('2019-01-01')
1
2

Timedelta('1 days 00:00:00')
1

pd.Timedelta(5, 'T')
1

Timedelta('0 days 00:05:00')
1

7.6 重采样

重采样作用：

• 降低采样率
• 提升采样率
• 方法：pdata.resample(rule,how=None,axis=0,fill_method=None,closed=None,label=None,convention='start'...)

应用场景：股票分析，金融等；

import pandas as pd
import numpy as np
index = pd.date_range('1/1/2000', periods=9, freq='2T')
series = pd.Series(range(9), index=index)
series
1
2
3
4
5
'
运行
运行

2000-01-01 00:00:00    0
2000-01-01 00:02:00    1
2000-01-01 00:04:00    2
2000-01-01 00:06:00    3
2000-01-01 00:08:00    4
2000-01-01 00:10:00    5
2000-01-01 00:12:00    6
2000-01-01 00:14:00    7
2000-01-01 00:16:00    8
Freq: 2T, dtype: int64
1
2
3
4
5
6
7
8
9
10

# 降低采样率，将时间间隔改成4S，每个时间对应值为均值
s = series.resample('4T')
s.groups
1
2
3

{Timestamp('2000-01-01 00:00:00'): 2,
 Timestamp('2000-01-01 00:04:00'): 4,
 Timestamp('2000-01-01 00:08:00'): 6,
 Timestamp('2000-01-01 00:12:00'): 8,
 Timestamp('2000-01-01 00:16:00'): 9}
1
2
3
4
5

Resampler对象相关方法：

s.first()
1

2000-01-01 00:00:00    0
2000-01-01 00:04:00    2
2000-01-01 00:08:00    4
2000-01-01 00:12:00    6
2000-01-01 00:16:00    8
Freq: 4T, dtype: int64
1
2
3
4
5
6

s.max()
1

2000-01-01 00:00:00    1
2000-01-01 00:04:00    3
2000-01-01 00:08:00    5
2000-01-01 00:12:00    7
2000-01-01 00:16:00    8
Freq: 4T, dtype: int64
1
2
3
4
5
6

s.mean()
1

2000-01-01 00:00:00    0.5
2000-01-01 00:04:00    2.5
2000-01-01 00:08:00    4.5
2000-01-01 00:12:00    6.5
2000-01-01 00:16:00    8.0
Freq: 4T, dtype: float64
1
2
3
4
5
6

#提高采样率，将时间间隔改成S，每个时间对应值为均值
rd = series.resample('T')
rd.bfill()
1
2
3

2000-01-01 00:00:00    0
2000-01-01 00:01:00    1
2000-01-01 00:02:00    1
2000-01-01 00:03:00    2
2000-01-01 00:04:00    2
2000-01-01 00:05:00    3
2000-01-01 00:06:00    3
2000-01-01 00:07:00    4
2000-01-01 00:08:00    4
2000-01-01 00:09:00    5
2000-01-01 00:10:00    5
2000-01-01 00:11:00    6
2000-01-01 00:12:00    6
2000-01-01 00:13:00    7
2000-01-01 00:14:00    7
2000-01-01 00:15:00    8
2000-01-01 00:16:00    8
Freq: T, dtype: int64
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7.7 时间迁移

• 时间序列常用操作：对数据按照时间进行迁移
• 迁移数据：df.shift(periods=1, freq=None, axis=0, fill_value=None)
• 迁移索引：df.tshift(periods=1, freq=None, axis=0) ——该方法已被弃用

index = pd.date_range('1/1/2000', periods=9, freq='D')
series = pd.Series(range(9), index=index)
series
1
2
3

2000-01-01    0
2000-01-02    1
2000-01-03    2
2000-01-04    3
2000-01-05    4
2000-01-06    5
2000-01-07    6
2000-01-08    7
2000-01-09    8
Freq: D, dtype: int64
1
2
3
4
5
6
7
8
9
10

series.shift(1, freq='T')
1

2000-01-01 00:01:00    0
2000-01-02 00:01:00    1
2000-01-03 00:01:00    2
2000-01-04 00:01:00    3
2000-01-05 00:01:00    4
2000-01-06 00:01:00    5
2000-01-07 00:01:00    6
2000-01-08 00:01:00    7
2000-01-09 00:01:00    8
Freq: D, dtype: int64
1
2
3
4
5
6
7
8
9
10

series.shift(1)
1

2000-01-01    NaN
2000-01-02    0.0
2000-01-03    1.0
2000-01-04    2.0
2000-01-05    3.0
2000-01-06    4.0
2000-01-07    5.0
2000-01-08    6.0
2000-01-09    7.0
Freq: D, dtype: float64
1
2
3
4
5
6
7
8
9
10

series.shift(1, freq='D')
1

2000-01-02    0
2000-01-03    1
2000-01-04    2
2000-01-05    3
2000-01-06    4
2000-01-07    5
2000-01-08    6
2000-01-09    7
2000-01-10    8
Freq: D, dtype: int64
1
2
3
4
5
6
7
8
9
10

8 数据清洗

数据清洗方式：

• 获取某列的唯一值:Series.unique()
• 每个值出现次数:Series.value_counts()
• 删除指定行列:pdata.drop(labels=None,axis=0,index=None,columns=None, level=None,inplace=False,errors='raise')
• 去重：pdata.drop_duplicates(subset=None, keep='first', inplace=False)

1. 产生数据

# 准备数据
import pandas as pd
import numpy as np
# 注意这里是字符串
ts = ['2019-03-25','2019-03-26','2019-03-26','2019-03-26','2019-03-29','2019-03-30','2019-03-31',
 '2019-04-01','2019-04-02','2019-04-03','2019-04-04','2019-05-01','2019-04-05',]
values = np.arange(len(ts))
pdata = pd.DataFrame({'ts':ts, 'values':values})
pdata
1
2
3
4
5
6
7
8
9
'
运行
运行

2. 唯一值与数值出现次数

# 唯一值
pdata.ts.unique()
1
2

array(['2019-03-25', '2019-03-26', '2019-03-29', '2019-03-30',
       '2019-03-31', '2019-04-01', '2019-04-02', '2019-04-03',
       '2019-04-04', '2019-05-01', '2019-04-05'], dtype=object)
1
2
3

# 数值出现次数
pdata.ts.value_counts()
1
2

ts
2019-03-26    3
2019-03-25    1
2019-03-29    1
2019-03-30    1
2019-03-31    1
2019-04-01    1
2019-04-02    1
2019-04-03    1
2019-04-04    1
2019-05-01    1
2019-04-05    1
Name: count, dtype: int64
1
2
3
4
5
6
7
8
9
10
11
12
13

3. 删除指定行列

# 删除指定行列
# 删除单行
print(pdata.drop(0))
1
2
3

            ts  values
1   2019-03-26       1
2   2019-03-26       2
3   2019-03-26       3
4   2019-03-29       4
5   2019-03-30       5
6   2019-03-31       6
7   2019-04-01       7
8   2019-04-02       8
9   2019-04-03       9
10  2019-04-04      10
11  2019-05-01      11
12  2019-04-05      12
1
2
3
4
5
6
7
8
9
10
11
12
13

# 删除多行
print(pdata.drop(index=[1,2,3]))
1
2

            ts  values
0   2019-03-25       0
4   2019-03-29       4
5   2019-03-30       5
6   2019-03-31       6
7   2019-04-01       7
8   2019-04-02       8
9   2019-04-03       9
10  2019-04-04      10
11  2019-05-01      11
12  2019-04-05      12
1
2
3
4
5
6
7
8
9
10
11

# 删除列
print(pdata.drop(columns='ts'))
1
2

    values
0        0
1        1
2        2
3        3
4        4
5        5
6        6
7        7
8        8
9        9
10      10
11      11
12      12
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 删除index为0值，删除列为ts的值
pdata.drop(index=0, columns='ts')
1
2

4. 去重

# 去重
# 保留第一次
pdata.drop_duplicates('ts')
1
2
3

#保留最后一次
pdata.drop_duplicates(subset='ts', keep='last')
1
2

#保留第一次数据，生成boolean索引，为True的为需要删除数据
bindex = pdata.duplicated(subset='ts')
pdata[bindex==False]
1
2
3

9 数据合并

目的：根据需求，合并多个数据集

• merge:
• join:
• concat:at:

9.1 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,validate=None)

主要参数：

合并方式：

1. 准备数据

import pandas as pd
import numpy as np
n1 = list('ABCE')
n2 = list('ABCD')
d1 = [90,80,100,69]
d2 = [95,78,96,72]
c1 = ['001','001','002','002']
c2 = ['001','001','002','002']
df1 = pd.DataFrame({'name':n1,'math':d1, 'class':c1})
df2 = pd.DataFrame({'name':n2,'chinese':d2, 'class':c2,'pname':n1})
1
2
3
4
5
6
7
8
9
10
'
运行
运行

df1
1

df2
1

2. 数据合并

#默认按索引合并
pd.merge(df1, df2)
1
2

#按class合并,根据class,两两组合，但是对于当前成绩来说，我们希望以名称进行合并
pd.merge(df1, df2, on = 'class')
1
2

#修改合并方式，取并集，会产生缺失数据
pd.merge(df1, df2, on = 'name', how='outer')
1
2

#指定left, 以left为主
pd.merge(df1, df2, on = 'name', how='left')
1
2

#指定right, 以right为主
pd.merge(df1, df2, on = 'name', how='right')
1
2

#实际工作中，数据集列名称可能不能，需要制定不同列名进行合并
pd.merge(df1, df2, left_on = 'name',right_on='pname')
1
2

9.2 join方法

join方法：DateFrame对象方法，与megre方法类似，how的方式默认为left

df1.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

主要参数：

df1
1

df2
1

#合并时候如果有相同列名，需要指定lsuffix，rsuffix，用于区分合并后列；
df1.join(df2, lsuffix='_x', rsuffix='_y')
1
2

df1.join(df2.set_index('class'), lsuffix='_x', rsuffix='_y', on ='class')
1

9.3 concat

concat：根据设置轴与条件，将两个数据进行拼接

pd.concat(objs,axis=0,join='outer',join_axes=None,ignore_index=False,keys=None,levels=None,names=None...)

参数说明：

#按axis=0， 按列进行拼接
pd.concat([df1, df2], sort= True)
1
2

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

#按axis=0， 按列进行拼接，并设置key，结果：多级索引
pd.concat([df1, df2], sort= True, keys=['p1', 'p2'])
1
2

#axis=1,按索引进行拼接
pd.concat([df1, df2], axis=1)
1
2

#axis=1,按索引进行拼接,列中增加多级索引
pd.concat([df1, df2], axis=1, keys=['s1','s2'])
1
2

#拼接数据，根据name进行拼接
t1 = df1.set_index('name')
t2 = df2.set_index('name')
pd.concat([t1, t2], axis=1, sort=True)
1
2
3
4

#拼接数据，根据name进行拼接,join设置为inner
t1 = df1.set_index('name')
t2 = df2.set_index('name')
pd.concat([t1, t2], axis=1, sort=True, join='inner')
1
2
3
4

10 pandas数据处理常用函数

目的：掌握apply, agg，str等函数，对数据灵活处理

10.1 apply函数

• 对pandas中DataFrame或者Series中每个数据进行处理
• apply方法：df.apply(func,axis=0,broadcast=None, raw=False,reduce=None, result_type=None,args=(), **kwds)

import pandas as pd
import numpy as np
n = list('ABCD')
math = [90,80,47,69]
chinese = [95,78,96,59]
nclass = ['001','001','002','002']
df = pd.DataFrame({'name':n,'math':math, 'chinese':chinese,'class':nclass})
df
1
2
3
4
5
6
7
8
'
运行
运行

name =df['name']
name
1
2

0    A
1    B
2    C
3    D
Name: name, dtype: object
1
2
3
4
5

# 修改name名字
name.apply(lambda x:x+x)
1
2

0    AA
1    BB
2    CC
3    DD
Name: name, dtype: object
1
2
3
4
5

# 将成绩转成True或者False
df[['math','chinese']].apply(lambda x : x>59)
1
2

10.2 func处理对象

def func(value):
    print(type(value))
    return np.mean(value)
df[['math','chinese']].apply(func)
1
2
3
4

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





math       71.5
chinese    82.0
dtype: float64
1
2
3
4
5
6
7
8
9
10

def func1(x):
    return x-x.mean()
df[['math','chinese']].apply(func1)
1
2
3

def func_min(x):
    return x-x.min()

sdata = df[['math','chinese']]
sdata.apply(func_min)
1
2
3
4
5

10.3 map

• 适用于Series对象或Df的某一列
• map方法：Series.map(arg, na_action=None)
• 对Series中的每个数值进行处理处理

df['math'].map(lambda x: 'pass' if x > 59 else 'failed')
1

0      pass
1      pass
2    failed
3      pass
Name: math, dtype: object
1
2
3
4
5

# 需求：将根据成绩单生成:'pass','failed'
func = lambda x: 'pass' if x > 59 else 'failed'
df[['math','chinese']].apply(lambda x : x.map(func))
1
2
3

10.4 replace：替换

• 对当前数据集中指定数据进行替换
• 方法：df.replace(to_replace=None,value=None,inplace=False,limit=None,regex=False,method='pad')

主要参数：

# 将A替换成a
df.replace('A', 'a')
1
2

# 将[A,B]替换成*
df.replace(['A','B'], '*')
1
2

# 一组数据替换
df.replace(list('ABCD'), list('abcd'))
1
2

# 正则：将所有字母替换成*
df.replace(r'[A-Z]','*', regex=True)
1
2

10.5 agg：聚合操作

• 按照设置axis对数据进行聚合操作(mean, max,…)
• df.agg(func, axis=0, *args, **kwargs)
• axis: 0:func应用到column, 1:func应用到rowow

df[['chinese', 'math']].agg(['mean', 'std'])
1

df[['chinese', 'math']].describe()
1

10.6 transform：处理数据

• 根据设置方法，对数据进行处理，得到新的数据
• df.transform(func, axis=0, *args, **kwargs)
• 每个科目数值减去均值去均值

df[['chinese', 'math']]
1

df[['chinese', 'math']].transform(lambda x:x-x.mean())
1

10.7 filter：过滤

• 根据标签过滤符合条件数据
• df.filter(items=None, like=None, regex=None, axis=None)

df.filter(['name'])
1

# 设置like：like in label
df.filter(like = 'n')
1
2

# 正则表达式:获取e结尾的列
df.filter(regex=r'.*e')
1
2

11 分组处理

目的：根据指定条件，对数据进行分组，然后在依据分组进行计算

例如：统计每天活跃用户总数，用户每天在线时长，用户平均消费水平等；

import pandas as pd
classname = ['001','001','002','002','003','003']
name = ['sun','li','zhou','wang','zao','wu']
height = [169, 172,180,170,165,175]
weights = [61,53,75,64,50,58]
df = pd.DataFrame({'cname':classname, 'user':name, 'height':height, 'weights':weights})
df
1
2
3
4
5
6
7
'
运行
运行

11.1 groupby分组

方法：df.groupby(by=None,axis=0,level=None,as_index=True,sort=True,group_keys=True,squeeze=False,observed=False,**kwargs)

主要参数：

# 创建DataFrameGroupBy 对象，
dfg = df.groupby('cname')
dfg.groups
1
2
3

{'001': [0, 1], '002': [2, 3], '003': [4, 5]}
1

# 分组统计
dfg.count()
1
2

# 根据多列进行分组：
dfg = df.groupby(['cname','height'])
dfg.groups
1
2
3

{('001', 169): [0], ('001', 172): [1], ('002', 170): [3], ('002', 180): [2], ('003', 165): [4], ('003', 175): [5]}
1

# 统计结果为多级索引
dfg.count()
1
2

11.2 聚合

分组得到groupby对象，可以通过聚合函数对其操作，获取聚合结果；

直白理解：对分组数据，进行处理；

import pandas as pd
import numpy as np
classname = ['001','001','002','002','003','003']
name = ['sun','li','zhou','wang','zao','wu']
height = [169, 172,180,170,165,175]
weights = [61,53,75,64,50,58]
df = pd.DataFrame({'cname':classname, 'user':name, 'height':height, 'weights':weights})
df_cname = df.drop('user', axis=1) # 删除列名为user的列
dfg = df_cname.groupby('cname')
df_cname
1
2
3
4
5
6
7
8
9
10
'
运行
运行

dfg.agg(['max', 'mean', 'std', 'count'])
1

11.3 transform

• 作用：将分组数据处理，得到一组新的数据
• 方法：dfg.transform(func, *args, **kwargs)
• 场景：分组数据中，与分组均值差,差,

# 每个班级平均身高，体重
dfg.transform('mean')
1
2

# 每个班级 学生-班级平均值(身高体重)
dfg.transform(lambda x: x-x.mean())
1
2

11.5 filter

• 过滤数据
• dfg.filter(func, dropna=True, *args, **kwargs)：根据过滤条件返回分组数据据

#返回分组身高均值大于171的数据
dfg['height'].filter(lambda x: np.mean(x)> 171)
1
2

2    180
3    170
Name: height, dtype: int64
1
2
3

dfg.count()
1

11.6 cut分组

• 根据设置区间进行分段汇总
• 方法：pd.cut(x,bins,right=True,labels=None,retbins=False,precision=3,include_lowest=False,duplicates='raise')

# 准备数据，统计70~79,80~89,90~100三个范围对应数量
df = pd.Series(np.random.randint(70,100, size = 10))
# 统计70~79,80~89,90~100三个范围对应数量
r = pd.cut(df, [70,80,90,101], right=False)
r
1
2
3
4
5

0     [70, 80)
1     [80, 90)
2     [70, 80)
3    [90, 101)
4     [70, 80)
5     [80, 90)
6    [90, 101)
7     [70, 80)
8    [90, 101)
9     [80, 90)
dtype: category
Categories (3, interval[int64, left]): [[70, 80) < [80, 90) < [90, 101)]
1
2
3
4
5
6
7
8
9
10
11
12

# 统计70~79,80~89,90~100三个范围对应数量,设置标签
r = pd.cut(df, [70,80,90,101], right=False, labels=['70+','80+','100+'])
r.groupby(r, observed=False).count()
1
2
3

70+     4
80+     3
100+    3
dtype: int64
1
2
3
4

#返回retbins
r,bins= pd.cut(df, [70,80,90,101], right=False, labels=['70+','80+','100+'],retbins=True)
bins
1
2
3

array([ 70,  80,  90, 101])
1

11.7 透视表

透视表是一种可以对数据动态排布并且分类汇总的表格格式，使用方式与groupby类似，但是比其简单；

方法：pd.pivot_table(data,values=None,index=None,columns=None,aggfunc='mean',fill_value=None,margins=False,...)

主要参数：

import pandas as pd
path = r'data\titanic.csv'
df = pd.read_csv(path)
df
1
2
3
4

891 rows × 15 columns

# 根据class等级统计男女获救的比例
# 1等仓，2等仓, ...
# 女性获救比例， x x ...
# 男性获救比例 x x ...
df.pivot_table(values='survived',index='sex', columns=['class'])
1
2
3
4
5

# 根据class等级统计男女获救的比例,统计所有值，并重命名
# 设置margins，统计所有男女获救比例
# 1等仓，2等仓, ...
# 女性获救比例， x x ...
# 男性获救比例 x x ...
df.pivot_table(values='survived',index='sex', columns=['class'],margins=True, margins_name='all_mean')
1
2
3
4
5
6

# 根据class等级与年龄段，统计男女获救的比例
cuts = pd.cut(df.age,[0,18,100])
df.pivot_table(values='survived',index=['sex',cuts], columns=['class'])
1
2
3

# 根据class等级与年龄段，统计男女获救的比例,数量，并统计所有值
cuts = pd.cut(df.age,[0,18,100])
df.pivot_table(values='survived',index=['sex'], columns=['class'], aggfunc=['mean', 'count'],margins=True)
1
2
3

11.8 str相关方法

str方法使Series对象内置方法，用于对字符串处理，与字符串相关方法类似；

• cat(others=None, sep=None, na_rep=None, join=None)：拼接字符串
• split(pat=None, n=-1, expand=False)：切分字符串
• get(i)：获取指定位置的字符串
• join(sep)：字符串拼接
• find(sub, start=0, end=None):查找,返回第一次出现子集位置
• contains(pat, case=True, flags=0, na=nan, regex=True):判断是否包含指定的值
• replace(pat, repl, n=-1, case=None, flags=0, regex=True)：替换
• sf.str.repeat(repeats):重复repeats次
• startswith(pat, na=nan):判断是否已pat开头
• sf.str.endswith(pat, na=nan):判断是否已pat结尾
• sf.str.strip(to_strip=None)：根据指定字符掐头去尾

sf = pd.Series(['a_1', 'b_2', 'c_3'])
sf.str.cat(list('ABC'), sep = '-')
1
2

0    a_1-A
1    b_2-B
2    c_3-C
dtype: object
1
2
3
4

sf.str.split('_', expand=True)
1

#提取有效字符，
sf.str.extract(r'([a-zA-Z]+)')
1
2

#字符开头
sf.str.match(r'([a-zA-Z]+)')
1
2

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

#查找所有字符与数字
sf.str.findall(r'([a-z0-9]+)')
1
2

0    [a, 1]
1    [b, 2]
2    [c, 3]
dtype: object
1
2
3
4

df = pd.DataFrame([ ["张三", "abcd1234"], ["李四", "a2b4c3r5"]], columns=["name", "pwd"]) 
df
1
2

12 pandas可视化

pandas可以直接绘制图表，实现基于matplotlib,使用方式与其类似，

方法：df.plot(*args, **kwargs)

主要参数：

12.1 基本使用

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
#数据
df = pd.DataFrame(np.random.randint(30,60, size=(6,4)), columns=list('ABCD'), index=range(6))
df
1
2
3
4
5
6
7

#绘制折线图
#x:index, y:默认所有columns
df.plot()
1
2
3

<AxesSubplot: >
1

​

​

#A使用左侧Y轴
df.A.plot()
#B使用右侧Y周
df.B.plot(secondary_y=True, style='g')
1
2
3
4

<AxesSubplot: >
1

​

​

12.2 plot中可视化方法

• 折线图：df.plot.line(x=None, y=None, **kwargs)
• 柱状图：df.plot.bar(x=None, y=None, **kwargs)
• 条形图：df.plot.barh(x=None, y=None, **kwargs)
• 直方图：df.plot.hist(by=None, bins=10, **kwargs)
• KDE图：df.plot.kde(bw_method=None, ind=None, **kwargs)
• 饼状图：df.plot.pie(**kwargs)
• 散点图：df.plot.scatter(x, y, s=None, c=None, **kwargs)
• 箱状图：df.plot.box(by=None, **kwargs)
• 区域块状图：df.plot.area(x=None, y=None, **kwargs)*kwargs)

# 柱状图
df.plot.bar()
1
2

<AxesSubplot: >
1

​

​

# 条状图
df.plot.barh()
1
2

<AxesSubplot: >
1

​

​

# 柱状图
df.plot.pie(y='A')
1
2

<AxesSubplot: ylabel='A'>
1

​

​