0 序
这一章节对pandas的基本属性和相关函数做了了解，包括Seires,DataFrame的用法等。话不多说，直接来学把～
导入三方模块
import pandas as pd
import numpy as np
1 文件的读取和写入
1.1 文件读取¶
1.1.1 csv文件读取
df_csv = pd.read_csv('./data/my_csv.csv')
df_csv.head()
1.1.2 txt文件读取
df_txt = pd.read_table('./data/my_table.txt')
df_txt.head()
1.1.3 excel文件读取
df_excel = pd.read_excel('./data/my_excel.xlsx', engine='openpyxl')
df_excel.head()
上面三个函数有一些常用的公共参数:
header=None - 第一行不作为列名
index_col - 把某一列或几列作为索引
usecols - 读取列的集合，默认读取所有的列
parse_dates - 需要转化为时间的列
nrows - 表示读取的数据行数
1.1.4 示范说明
1.1.4.1 第一行不作为列名（字段名）
df_txt_2 = pd.read_table('./data/my_table.txt', header=None)
df_txt_2.head()
可以发现，第一行数据不作为数据表字段了，而是到了第二行
pandas为这个数据自动生成了一串序号作为列名
1.1.4.2 设置两列作为索引
df_csv_2 = pd.read_csv('./data/my_csv.csv', index_col=['col1', 'col2'])
df_csv_2.head()
可以看到，索引列包括了col1和col2
1.1.4.3 不读取所有列，只读取两列
df_txt_3 = pd.read_table('./data/my_table.txt', usecols=['col1', 'col2'])
df_txt_3.head()
数据只读取了col1和col2列
1.1.4.4 将某列转化为时间格式
df_csv_3 = pd.read_csv('./data/my_csv.csv', parse_dates=['col5'])
df_csv_3.info()
col5的dtype从object转换成为为datetime64[ns]
1.1.4.5 只读取部分行
df_excel_2 = pd.read_excel('./data/my_excel.xlsx', nrows=2, engine='openpyxl')
print(df_excel_2)
的确，数据只读取了两行
1.1.4.5 txt分割后读取
在读取 txt 文件时，经常遇到分隔符非空格的情况
read_table 有一个分割参数 sep ，它使得用户可以自定义分割符号，进行 txt 数据的读取。
例如，下面的读取的表以 |||| 为分割
df_txt_special_sep = pd.read_table('./data/my_table_special_sep.txt')
df_txt_special_sep.head()
利用sep参数重新读取，同时需要指定引擎为python,’|'需要加上斜杠转义
df_txt_special_sep_2 = pd.read_table('./data/my_table_special_sep.txt', sep='\|\|\|\|', engine='python')
df_txt_special_sep_2.head()
1.2 数据写入
一般在数据写入中，最常用的操作是把 index 设置为 False ，特别当索引没有特殊意义的时候，这样的行为能把索引在保存的时候去除。
df_csv.head()
df_csv.to_csv('./data/my_csv_saved.csv', index=False)
df_excel.to_excel('./data/my_excel_saved.xlsx', index=False)
pandas没有定义to_table函数，但是to_csv可以保存为txt文件，并且允许自定义分割符
常用制表符\t分割
df_txt.to_csv('./data/my_txt_saved.txt', sep='t', index=False)
将表格转换为markdown和latex语言，可以使用to_markdown和to_latex函数
----pip install tabulate
print(df_csv.to_markdown())
print(df_csv.to_latex())
2 基本数据结构
pandas 中具有两种基本的数据存储结构:
存储一维 values 的 Series
存储二维 values 的 DataFrame
在这两种结构上定义了很多的属性和方法
2.1 Series
Series 一般由四个部分组成:序列的值 data 、索引 index 、存储类型 dtype 、序列的名字 name
其中，索引也可以指定它的名字，默认为空。
s = pd.Series(data=[100, 'a', {'dic1': 5}],
index=pd.Index(['id1', 20, 'third'], name='my_idx'),
dtype='object',
name='my_name')
print(s)
object 代表了一种混合类型
正如上面的例子中存储了整数、字符串以及 Python 的字典数据结构
此外，目前 pandas 把纯字符串序列也默认认为是一种 object 类型的序列，但它也可以用 string 类型存储。
对于上述属性，可以通过.的方式获取
利用.shape可以获取序列长度
s.shape
索引是 pandas 中最重要的概念之一
如果想要取出单个索引对应的值，可以通过 [index_item] 可以取出。
s['third']
2.2 DataFrame
DataFrame 在 Series 的基础上增加了列索引
一个数据框可以由二维的 data 与行列索引来构造
data = [[1, 'a', 1.2], [2, 'b', 2.2], [3, 'c', 3.2]]
df = pd.DataFrame(data=data,
index=['row_%d'%i for i in range(3)],
columns=['col_%d'%j for j in range(3)])
一般而言，更多的时候会采用从列索引名到数据的映射来构造数据框，同时再加上行索引
df = pd.DataFrame(data={'col_0': [1, 2, 3],
'col_1': list('abc'),
'col_2': [1.2, 2.2, 3.2]},
index=['row_%d'%k for k in range(3)])
由于这种映射关系，在 DataFrame 中可以用 [col_name] 与 [col_list] 来取出相应的列与由多个列组成的表
结果分别为 Series 和 DataFrame
df['col_0']
df[['col_0', 'col_1']]
与 Series 类似，在数据框中同样可以取出相应的属性
3 常用基本函数
为了进行举例说明，在接下来的部分和其余章节都将会使用一份 learn_pandas.csv 的虚拟数据集
它记录了四所学校学生的体测个人信息
df = pd.read_csv('./data/learn_pandas.csv')
df.head()
# 本章使用前7列
df = df[df.columns[:7]]
df.head()
3.1 汇总函数
head, tail 函数分别表示返回表或者序列的前 n 行和后 n 行，其中 n 默认为5。
df.tail()
info, describe 分别返回表的 信息概况 和表中 数值列对应的主要统计量
info()可以看到每个字段的基本情况，包括字段名，字段数据数，字段类型
df.describe()
describe()只针对数值型数据进行统计；
info, describe 只能实现较少信息的展示，如果想要对一份数据集进行全面且有效的观察，特别是在列较多的情况下，推荐使用 pandas-profiling 包。
3.2 特征统计函数
在 Series 和 DataFrame 上定义了许多统计函数，最常见的是 sum, mean, median, var, std, max, min
df_demo = df[['Height', 'Weight']]
此外，需要介绍的是 quantile, count, idxmax 这三个函数
它们分别返回的是分位数、非缺失值个数、最大值对应的索引；
# 分位数，默认0.5中位数，可以选择上下四分位数
df_demo.quantile()
# 计数（缺失值不计入）
df_demo.count()
# 最值对应的索引
print(df_demo.idxmax())
print(df_demo.idxmin())
上面这些所有的函数，由于操作后返回的是标量，所以又称为聚合函数，它们有一个公共参数 axis ，默认为0代表逐列聚合，如果设置为1则表示逐行聚合
3.3 唯一值函数
对序列使用 unique 和 nunique 可以分别得到其唯一值组成的列表和唯一值的个数
# 得到唯一值组成的列表
df['School'].unique()
# 得到唯一值的个数
df['School'].nunique()
# value_counts可以得到唯一值和其对应出现的频数，有点分组统计的样子
df['School'].value_counts()
如果想要观察多个列组合的唯一值，可以使用 drop_duplicates 。
其中的关键参数是 keep
默认值 first 表示每个组合保留第一次出现的所在行
last 表示保留最后一次出现的所在行
False 表示把所有重复组合所在的行剔除
df_demo = df[['Gender', 'Transfer', 'Name']]
df_demo.drop_duplicates(['Gender', 'Transfer'])
# 对于重复数据保留最后一次出现的所在行
df_demo.drop_duplicates(['Gender', 'Transfer'], keep='last')
# 保留只出现过一次的性别和姓名组合,即重复数据全部不保留
df_demo.drop_duplicates(['Name', 'Gender'], keep=False).head()
去重功能在Series也可以使用
此外， duplicated 和 drop_duplicates 的功能类似
前者返回了是否为唯一值的布尔列表，其 keep 参数与后者一致。
其返回的序列，把重复元素设为 True ，否则为 False
drop_duplicates 等价于把 duplicated 为 True 的对应行剔除
df_demo.duplicated(['Gender', 'Transfer']).head()
# Series上也可以使用
df['School'].duplicated().head()
3.4 替换函数
一般而言，替换操作是针对某一个列进行的，因此下面的例子都以 Series 举例
pandas 中的替换函数可以归纳为三类：映射替换、逻辑替换、数值替换;其中映射替换包含:
replace 方法
str.replace 方法
cat.codes 方法
此处介绍 replace 的用法
在 replace 中，可以通过字典构造，或者传入两个列表来进行替换
# 女性用0表示，男性用1表示
df['Gender'].replace({'Female': 0, 'Male': 1}).head()
df['Gender'].replace(['Female', 'Male'], [0, 1]).head()
另外， replace 还有一种特殊的方向替换
指定 method 参数为 ffill - 则为用前面一个最近的未被替换的值进行替换;
bfill - 则使用后面最近的未被替换的值进行替换
从下面的例子可以看到，它们的结果是不同的
s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s.replace([1, 2], method='ffill')
s.replace([1, 2], method='bfill')
虽然对于 replace 而言可以使用正则替换，但是当前版本下对于 string 类型的正则替换还存在 bug
因此如有此需求，请选择 str.replace 进行替换操作；
逻辑替换包括了 where 和 mask ，这两个函数是完全对称的：
where 函数在传入条件为 False 的对应行进行替换
而 mask 在传入条件为 True 的对应行进行替换，
当不指定替换值时，替换为缺失值。
s = pd.Series([-1, 1.2345, 100, -50])
# where - 把条件为False的替换掉
s.where(s<0)
# mask - 把条件为True的替换掉
s.mask(s<0)
s.mask(s<0, -50)
# 传入的条件只需是与被调用的 Series 索引一致的布尔序列即可
s_condition = pd.Series([True, False, False, True], index=s.index)
s_condition
s.mask(s_condition, -50)
数值替换包含了 round, abs, clip 方法，它们分别表示按照给定精度四舍五入、取绝对值和截断
# 所有元素替换成该元素的给定精度四舍五入
s.round(2)
# 所有元素替换成该元素的给定精度四舍五入
s.round(2)
# 所有元素按其绝对值替换
s.abs()
# 按照给点的边界截断
s.clip(0, 2)
练一练
在 clip 中，超过边界的只能截断为边界值，如果要把超出边界的替换为自定义的值，应当如何做？
# clip(a, b)后，如果超过边界，那只能是a或b； a替换成-99，b替换成99
s.clip(0, 2).replace({2: 99, 0: -99})
3.5 排序函数
排序共有两种方式，其一为值排序，其二为索引排序，对应的函数是 sort_values 和 sort_index 。
为了演示排序函数，下面先利用 set_index 方法把年级和姓名两列作为索引
df_demo = df[['Grade', 'Name', 'Height', 'Weight']].set_index(['Grade', 'Name'])
df_demo.head()
# 对身高升序排序
df_demo.sort_values('Height').head()
# 对身高降序排序
df_demo.sort_values('Height', ascending=False).head()
# 在体重相同的情况下，对身高进行排序，并且保持身高降序排列，体重升序排列
df_demo.sort_values(['Weight', 'Height'], ascending=[True, False]).head()
索引排序的用法和值排序完全一致，只不过元素的值在索引中，此时需要指定索引层的名字或者层号，用参数 level 表示。
另外，需要注意的是字符串的排列顺序由字母顺序决定
df_demo.sort_index(level=['Grade', 'Name'], ascending=[True, False]).head()
3.6 apply方法
apply 方法常用于 DataFrame 的行迭代或者列迭代，它的 axis 含义与第2小节中的统计聚合函数一致
apply 的参数往往是一个以序列为输入的函数
df_demo = df_demo[['Height', 'Weight']]
def my_mean(x):
res = x.mean()
return res
df_demo.apply(my_mean)
可以利用 lambda 表达式使得书写简洁，这里的 x 就指代被调用的 df_demo 表中逐个输入的序列
df_demo.apply(lambda x: x.mean())
利用 apply 计算升高和体重的 mad 指标
对比一下执行效率
df_demo.apply(lambda x: (x - x.mean()).abs().mean())
# 使用内置的mad函数
df_demo.mad()
得益于传入自定义函数的处理， apply 的自由度很高，但这是以性能为代价的。
一般而言，使用 pandas 的内置函数处理和 apply 来处理同一个任务，其速度会相差较多
因此只有在确实存在自定义需求的情境下才考虑使用 apply
4 窗口对象
pandas 中有3类窗口，分别是滑动窗口 rolling 、扩张窗口 expanding 以及指数加权窗口 ewm
需要说明的是，以日期偏置为窗口大小的滑动窗口将在第十章讨论，指数加权窗口见本章练习
4.1 滑窗对象
要使用滑窗函数，就必须先要对一个序列使用 .rolling 得到滑窗对象，其最重要的参数为窗口大小 window
s = pd.Series([1, 2, 3, 4, 5])
roller = s.rolling(window=3)
为何要引入窗口函数
因为有些特殊的时序数据难以直接进行操作。
窗口函数方便处理时序数据，解决了滞后性和数据分布的不稳定性。
主要用于通过平滑曲线来以图形方式查找数据内的趋势
window = 数值型int --> 计算统计量的观测值的数量，及从第0个元素开始，
向前数window个，然后在使用后面定义的函数
window = offset时间偏移量 --> 表示时间窗的大小
s = pd.Series([1,2,3,4,5]) --> [1,2,3,4,5]
经过：s.rolling(window=3) -->
从第0个下标，往前数3个，[空，空 ，1]
从第1个下标，往前数3个，[空，1 ， 2]
从第2个下标，往前数3个，[1， 2， 3]
从第3个下标，往前数3个，[2， 3， 4]
从第4个下标，往前数3个，[3， 4， 5]
然后得到的元素，在经过统计函数，mean()进行计算。
第n个元素的值将是n，n-1和n-2元素的平均值
便形成了：
0 NaN
1 NaN
2 2.0
3 3.0
4 4.0
还支持使用 apply 传入自定义函数，其传入值是对应窗口的 Series ，例如上述的均值函数可以等效表示
roller.apply(lambda x:x.mean())
shift, diff, pct_change 是一组类滑窗函数，它们的公共参数为 periods=n ，默认为1
shift - 取向前第 n 个元素的值
diff - 与向前第 n 个元素做差（与 Numpy 中不同，后者表示 n 阶差分）
pct_change - 与向前第 n 个元素相比计算增长率。这里的 n 可以为负，表示反方向的类似操作
s = pd.Series([1, 3, 6, 10, 15])
# 取向前第 n 个元素的值
s.shift(2)
# 与向前第 n 个元素相比计算增长率
s.pct_change()
将其视作类滑窗函数的原因是，它们的功能可以用窗口大小为 n+1 的 rolling 方法等价代替
如下面列表,取每个元素窗口列表的第一个元素，等价与将s往前移2格
'''
s = pd.Series([1,3,6,10,15])--> [1,3,6,10,15]
经过：s.rolling(window=3) -->
从第0个下标，往前数3个，[空，空 ，1]
从第1个下标，往前数3个，[空，1 ， 3]
从第2个下标，往前数3个，[1， 3， 6]
从第3个下标，往前数3个，[3， 6， 10]
从第4个下标，往前数3个，[6， 10，15]
'''
s.rolling(3).apply(lambda x: list(x)[0])
# 等价于s.diff(3)
s.rolling(4).apply(lambda x: list(x)[-1] - list(x)[0])
def my_pct(x):
L = list(x)
return L[-1] / L[0] - 1
# 等价s.pct_change(1)
s.rolling(2).apply(my_pct)
4.2 扩张窗口
扩张窗口又称累计窗口，可以理解为一个动态长度的窗口
其窗口的大小就是从序列开始处到具体操作的对应位置，其使用的聚合函数会作用于这些逐步扩张的窗口上
具体地说，设序列为a1, a2, a3, a4，则其每个位置对应的窗口即[a1]、[a1, a2]、[a1, a2, a3]、[a1, a2, a3, a4]
s = pd.Series([1, 3, 6, 10])
s.expanding().mean()
5 练习
5.1 口袋妖怪数据集
现有一份口袋妖怪的数据集，下面进行一些背景说明：
‘#’ 代表全国图鉴编号，不同行存在相同数字则表示为该妖怪的不同状态
妖怪具有单属性和双属性两种，对于单属性的妖怪， Type 2 为缺失值
Total, HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 分别代表种族值、体力、物攻、防御、特攻、特防、速度，其中种族值为后6项之和;
1.对 HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 进行加总，验证是否为 Total 值。
2.对于 # 重复的妖怪只保留第一条记录，解决以下问题：
求第一属性的种类数量和前三多数量对应的种类
求第一属性和第二属性的组合种类
求尚未出现过的属性组合
3.按照下述要求，构造 Series ：
取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid
取出第一属性，分别用 replace 和 apply 替换所有字母为大写
求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序
data = pd.read_csv('./data/pokemon.csv')
A1
columns = ['HP', 'Attack', 'Defense', 'Sp. Def', 'Sp. Atk', 'Speed']
data['Total_unsure'] = data[columns].sum(axis=1)
data['Total_seq'] = data['Total'] == data['Total_unsure']
data.groupby('Total_seq')['#'].count()
800条数据的Total值都是后6项能力数值的加总无误
A2
# 去重
data.drop_duplicates(subset=['#'], keep='first', inplace=True)
data.info()
'''去重后剩余721条记录'''
# 第一属性的种类数量和前三多数量对应的种类
len(data.groupby('Type 1')['#'].count().sort_values(ascending=False))
# len(set(data['Type 1']))
第一属性的种类数量有18种
data.groupby('Type 1')['#'].count().sort_values(ascending=False)
其中，前三多数量对应的种类为Water(水)，Normal(普通),Grass(草)
# 第一属性和第二属性的组合种类
data.groupby(['Type 1', 'Type 2'])['#'].count()
第一属性和第二属性的组合种类有125种
# 求尚未出现过的属性组合
## 先看一下都有哪些属性
Type_1 = set(data['Type 1'])
Type_1
Type_2 = set(data['Type 2'])
Type_2
可以看出，种类一共就18种
# 看一下数据集里出现了多少组合
data['Type'] = data['Type 1'] + '-' + data['Type 2']
Type = set(data['Type'])
len(Type)
'''126'''
通过观察发现，属性A-B不会出现B-A的重复项
Type_list = []
for i in Type_1:
Type_list.append(i)
# 故人工组合一下所有可能的组合
'''17+16+...+1=153'''
list = []
for i in range(0, 18):
type_1 = Type_list[i]
k = i + 1
while k < 18:
type_2 = Type_list[k]
list.append(str(type_1) + '-' + str(type_2))
k += 1
len(list)
'''153 正好是所有组合'''
# Type是数据中出现的组合
# list是153种所有可能出现的组合
list_other = []
for i in Type:
if i not in list:
list_other.append(i)
A3
按照下述要求，构造 Series ：
取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid
取出第一属性，分别用 replace 和 apply 替换所有字母为大写
求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序
def func_1(x):
if x < 50:
return 'low'
elif x <= 120:
return 'mid'
else:
return 'high'
data['Attack_level'] = data['Attack'].apply(lambda x : func_1(x))
data[['Attack', 'Attack_level']].head()
取出第一属性，分别用 replace 和 apply 替换所有字母为大写
# replace
data['Type 1'].replace({i: str.upper(i) for i in data['Type 1'].unique()}).head()
# apply
data['Type 1'].apply(lambda x: str.upper(x)).head()
求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序
data['Deviation'] = data[columns].apply(lambda x:np.max((x-x.median()).abs()), 1)
data.sort_values('Deviation', ascending=False).head()
5.2 指数加权窗口
作为扩张窗口的 ewm 窗口
在扩张窗口中，用户可以使用各类函数进行历史的累计指标统计，但这些内置的统计函数往往把窗口中的所有元素赋予了同样的权重。事实上，可以给出不同的权重来赋给窗口中的元素，指数加权窗口就是这样一种特殊的扩张窗口
其中，最重要的参数是 alpha ，它决定了默认情况下的窗口权重为 𝑤𝑖=(1−𝛼)𝑖,𝑖∈{0,1,…,𝑡} ，其中 𝑖=𝑡 表示当前元素， 𝑖=0 表示序列的第一个元素
从权重公式可以看出，离开当前值越远则权重越小，若记原序列为 x ，更新后的当前元素为 𝑦𝑡 ，此时通过加权公式归一化后可知
对于 Series 而言，可以用 ewm 对象如下计算指数平滑后的序列：
np.random.seed(0)
s = pd.Series(np.random.randint(-1, 2, 30).cumsum())
s.head()
s.ewm(alpha=0.2).mean().head()
请用expending窗口实现
def ewm_func(x, alpha=0.2):
win = (1-alpha)**np.arange(x.shape[0])[::-1]
res = (win*x).sum()/win.sum()
return res
s.expanding().apply(ewm_func).head()
作为滑动窗口的 ewm 窗口
从第1问中可以看到， ewm 作为一种扩张窗口的特例，只能从序列的第一个元素开始加权。现在希望给定一个限制窗口 n ，只对包含自身的最近的 n 个元素作为窗口进行滑动加权平滑。请根据滑窗函数，给出新的 𝑤𝑖 与 𝑦𝑡 的更新公式，并通过 rolling 窗口实现这一功能;
s.rolling(window=4).apply(ewm_func).head()
6 总结
这一章节学下来，感觉pandas零零碎碎的函数和属性是非常多的，每个分解来看都不难，难的是融会贯通，难的是在特定场景下最高效快捷地解决问题；
而且从练习题可以看出，想要学好pandas和numpy，数学的逻辑的基本功底还是要有一些的。抽空最好补充一下线性代数方面的知识，不然numpy会比较困难。
希望大家能有收获，下次学习我们继续～
238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
