文件的读取和写入
文件读取
df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv') # 可以写相对路径也可以写绝对路径
df_csv
| col1 | col2 | col3 | col4 | col5 | |
|---|---|---|---|---|---|
| 0 | 2 | a | 1.4 | apple | 2020/1/1 |
| 1 | 3 | b | 3.4 | banana | 2020/1/2 |
| 2 | 6 | c | 2.5 | orange | 2020/1/5 |
| 3 | 5 | d | 3.2 | lemon | 2020/1/7 |
df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table.txt')
df_txt
| col1 | col2 | col3 | col4 | |
|---|---|---|---|---|
| 0 | 2 | a | 1.4 | apple 2020/1/1 |
| 1 | 3 | b | 3.4 | banana 2020/1/2 |
| 2 | 6 | c | 2.5 | orange 2020/1/5 |
| 3 | 5 | d | 3.2 | lemon 2020/1/7 |
df_excel = pd.read_excel('G:\代码\joyful-pandas-master\data\my_excel.xlsx')
df_excel
| col1 | col2 | col3 | col4 | col5 | |
|---|---|---|---|---|---|
| 0 | 2 | a | 1.4 | apple | 2020/1/1 |
| 1 | 3 | b | 3.4 | banana | 2020/1/2 |
| 2 | 6 | c | 2.5 | orange | 2020/1/5 |
| 3 | 5 | d | 3.2 | lemon | 2020/1/7 |
- header=None 表示第一行不作为列名
- index_col 表示把某一列或几列作为索引
- usecols 表示读取列的集合，默认读取所有的列
- parse_dates 表示需要转化为时间的列
- nrows 表示读取的数据行数
df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv', header=None)
df_csv
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 0 | col1 | col2 | col3 | col4 | col5 |
| 1 | 2 | a | 1.4 | apple | 2020/1/1 |
| 2 | 3 | b | 3.4 | banana | 2020/1/2 |
| 3 | 6 | c | 2.5 | orange | 2020/1/5 |
| 4 | 5 | d | 3.2 | lemon | 2020/1/7 |
df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv', index_col=['col1', 'col2'])
df_csv
| col3 | col4 | col5 | ||
|---|---|---|---|---|
| col1 | col2 | |||
| 2 | a | 1.4 | apple | 2020/1/1 |
| 3 | b | 3.4 | banana | 2020/1/2 |
| 6 | c | 2.5 | orange | 2020/1/5 |
| 5 | d | 3.2 | lemon | 2020/1/7 |
df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table.txt', usecols=['col1', 'col2'])
df_txt
| col1 | col2 | |
|---|---|---|
| 0 | 2 | a |
| 1 | 3 | b |
| 2 | 6 | c |
| 3 | 5 | d |
df_csv = pd.read_csv('G:\代码\joyful-pandas-master\data\my_csv.csv', parse_dates=['col5'])
type(df_csv['col5'])
pandas.core.series.Series
df_excel = pd.read_excel('G:\代码\joyful-pandas-master\data\my_excel.xlsx', nrows=2) # 只读两行
df_excel
| col1 | col2 | col3 | col4 | col5 | |
|---|---|---|---|---|---|
| 0 | 2 | a | 1.4 | apple | 2020/1/1 |
| 1 | 3 | b | 3.4 | banana | 2020/1/2 |
在读取 txt 文件时，经常遇到分隔符非空格的情况，read_table 有一个分割参数 sep ，它使得用户可以自定义分割符号，进行 txt 数据的读取。例如，下面的读取的表以 |||| 为分割：
df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table_special_sep.txt')
df_txt
| col1 |||| col2 | |
|---|---|
| 0 | TS |||| This is an apple. |
| 1 | GQ |||| My name is Bob. |
| 2 | WT |||| Well done! |
| 3 | PT |||| May I help you? |
这时可以使用 sep ，同时需要指定引擎为 python
注：参数 sep 中使用的是正则表达式，因此需要对 | 进行转义变成 | ，否则无法读取到正确的结果
df_txt = pd.read_table('G:\代码\joyful-pandas-master\data\my_table_special_sep.txt',
sep=' \|\|\|\| ', engine='python')
df_txt
| col1 | col2 | |
|---|---|---|
| 0 | TS | This is an apple. |
| 1 | GQ | My name is Bob. |
| 2 | WT | Well done! |
| 3 | PT | May I help you? |
数据写入
一般在数据写入的时候，最常用的操作是把 index 设置为 False ，特别当索引没有特殊意义的时候，这样可以在保存文件的时候不保存索引
df_csv.to_csv('G:\代码\joyful-pandas-master\data\my_csv_saved.csv', index=False)
pandas 中没有定义 to_table 函数，但是 to_csv 可以保存为 txt 文件，并且允许自定义分隔符，常用制表符 \t 分割：
df_txt.to_csv('G:\代码\joyful-pandas-master\data\my_txt_saved.txt', sep='\t', index=False)
如果想要把表格快速转换为 markdown 和 latex 语言，可以使用 to_markdown 和 to_latex 函数，需要安装 tabulate 包
print(df_csv.to_markdown())
| | col1 | col2 | col3 | col4 | col5 |
|---:|-------:|:-------|-------:|:-------|:--------------------|
| 0 | 2 | a | 1.4 | apple | 2020-01-01 00:00:00 |
| 1 | 3 | b | 3.4 | banana | 2020-01-02 00:00:00 |
| 2 | 6 | c | 2.5 | orange | 2020-01-05 00:00:00 |
| 3 | 5 | d | 3.2 | lemon | 2020-01-07 00:00:00 |
print(df_csv.to_latex())
\begin{tabular}{lrlrll}
\toprule
{} & col1 & col2 & col3 & col4 & col5 \\
\midrule
0 & 2 & a & 1.4 & apple & 2020-01-01 \\
1 & 3 & b & 3.4 & banana & 2020-01-02 \\
2 & 6 & c & 2.5 & orange & 2020-01-05 \\
3 & 5 & d & 3.2 & lemon & 2020-01-07 \\
\bottomrule
\end{tabular}
基本数据结构
pandas 中具有两种基本的数据存储结构，存储一维 values 的 Series 和存储二维 values 的 DataFrame ，在这两种结构上定义了很多的属性和方法。
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')
s
my_idx
id1 100
20 a
third {'dic1': 5}
Name: my_name, dtype: object
对于这些属性，可以通过 . 的方式来获取：
print('s.values:',s.values)
print('s.index：',s.index)
print('s.dtype：',s.dtype)
print('s.name：',s.name)
s.values: [100 'a' {'dic1': 5}]
s.index： Index(['id1', 20, 'third'], dtype='object', name='my_idx')
s.dtype： object
s.name： my_name
利用 .shape 可以获取序列的长度：
s.shape
(3,)
如果想要取出单个索引对应的值，可以通过 [index_item] 可以取出：
s['third']
{'dic1': 5}
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_0', 'col_1', 'col_2'])
df
| col_0 | col_1 | col_2 | |
|---|---|---|---|
| row_0 | 1 | a | 1.2 |
| row_1 | 2 | b | 2.2 |
| row_2 | 3 | c | 3.2 |
但一般而言，更多的时候会采用从列索引名到数据的映射来构造数据框，同时再加上行索引：
df = pd.DataFrame(data = {'col_0': [1,2,3], 'col_1':list('abc'),
'col_2': [1.2, 2.2, 3.2]},
index = ['row_%d'%i for i in range(3)])
df
| col_0 | col_1 | col_2 | |
|---|---|---|---|
| row_0 | 1 | a | 1.2 |
| row_1 | 2 | b | 2.2 |
| row_2 | 3 | c | 3.2 |
由于这种映射关系，在 DataFrame 中可以用 [col_name] 与 [col_list] 来取出相应的列与由多个列组成的表，结果分别为 Series 和 DataFrame ：
print(df['col_0'])
print(type(df['col_0']))
print('\n')
print(df[['col_0', 'col_1']])
print(type(df[['col_0', 'col_1']]))
row_0 1
row_1 2
row_2 3
Name: col_0, dtype: int64
<class 'pandas.core.series.Series'>
col_0 col_1
row_0 1 a
row_1 2 b
row_2 3 c
<class 'pandas.core.frame.DataFrame'>
与 Series 类似，在数据框中同样可以取出相应的属性：
print('df.values:')
print(df.values)
print('\n')
print('df.index:')
print(df.index)
print('\n')
print('df.columns:')
print(df.columns)
print('\n')
print('df.dtypes:')
print(df.dtypes)
print('\n')
print('df.shape:')
print(df.shape)
df.values:
[[1 'a' 1.2]
[2 'b' 2.2]
[3 'c' 3.2]]
df.index:
Index(['row_0', 'row_1', 'row_2'], dtype='object')
df.columns:
Index(['col_0', 'col_1', 'col_2'], dtype='object')
df.dtypes:
col_0 int64
col_1 object
col_2 float64
dtype: object
df.shape:
(3, 3)
通过 .T 可以把 DataFrame 进行转置：
df.T
| row_0 | row_1 | row_2 | |
|---|---|---|---|
| col_0 | 1 | 2 | 3 |
| col_1 | a | b | c |
| col_2 | 1.2 | 2.2 | 3.2 |
常用基本函数
以如下四所学校学生的体测信息为例进行分析：
df = pd.read_csv('G:\代码\joyful-pandas-master\data\learn_pandas.csv')
df
| School | Grade | Name | Gender | Height | Weight | Transfer | Test_Number | Test_Date | Time_Record | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | Shanghai Jiao Tong University | Freshman | Gaopeng Yang | Female | 158.9 | 46.0 | N | 1 | 2019/10/5 | 0:04:34 |
| 1 | Peking University | Freshman | Changqiang You | Male | 166.5 | 70.0 | N | 1 | 2019/9/4 | 0:04:20 |
| 2 | Shanghai Jiao Tong University | Senior | Mei Sun | Male | 188.9 | 89.0 | N | 2 | 2019/9/12 | 0:05:22 |
| 3 | Fudan University | Sophomore | Xiaojuan Sun | Female | NaN | 41.0 | N | 2 | 2020/1/3 | 0:04:08 |
| 4 | Fudan University | Sophomore | Gaojuan You | Male | 174.0 | 74.0 | N | 2 | 2019/11/6 | 0:05:22 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 195 | Fudan University | Junior | Xiaojuan Sun | Female | 153.9 | 46.0 | N | 2 | 2019/10/17 | 0:04:31 |
| 196 | Tsinghua University | Senior | Li Zhao | Female | 160.9 | 50.0 | N | 3 | 2019/9/22 | 0:04:03 |
| 197 | Shanghai Jiao Tong University | Senior | Chengqiang Chu | Female | 153.9 | 45.0 | N | 1 | 2020/1/5 | 0:04:48 |
| 198 | Shanghai Jiao Tong University | Senior | Chengmei Shen | Male | 175.3 | 71.0 | N | 2 | 2020/1/7 | 0:04:58 |
| 199 | Tsinghua University | Sophomore | Chunpeng Lv | Male | 155.7 | 51.0 | N | 1 | 2019/11/6 | 0:05:05 |
200 rows × 10 columns
df.columns
Index(['School', 'Grade', 'Name', 'Gender', 'Height', 'Weight', 'Transfer',
'Test_Number', 'Test_Date', 'Time_Record'],
dtype='object')
df = df[df.columns[:7]]
汇总函数
head, tail 函数分别表示返回表或者序列的前 n 行和后 n 行，其中 n 默认为5：
df.head(2)
| School | Grade | Name | Gender | Height | Weight | Transfer | Test_Number | Test_Date | Time_Record | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | Shanghai Jiao Tong University | Freshman | Gaopeng Yang | Female | 158.9 | 46.0 | N | 1 | 2019/10/5 | 0:04:34 |
| 1 | Peking University | Freshman | Changqiang You | Male | 166.5 | 70.0 | N | 1 | 2019/9/4 | 0:04:20 |
df.tail(3)
| School | Grade | Name | Gender | Height | Weight | Transfer | Test_Number | Test_Date | Time_Record | |
|---|---|---|---|---|---|---|---|---|---|---|
| 197 | Shanghai Jiao Tong University | Senior | Chengqiang Chu | Female | 153.9 | 45.0 | N | 1 | 2020/1/5 | 0:04:48 |
| 198 | Shanghai Jiao Tong University | Senior | Chengmei Shen | Male | 175.3 | 71.0 | N | 2 | 2020/1/7 | 0:04:58 |
| 199 | Tsinghua University | Sophomore | Chunpeng Lv | Male | 155.7 | 51.0 | N | 1 | 2019/11/6 | 0:05:05 |
info, describe 分别返回表的 信息概况 和表中 数值列对应的主要统计量：
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 10 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 School 200 non-null object
1 Grade 200 non-null object
2 Name 200 non-null object
3 Gender 200 non-null object
4 Height 183 non-null float64
5 Weight 189 non-null float64
6 Transfer 188 non-null object
7 Test_Number 200 non-null int64
8 Test_Date 200 non-null object
9 Time_Record 200 non-null object
dtypes: float64(2), int64(1), object(7)
memory usage: 15.8+ KB
df.describe()
| Height | Weight | Test_Number | |
|---|---|---|---|
| count | 183.000000 | 189.000000 | 200.000000 |
| mean | 163.218033 | 55.015873 | 1.645000 |
| std | 8.608879 | 12.824294 | 0.722207 |
| min | 145.400000 | 34.000000 | 1.000000 |
| 25% | 157.150000 | 46.000000 | 1.000000 |
| 50% | 161.900000 | 51.000000 | 1.500000 |
| 75% | 167.500000 | 65.000000 | 2.000000 |
| max | 193.900000 | 89.000000 | 3.000000 |
特征统计函数
在 Series 和 DataFrame 上定义了许多统计函数，最常见的是 sum, mean, median, var, std, max, min。
df_demo = df[['Height', 'Weight']]
df_demo.mean()
Height 163.218033
Weight 55.015873
dtype: float64
quantile, count, idxmax 三个函数，它们分别返回的是分位数、非缺失值个数、最大值对应的索引：
df_demo.quantile(0.75)
Height 167.5
Weight 65.0
Name: 0.75, dtype: float64
df_demo.count()
Height 183
Weight 189
dtype: int64
df_demo.idxmax()
Height 193
Weight 2
dtype: int64
上面这些所有的函数，由于操作后返回的是标量，所以又称为聚合函数，它们有一个公共参数 axis ，默认为0代表逐列聚合，如果设置为1则表示逐行聚合：
df_demo.mean(axis=1).head() # 表示按行求身高和体重的均值
0 102.45
1 118.25
2 138.95
3 41.00
4 124.00
dtype: float64
唯一值函数
对序列使用 unique 和 nunique 可以分别得到其唯一值组成的列表和唯一值的个数：
print(df['School'].unique())
print(df['School'].nunique())
['Shanghai Jiao Tong University' 'Peking University' 'Fudan University'
'Tsinghua University']
4
value_counts 可以得到唯一值和其对应出现的频数：
df['School'].value_counts()
Tsinghua University 69
Shanghai Jiao Tong University 57
Fudan University 40
Peking University 34
Name: School, dtype: int64
如果想要观察多个列组合的唯一值，可以使用 drop_duplicates。其中的关键参数是 keep，默认值 first 表示每个组合保留第一次出现的所在行， last 表示保留最后一次出现的所在行， False 表示把所有重复组合所在的行剔除。
df_demo = df[['Gender','Transfer','Name']]
df_demo.drop_duplicates(['Gender', 'Transfer'])
| Gender | Transfer | Name | |
|---|---|---|---|
| 0 | Female | N | Gaopeng Yang |
| 1 | Male | N | Changqiang You |
| 12 | Female | NaN | Peng You |
| 21 | Male | NaN | Xiaopeng Shen |
| 36 | Male | Y | Xiaojuan Qin |
| 43 | Female | Y | Gaoli Feng |
df_demo.drop_duplicates(['Gender', 'Transfer'], keep='last')
| Gender | Transfer | Name | |
|---|---|---|---|
| 147 | Male | NaN | Juan You |
| 150 | Male | Y | Chengpeng You |
| 169 | Female | Y | Chengquan Qin |
| 194 | Female | NaN | Yanmei Qian |
| 197 | Female | N | Chengqiang Chu |
| 199 | Male | N | Chunpeng Lv |
df_demo.drop_duplicates(['Name', 'Gender'],keep=False).head() # 保留只出现过一次的性别和姓名组合
| Gender | Transfer | Name | |
|---|---|---|---|
| 0 | Female | N | Gaopeng Yang |
| 1 | Male | N | Changqiang You |
| 2 | Male | N | Mei Sun |
| 4 | Male | N | Gaojuan You |
| 5 | Female | N | Xiaoli Qian |
df['School'].drop_duplicates()
0 Shanghai Jiao Tong University
1 Peking University
3 Fudan University
5 Tsinghua University
Name: School, dtype: object
此外， duplicated 和 drop_duplicates 的功能类似，但前者返回了是否为唯一值的布尔列表，其 keep 参数与后者一致。其返回的序列，把重复元素设为 True ，否则为 False 。 drop_duplicates 等价于把 duplicated 为 True 的对应行剔除。
print(df_demo.head())
print('\n')
print(df_demo.duplicated(['Gender', 'Transfer']).head())
Gender Transfer Name
0 Female N Gaopeng Yang
1 Male N Changqiang You
2 Male N Mei Sun
3 Female N Xiaojuan Sun
4 Male N Gaojuan You
0 False
1 False
2 True
3 True
4 True
dtype: bool
print(df['School'].head())
print('\n')
print(df['School'].duplicated().head())
0 Shanghai Jiao Tong University
1 Peking University
2 Shanghai Jiao Tong University
3 Fudan University
4 Fudan University
Name: School, dtype: object
0 False
1 False
2 True
3 False
4 True
Name: School, dtype: bool
替换函数
一般而言，替换操作是针对某一个列进行的，因此下面的例子都以 Series 举例。pandas 中的替换函数可以归纳为三类：映射替换、逻辑替换、数值替换。
在 replace 中，可以通过字典构造，或者传入两个列表来进行替换：
df['Gender'].replace({'Female':0, 'Male':1}).head()
0 0
1 1
2 1
3 0
4 1
Name: Gender, dtype: int64
df['Gender'].replace(['Female', 'Male'], [0, 1]).head()
0 0
1 1
2 1
3 0
4 1
Name: Gender, dtype: int64
另外， replace 还有一种特殊的方向替换，指定 method 参数为 ffill 则为用前面一个最近的未被替换的值进行替换， bfill 则使用后面最近的未被替换的值进行替换。从下面的例子可以看到，它们的结果是不同的：
s = pd.Series(['a', 1, 'b', 2, 1, 1, 'a'])
s
0 a
1 1
2 b
3 2
4 1
5 1
6 a
dtype: object
s.replace([1, 2], method='bfill')
0 a
1 b
2 b
3 a
4 a
5 a
6 a
dtype: object
s.replace([1, 2], method='ffill')
0 a
1 a
2 b
3 b
4 b
5 b
6 a
dtype: object
逻辑替换包括了 where 和 mask ，这两个函数是完全对称的： where 函数在传入条件为 False 的对应行进行替换，而 mask 在传入条件为 True 的对应行进行替换，当不指定替换值时，替换为缺失值。
s = pd.Series([-1, 1.2345, 100, -50])
s
0 -1.0000
1 1.2345
2 100.0000
3 -50.0000
dtype: float64
s.where(s<0)
0 -1.0
1 NaN
2 NaN
3 -50.0
dtype: float64
s.mask(s<0)
0 NaN
1 1.2345
2 100.0000
3 NaN
dtype: float64
s.mask(s<0, -50) # 指定替换值为 -50
0 -50.0000
1 1.2345
2 100.0000
3 -50.0000
dtype: float64
需要注意的是，传入的条件只需是与被调用的 Series 索引一致的布尔序列即可：
s_condition= pd.Series([True,False,False,True],index=s.index)
s_condition
0 True
1 False
2 False
3 True
dtype: bool
s.mask(s_condition, -50)
0 -50.0000
1 1.2345
2 100.0000
3 -50.0000
dtype: float64
数值替换包含了 round, abs, clip 方法，它们分别表示取整、取绝对值和截断：
s = pd.Series([-1, 1.2345, 100, -50])
print(s)
print('\n')
print(s.round(2))
print('\n')
print(s.abs())
print('\n')
print(s.clip(0, 2)) # 前两个数分别表示上下截断边界，如果超过边界就替换为该值
0 -1.0000
1 1.2345
2 100.0000
3 -50.0000
dtype: float64
0 -1.00
1 1.23
2 100.00
3 -50.00
dtype: float64
0 1.0000
1 1.2345
2 100.0000
3 50.0000
dtype: float64
0 0.0000
1 1.2345
2 2.0000
3 0.0000
dtype: float64
Question：cilp 超过边界的只能截断为边界值，如果要把超出边界的替换为自定义的值，应当如何做？
s.mask((s<0)|(s>2),-50)
0 -50.0000
1 1.2345
2 -50.0000
3 -50.0000
dtype: float64
排序函数
排序共有两种方式，其一为值排序，其二为索引排序，对应的函数是 sort_values 和 sort_index。
df_demo = df[['Grade', 'Name', 'Height','Weight']].set_index(['Grade','Name']) # 把年级和姓名两列作为索引
df_demo.head()
| Height | Weight | ||
|---|---|---|---|
| Grade | Name | ||
| Freshman | Gaopeng Yang | 158.9 | 46.0 |
| Changqiang You | 166.5 | 70.0 | |
| Senior | Mei Sun | 188.9 | 89.0 |
| Sophomore | Xiaojuan Sun | NaN | 41.0 |
| Gaojuan You | 174.0 | 74.0 |
对身高进行排序，默认参数 ascending=True 为升序：
df_demo.sort_values('Height').head()
| Height | Weight | ||
|---|---|---|---|
| Grade | Name | ||
| Junior | Xiaoli Chu | 145.4 | 34.0 |
| Senior | Gaomei Lv | 147.3 | 34.0 |
| Sophomore | Peng Han | 147.8 | 34.0 |
| Senior | Changli Lv | 148.7 | 41.0 |
| Sophomore | Changjuan You | 150.5 | 40.0 |
df_demo.sort_values('Height', ascending=False).head()
| Height | Weight | ||
|---|---|---|---|
| Grade | Name | ||
| Senior | Xiaoqiang Qin | 193.9 | 79.0 |
| Mei Sun | 188.9 | 89.0 | |
| Gaoli Zhao | 186.5 | 83.0 | |
| Freshman | Qiang Han | 185.3 | 87.0 |
| Senior | Qiang Zheng | 183.9 | 87.0 |
在排序中，经常遇到多列排序的问题，比如在体重相同的情况下，对身高进行排序，并且保持身高降序排列，体重升序排列：
df_demo.sort_values(['Weight','Height'],ascending=[True,False]).head()
| Height | Weight | ||
|---|---|---|---|
| Grade | Name | ||
| Sophomore | Peng Han | 147.8 | 34.0 |
| Senior | Gaomei Lv | 147.3 | 34.0 |
| Junior | Xiaoli Chu | 145.4 | 34.0 |
| Sophomore | Qiang Zhou | 150.5 | 36.0 |
| Freshman | Yanqiang Xu | 152.4 | 38.0 |
索引排序的用法和值排序完全一致，只不过元素的值在索引中，此时需要指定索引层的名字或者层号，用参数 level 表示。另外，需要注意的是字符串的排列顺序由字母顺序决定。
df_demo.sort_index(level=['Grade','Name'],ascending=[True,False]).head()
| Height | Weight | ||
|---|---|---|---|
| Grade | Name | ||
| Freshman | Yanquan Wang | 163.5 | 55.0 |
| Yanqiang Xu | 152.4 | 38.0 | |
| Yanqiang Feng | 162.3 | 51.0 | |
| Yanpeng Lv | NaN | 65.0 | |
| Yanli Zhang | 165.1 | 52.0 |
apply方法
apply 方法常用于 DataFrame 的行迭代或者列迭代，它的 axis 含义与统计聚合函数一致， apply 的参数往往是一个以序列为输入的函数。例如对于 .mean() ，使用 apply 可以如下地写出：
df_demo = df[['Height', 'Weight']]
def my_mean(x):
res = x.mean()
return res
df_demo.apply(my_mean)
Height 163.218033
Weight 55.015873
dtype: float64
同样的，可以利用 lambda 表达式使得书写简洁，这里的 x 就指代被调用的 df_demo 表中逐个输入的序列：
df_demo.apply(lambda x:x.mean())
Height 163.218033
Weight 55.015873
dtype: float64
若指定 axis=1 ，那么每次传入函数的就是行元素组成的 Series ，其结果与之前的逐行均值结果一致。
df_demo.apply(lambda x:x.mean(), axis=1).head()
0 102.45
1 118.25
2 138.95
3 41.00
4 124.00
dtype: float64
另一个例子：mad 函数返回的是一个序列中偏离该序列均值的绝对值大小的均值，例如序列1,3,7,10中，均值为5.25，每一个元素偏离的绝对值为4.25,2.25,1.75,4.75，这个偏离序列的均值为3.25。现在利用 apply 计算升高和体重的 mad 指标：
df_demo.apply(lambda x:(x-x.mean()).abs().mean())
Height 6.707229
Weight 10.391870
dtype: float64
这与使用内置的 mad 函数计算结果一致：
df_demo.mad()
Height 6.707229
Weight 10.391870
dtype: float64
窗口对象
pandas 中有3类窗口，分别是滑动窗口 rolling 、扩张窗口 expanding 以及指数加权窗口 ewm
滑窗对象
要使用滑窗函数，就必须先要对一个序列使用 .rolling 得到滑窗对象，其最重要的参数为窗口大小 window。
s = pd.Series([1,2,3,4,5])
roller = s.rolling(window = 3)
roller
Rolling [window=3,center=False,axis=0]
在得到了滑窗对象后，能够使用相应的聚合函数进行计算，需要注意的是窗口包含当前行所在的元素，例如在第四个位置进行均值运算时，应当计算(2+3+4)/3，而不是(1+2+3)/3：
roller.mean()
0 NaN
1 NaN
2 2.0
3 3.0
4 4.0
dtype: float64
roller.sum()
0 NaN
1 NaN
2 6.0
3 9.0
4 12.0
dtype: float64
对于滑动相关系数或滑动协方差的计算，可以如下写出：
s2 = pd.Series([1,2,6,16,30])
roller.cov(s2)
0 NaN
1 NaN
2 2.5
3 7.0
4 12.0
dtype: float64
roller.corr(s2)
0 NaN
1 NaN
2 0.944911
3 0.970725
4 0.995402
dtype: float64
此外，还支持使用 apply 传入自定义函数，其传入值是对应窗口的 Series ，例如上述的均值函数可以等效表示：
roller.apply(lambda x:x.mean())
0 NaN
1 NaN
2 2.0
3 3.0
4 4.0
dtype: float64
shift, diff, pct_change 是一组类滑窗函数，它们的公共参数为 periods=n ，默认为1，分别表示取向前第 n 个元素的值、与向前第 n 个元素做差（与 Numpy 中不同，后者表示 n 阶差分）、与向前第 n 个元素相比计算增长率。这里的 n 可以为负，表示反方向的类似操作。
s = pd.Series([1,3,6,10,15])
s.shift(2)
0 NaN
1 NaN
2 1.0
3 3.0
4 6.0
dtype: float64
s.diff(3)
0 NaN
1 NaN
2 NaN
3 9.0
4 12.0
dtype: float64
s.pct_change()
0 NaN
1 2.000000
2 1.000000
3 0.666667
4 0.500000
dtype: float64
s.shift(-1)
0 3.0
1 6.0
2 10.0
3 15.0
4 NaN
dtype: float64
s.diff(-2)
0 -5.0
1 -7.0
2 -9.0
3 NaN
4 NaN
dtype: float64
将其视作类滑窗函数的原因是，它们的功能可以用窗口大小为 n+1 的 rolling 方法等价代替：
s.rolling(3).apply(lambda x:list(x)[0]) # s.shift(2)
0 NaN
1 NaN
2 1.0
3 3.0
4 6.0
dtype: float64
s.rolling(4).apply(lambda x:list(x)[-1]-list(x)[0]) # s.diff(3)
0 NaN
1 NaN
2 NaN
3 9.0
4 12.0
dtype: float64
def my_pct(x):
L = list(x)
return L[-1]/L[0]-1
s.rolling(2).apply(my_pct) # s.pct_change()
0 NaN
1 2.000000
2 1.000000
3 0.666667
4 0.500000
dtype: float64
Question：rolling 对象的默认窗口方向都是向前的，某些情况下用户需要向后的窗口，例如对1,2,3设定向后窗口为2的 sum 操作，结果为3,5,NaN，此时应该如何实现向后的滑窗操作？（提示：使用 shift ）
s = pd.Series([1,2,3])
s+s.shift(-1)
0 3.0
1 5.0
2 NaN
dtype: float64
扩张窗口
扩张窗口又称累计窗口，可以理解为一个动态长度的窗口，其窗口的大小就是从序列开始处到具体操作的对应位置，其使用的聚合函数会作用于这些逐步扩张的窗口上。具体地说，设序列为a1, a2, a3, a4，则其每个位置对应的窗口即[a1]、[a1, a2]、[a1, a2, a3]、[a1, a2, a3, a4]。
s = pd.Series([1, 3, 6, 10])
s.expanding().mean()
0 1.000000
1 2.000000
2 3.333333
3 5.000000
dtype: float64
Question：cummax, cumsum, cumprod 函数是典型的类扩张窗口函数，请使用 expanding 对象依次实现它们。
s = pd.Series([1, 3, 6, 10])
s.expanding().max() # s.cummax()
0 1.0
1 3.0
2 6.0
3 10.0
dtype: float64
s.expanding().sum() # s.cumsum()
0 1.0
1 4.0
2 10.0
3 20.0
dtype: float64
s.expanding().apply(lambda x:x.prod()) # s.cumprod()
0 1.0
1 3.0
2 18.0
3 180.0
dtype: float64
练习
口袋妖怪数据集
现有一份口袋妖怪的数据集，下面进行一些背景说明：
-
# 代表全国图鉴编号，不同行存在相同数字则表示为该妖怪的不同状态
-
妖怪具有单属性和双属性两种，对于单属性的妖怪， Type 2 为缺失值
-
Total, HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 分别代表种族值、体力、物攻、防御、特攻、特防、速度，其中种族值为后6项之和
df = pd.read_csv('G:\代码\joyful-pandas-master\data\pokemon.csv')
df.head()
| # | Name | Type 1 | Type 2 | Total | HP | Attack | Defense | Sp. Atk | Sp. Def | Speed | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | Bulbasaur | Grass | Poison | 318 | 45 | 49 | 49 | 65 | 65 | 45 |
| 1 | 2 | Ivysaur | Grass | Poison | 405 | 60 | 62 | 63 | 80 | 80 | 60 |
| 2 | 3 | Venusaur | Grass | Poison | 525 | 80 | 82 | 83 | 100 | 100 | 80 |
| 3 | 3 | VenusaurMega Venusaur | Grass | Poison | 625 | 80 | 100 | 123 | 122 | 120 | 80 |
| 4 | 4 | Charmander | Fire | NaN | 309 | 39 | 52 | 43 | 60 | 50 | 65 |
-
对 HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 进行加总，验证是否为 Total 值
-
对于 # 重复的妖怪只保留第一条记录，解决以下问题：
a. 求第一属性的种类数量和前三多数量对应的种类
b. 求第一属性和第二属性的组合种类
c. 求尚未出现过的属性组合
-
按照下述要求，构造 Series ：
a. 取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid
b. 取出第一属性，分别用 replace 和 apply 替换所有字母为大写
c. 求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序
# 1. 对 HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 进行加总，验证是否为 Total 值
df[['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed']].sum(axis=1).head()-df['Total'].head()
0 0
1 0
2 0
3 0
4 0
dtype: int64
# 2. 对于 # 重复的妖怪只保留第一条记录
df_uni = df.drop_duplicates(['#'])
print(df['#'].count())
print(df_uni['#'].count())
800
721
# 2.a 求第一属性的种类数量和前三多数量对应的种类
print('第一属性的种类数量：')
print(df_uni['Type 1'].nunique())
print('前三多数量对应的种类：')
print(df_uni['Type 1'].value_counts()[0:3])
第一属性的种类数量：
18
前三多数量对应的种类：
Water 105
Normal 93
Grass 66
Name: Type 1, dtype: int64
# 2.b 求第一属性和第二属性的组合种类
print(df_uni[['Type 1', 'Type 2']].drop_duplicates(['Type 1', 'Type 2']).head())
print('\n')
print(df_uni[['Type 1', 'Type 2']].drop_duplicates(['Type 1', 'Type 2']).shape[0])
Type 1 Type 2
0 Grass Poison
4 Fire NaN
6 Fire Flying
9 Water NaN
13 Bug NaN
143
# 2.c 求尚未出现过的属性组合
L_full = [i+' '+j for i in df['Type 1'].unique() for j in (df['Type 1'].unique().tolist() + [''])] # 所有组合
L_part = [i+' '+j for i, j in zip(df['Type 1'], df['Type 2'].replace(np.nan, ''))] # 出现过的属性组合
res = set(L_full).difference(set(L_part))
len(res)
188
# 3.a 取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid
df['Attack'].mask(df['Attack']>120, 'high').mask(df['Attack']<50, 'low').mask((50<=df['Attack'])&(df['Attack']<=120), 'mid').head()
0 low
1 mid
2 mid
3 mid
4 mid
Name: Attack, dtype: object
# 3.b 取出第一属性，分别用 replace 和 apply 替换所有字母为大写
print(df['Type 1'].replace({i:str.upper(i) for i in df['Type 1'].unique()}).head()) # replace
# {i:str.upper(i) for i in df['Type 1'].unique()} 相当于用来替换的字典
print('\n')
print(df['Type 1'].apply(lambda x:str.upper(x)).head()) # apply
0 GRASS
1 GRASS
2 GRASS
3 GRASS
4 FIRE
Name: Type 1, dtype: object
0 GRASS
1 GRASS
2 GRASS
3 GRASS
4 FIRE
Name: Type 1, dtype: object
# 3.c 求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序
df['Deviation'] = df[['HP', 'Attack', 'Defense', 'Sp. Atk','Sp. Def', 'Speed']].apply(lambda x:np.max((x-x.median()).abs()), 1)
df.sort_values('Deviation', ascending=False).head()
| # | Name | Type 1 | Type 2 | Total | HP | Attack | Defense | Sp. Atk | Sp. Def | Speed | Deviation | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 230 | 213 | Shuckle | Bug | Rock | 505 | 20 | 10 | 230 | 10 | 230 | 5 | 215.0 |
| 121 | 113 | Chansey | Normal | NaN | 450 | 250 | 5 | 5 | 35 | 105 | 50 | 207.5 |
| 261 | 242 | Blissey | Normal | NaN | 540 | 255 | 10 | 10 | 75 | 135 | 55 | 190.0 |
| 333 | 306 | AggronMega Aggron | Steel | NaN | 630 | 70 | 140 | 230 | 60 | 80 | 50 | 155.0 |
| 224 | 208 | SteelixMega Steelix | Steel | Ground | 610 | 75 | 125 | 230 | 55 | 95 | 30 | 145.0 |
{i:str.upper(i) for i in df['Type 1'].unique()}
{'Grass': 'GRASS',
'Fire': 'FIRE',
'Water': 'WATER',
'Bug': 'BUG',
'Normal': 'NORMAL',
'Poison': 'POISON',
'Electric': 'ELECTRIC',
'Ground': 'GROUND',
'Fairy': 'FAIRY',
'Fighting': 'FIGHTING',
'Psychic': 'PSYCHIC',
'Rock': 'ROCK',
'Ghost': 'GHOST',
'Ice': 'ICE',
'Dragon': 'DRAGON',
'Dark': 'DARK',
'Steel': 'STEEL',
'Flying': 'FLYING'}
指数加权窗口
-
作为扩张窗口的 ewm 窗口
在扩张窗口中，用户可以使用各类函数进行历史的累计指标统计，但这些内置的统计函数往往把窗口中的所有元素赋予了同样的权重。事实上，可以给出不同的权重来赋给窗口中的元素，指数加权窗口就是这样一种特殊的扩张窗口。其中，最重要的参数是 alpha ，它决定了默认情况下的窗口权重为 w i = ( 1 − α ) i , i ∈ { 0 , 1 , . . . , t } w_i = (1-\alpha)^i,i \in \{0,1,...,t\} wi=(1−α)i,i∈{0,1,...,t}，其中 i = t i=t i=t 表示当前元素， i = 0 i=0 i=0 表示序列的第一个元素。
从权重公式可以看出，离开当前值越远则权重越小，若记原序列为 x ，更新后的当前元素为 yt ，此时通过加权公式归一化后可知：
y
t
=
∑
i
=
0
t
w
i
x
t
−
i
∑
i
=
0
t
w
i
y_t =\frac{\sum_{i=0}^{t} w_i x_{t-i}}{\sum_{i=0}^{t} w_i}
yt=∑i=0twi∑i=0twixt−i
=
x
t
+
(
1
−
α
)
x
t
−
1
+
(
1
−
α
)
2
x
t
−
2
+
.
.
.
+
(
1
−
α
)
t
x
0
1
+
(
1
−
α
)
+
(
1
−
α
)
2
+
.
.
.
+
(
1
−
α
)
t
−
1
=\frac{x_t + (1 - \alpha)x_{t-1} + (1 - \alpha)^2 x_{t-2} + ... + (1 - \alpha)^{t} x_{0}}{1 + (1 - \alpha) + (1 - \alpha)^2 + ... + (1 - \alpha)^{t-1}}
=1+(1−α)+(1−α)2+...+(1−α)t−1xt+(1−α)xt−1+(1−α)2xt−2+...+(1−α)tx0
对于 Series 而言，可以用 ewm 对象如下计算指数平滑后的序列：
np.random.seed(0)
s = pd.Series(np.random.randint(-1,2,30).cumsum())
s.head()
0 -1
1 -1
2 -2
3 -2
4 -2
dtype: int32
s.ewm(alpha=0.2).mean().head()
0 -1.000000
1 -1.000000
2 -1.409836
3 -1.609756
4 -1.725845
dtype: float64
请用 expanding 窗口实现:
# 方法一
alpha = 0.2
s1 = pd.Series([(1-alpha)**i for i in range(29,-1,-1)])
s2 = s1*s.sort_index(ascending=False)
res = s2.expanding().sum()/s1.expanding().sum()
res.head()
0 -1.000000
1 -1.000000
2 -1.409836
3 -1.609756
4 -1.725845
dtype: float64
# 方法二
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()
0 -1.000000
1 -1.000000
2 -1.409836
3 -1.609756
4 -1.725845
dtype: float64
- 作为滑动窗口的 ewm 窗口
从第1问中可以看到， ewm 作为一种扩张窗口的特例，只能从序列的第一个元素开始加权。现在希望给定一个限制窗口 n ，只对包含自身最近的 n 个窗口进行滑动加权平滑。请根据滑窗函数，给出新的 w i w_i wi 与 y t y_t yt 的更新公式，并通过 rolling 窗口实现这一功能。
新的权重为 w i = ( 1 − α ) i , i ∈ { 0 , 1 , . . . , n − 1 } ， y t w_i = (1 - \alpha)^i, i\in \{0,1,...,n-1\} ，y_t wi=(1−α)i,i∈{0,1,...,n−1}，yt 更新如下：
y
t
=
∑
i
=
0
n
−
1
w
i
x
t
−
i
∑
i
=
0
n
−
1
w
i
y_t =\frac{\sum_{i=0}^{n-1} w_i x_{t-i}}{\sum_{i=0}^{n-1} w_i}
yt=∑i=0n−1wi∑i=0n−1wixt−i
=
x
t
+
(
1
−
α
)
x
t
−
1
+
(
1
−
α
)
2
x
t
−
2
+
.
.
.
+
(
1
−
α
)
n
−
1
x
t
−
(
n
−
1
)
1
+
(
1
−
α
)
+
(
1
−
α
)
2
+
.
.
.
+
(
1
−
α
)
n
−
1
=\frac{x_t + (1 - \alpha)x_{t-1} + (1 - \alpha)^2 x_{t-2} + ... + (1 - \alpha)^{n-1} x_{t-(n-1)}}{1 + (1 - \alpha) + (1 - \alpha)^2 + ... + (1 - \alpha)^{n-1}}
=1+(1−α)+(1−α)2+...+(1−α)n−1xt+(1−α)xt−1+(1−α)2xt−2+...+(1−α)n−1xt−(n−1)
s.rolling(window=4).apply(ewm_func).head()
0 NaN
1 NaN
2 NaN
3 -1.609756
4 -1.826558
dtype: float64