第二章 pandas 基础
文件读取与写入
文件读取
主要介绍scv、excel、txt文件的读取方式
import numpy as np
import pandas as pd
# conda update pandas更新pandas包到最新版本
# 查看pandas版本
pd.__version__
'1.1.5'
df_csv = pd.read_csv('my_csv.csv')
df_txt = pd.read_table('my_table.txt')
df_excel = pd.read_excel('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】 表示读取的数据行数
# 【header=None】 表示第一行不作为列名
pd.read_table('my_table.txt',header=None)
0 | 1 | 2 | 3 | |
---|---|---|---|---|
0 | col1 | col2 | col3 | col4 |
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 |
# 【index_col】表示把某一列或几列作为索引
pd.read_csv('my_csv.csv',index_col=['col1','col2'])
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 |
# 【usecols】 表示读取列的集合,默认读取所有的列
pd.read_csv('my_csv.csv',usecols=['col1','col2'])
col1 | col2 | |
---|---|---|
0 | 2 | a |
1 | 3 | b |
2 | 6 | c |
3 | 5 | d |
# 【parse_dates】 表示需要转化为时间的列
pd.read_csv('my_csv.csv',parse_dates=['col5'])
col1 | col2 | col3 | col4 | col5 | |
---|---|---|---|---|---|
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 |
# 【nrows】 表示读取的数据行数
pd.read_csv('my_csv.csv',nrows=3)
# 等价于.head(3)
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 |
txt文件自定义分隔符号
pd.read_table('my_table_special_sep.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正则参数,使用的是正则表达式,需要对|进行转义变成 \|。【正则表达式第八章】
# sep定义分割符号为||||,同时制定引擎为python
pd.read_table('my_table_special_sep.txt',sep='\|\|\|\|',engine='python')
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('my_csv_saved.csv', index=False)
pandas中没有定义to_table函数,但是to_csv可以保存为txt文件,并且允许自定义分隔符,常用制表符\t分割
df_txt.to_csv('my_txt_saved.txt', sep='\t', index=False)
如果想要把表格快速转换为 markdown 和 latex 语言,可以使用 to_markdown 和 to_latex 函数,此处需要安装 tabulate 包。
# conda install tabulate 安装 tabulate 包
print(df_csv.to_markdown())
| | 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 |
print(df_csv.to_latex())
\begin{tabular}{lrlrll}
\toprule
{} & col1 & col2 & col3 & col4 & col5 \\
\midrule
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 \\
\bottomrule
\end{tabular}
基本数据结构
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
object 代表了一种混合数据类型(整数、字符串、字典等)
属性可通过.方式获取
s.values
s.index
s.dtype
s.name
【s.shape】获取序列的长度
【index_item】取出单个索引对应的值
# 【index_item】取出单个索引对应的值
s['third']
{'dic1': 5}
DataFrame
DataFrame 在 Series 的基础上增加了列索引
3*3二维矩阵框
data = [[1, 'a', 1.2], [2, 'b', 2.2], [3, 'c', 3.2]]
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 |
# 取series
df['col_0']
row_0 1
row_1 2
row_2 3
Name: col_0, dtype: int64
# 取DataFrame
df[['col_0', 'col_1']]
col_0 | col_1 | |
---|---|---|
row_0 | 1 | a |
row_1 | 2 | b |
row_2 | 3 | c |
# 取相应的属性
df.values
df.index
df.columns
df.dtypes
df.shape
(3, 3)
常用基本函数
df = pd.read_csv('learn_pandas.csv')
df.columns
# 学校、年级、姓名、性别、身高、体重、是否为转系生、体测场次、测试时间、1000 米成 绩
Index(['School', 'Grade', 'Name', 'Gender', 'Height', 'Weight', 'Transfer',
'Test_Number', 'Test_Date', 'Time_Record'],
dtype='object')
# 本章只需使用其中的前七列
df = df[df.columns[:7]]
df[:3]
School | Grade | Name | Gender | Height | Weight | Transfer | |
---|---|---|---|---|---|---|---|
0 | Shanghai Jiao Tong University | Freshman | Gaopeng Yang | Female | 158.9 | 46.0 | N |
1 | Peking University | Freshman | Changqiang You | Male | 166.5 | 70.0 | N |
2 | Shanghai Jiao Tong University | Senior | Mei Sun | Male | 188.9 | 89.0 | N |
汇总函数
head, tail 函数分别表示返回表或者序列的前 n 行和后 n 行,其中 n 默认为 5
df.head(2)
School | Grade | Name | Gender | Height | Weight | Transfer | |
---|---|---|---|---|---|---|---|
0 | Shanghai Jiao Tong University | Freshman | Gaopeng Yang | Female | 158.9 | 46.0 | N |
1 | Peking University | Freshman | Changqiang You | Male | 166.5 | 70.0 | N |
# tail返回表或者序列的后 n 行
df.tail(3)
School | Grade | Name | Gender | Height | Weight | Transfer | |
---|---|---|---|---|---|---|---|
197 | Shanghai Jiao Tong University | Senior | Chengqiang Chu | Female | 153.9 | 45.0 | N |
198 | Shanghai Jiao Tong University | Senior | Chengmei Shen | Male | 175.3 | 71.0 | N |
199 | Tsinghua University | Sophomore | Chunpeng Lv | Male | 155.7 | 51.0 | N |
info, describe 分别返回表的信息概况和表中数值列对应的主要统计量
# 【.info()】information
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 7 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
dtypes: float64(2), object(5)
memory usage: 11.1+ KB
df.describe()
Height | Weight | |
---|---|---|
count | 183.000000 | 189.000000 |
mean | 163.218033 | 55.015873 |
std | 8.608879 | 12.824294 |
min | 145.400000 | 34.000000 |
25% | 157.150000 | 46.000000 |
50% | 161.900000 | 51.000000 |
75% | 167.500000 | 65.000000 |
max | 193.900000 | 89.000000 |
info, describe 只能实现较少信息的展示
如果想要对一份数据集进行全面且有效的观察,特别是在列较多的情况下,推荐使用 pandas-profiling 包
特征统计函数
在 Series 和 DataFrame 上定义了许多统计函数,最常见的是
sum
mean
median
var
std
max
min 【.quantile(0.75)】0.75分位数
【.count()】非缺失值个数
【.idxmax()】最大值对应的索引
【.idxmin()】最小值对应的索引上面这些所有的函数,由于操作后返回的是标量,所以又称为聚合函数
它们有一个公共参数 axis ,默认为 0 代表逐列聚合,如果设置为 1 则表示逐行聚合
df_demo = df[['Height', 'Weight']]
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 】唯一值个数
可以分别得到序列唯一值组成的列表和唯一值的个数
df['School'].unique()
array(['Shanghai Jiao Tong University', 'Peking University',
'Fudan University', 'Tsinghua University'], dtype=object)
df['School'].nunique()
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
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()
# 保留只出现过一次的姓名和性别组合,keep=False剔除姓名和性别重复的组合
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()
# 在 Series 上也可以使用
0 Shanghai Jiao Tong University
1 Peking University
3 Fudan University
5 Tsinghua University
Name: School, dtype: object
【duplicated】返回了是否为唯一值的布尔列表
keep 参数一致,重复元素为 True ,否则为 False 。
【drop_duplicates】 = 【duplicated】为 True 的对应行剔除。
df_demo.duplicated(['Gender', 'Transfer']).head()
0 False
1 False
2 True
3 True
4 True
dtype: bool
df['School'].duplicated().head()
# 在 Series 上也可以使用
0 False
1 False
2 True
3 False
4 True
Name: School, dtype: bool
替换函数
替换操作针对某一个列进行,因此以 Series 举例
三类替换函数:映射替换、逻辑替换、数值替换
映射替换:【replace】【str.replace】【cat.codes】
【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’】用前面一个最近的未被替换的值进行替换
【method = ‘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='ffill')
0 a
1 a
2 b
3 b
4 b
5 b
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
【str.replace】对于 string 类型的正则替换(第八章)
逻辑替换:【where】【mask】
【where】在传入条件为 False 的对应行进行替换
【mask】在传入条件为 True 的对应行进行替换
不指定替换值时,替换为缺失值。
s = pd.Series([-1, 1.2345, 100, -50])
s.where(s<0)
0 -1.0
1 NaN
2 NaN
3 -50.0
dtype: float64
s.where(s<0, 100)
0 -1.0
1 100.0
2 100.0
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)
0 -50.0000
1 1.2345
2 100.0000
3 -50.0000
dtype: float64
数值替换:【round】【abs】【clip】
【round】取整
【abs】取绝对值
【clip】截断
s = pd.Series([-1, 1.2345, 100, -50])
s.round(2)
# 保留2位小数
0 -1.00
1 1.23
2 100.00
3 -50.00
dtype: float64
s.clip(0, 2)
# 0,2两个数分别表示上下截断边界,超出边界的数赋值为边界值
0 0.0000
1 1.2345
2 2.0000
3 0.0000
dtype: float64
# 【clip】中,超过边界的只能截断为边界值
# 如果要把超出边界的替换为自定义的值,用替换函数进行替换
s.clip(1, 2).replace([1, 2], [0, 100])
0 0.0000
1 1.2345
2 100.0000
3 0.0000
dtype: float64
排序函数
【sort_values】值排序
【sort_index】索引排序
1、【sort_values】值排序
# 利用 set_index 把年级和姓名两列作为索引
df_demo = df[['Grade', 'Name', 'Height','Weight']].set_index(['Grade','Name'])
df_demo
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 | |
... | ... | ... | ... |
Junior | Xiaojuan Sun | 153.9 | 46.0 |
Senior | Li Zhao | 160.9 | 50.0 |
Chengqiang Chu | 153.9 | 45.0 | |
Chengmei Shen | 175.3 | 71.0 | |
Sophomore | Chunpeng Lv | 155.7 | 51.0 |
200 rows × 2 columns
# 对身高进行排序,默认参数 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 |
# ascending=False 为降序
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 |
2、【sort_index】索引排序
排序元素在索引中,需要指定索引层的名字或者层号,用参数 level 表示。
字符串的排列顺序由字母顺序决定。
df_demo.sort_index(level=['Grade','Name'],ascending=[True,False])
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 | |
... | ... | ... | ... |
Sophomore | Chengqiang Lv | 166.8 | 53.0 |
Chengli You | 164.1 | 57.0 | |
Changqiang Qian | 167.6 | 64.0 | |
Changmei Xu | 151.6 | 43.0 | |
Changjuan You | 150.5 | 40.0 |
200 rows × 2 columns
apply 方法
【apply】传入自定义函数
用于 DataFrame 的行迭代或者列迭代
其参数往往是一个以序列为输入的函数
只有在确实存在自定义需求的情境下才考虑使用 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
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
窗口对象
【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
【shift】表示取向前第 n 个元素的值
【diff】向前第 n 个元素做差(与 Numpy 中不同,后者表示 n 阶差分)
【pct_change】向前第 n 个元素相比计算增长率
这里的 n 可以为负,表示反方向的类似操作
s = pd.Series([1,3,6,10,15])
s.shift(2)
# .shift(2)取向前第 2 个元素的值
0 NaN
1 NaN
2 1.0
3 3.0
4 6.0
dtype: float64
s = pd.Series([1,3,6,10,15])
s.diff(3)
# .diff(3)向前第 3 个元素做差
0 NaN
1 NaN
2 NaN
3 9.0
4 12.0
dtype: float64
s = pd.Series([1,3,6,10,15])
s.pct_change()
# 与前第 1 个元素相比计算增长率
# 相比于之前一个数,增长了百分之几
0 NaN
1 2.000000
2 1.000000
3 0.666667
4 0.500000
dtype: float64
s = pd.Series([1,3,6,10,15])
s.shift(-1)
# n 可以为负,表示反方向的类似操作
# .shift(-1)取后第 1 个元素的值
0 3.0
1 6.0
2 10.0
3 15.0
4 NaN
dtype: float64
将其视作类滑窗函数的原因:
它们的功能可以用窗口大小为 n+1 的 rolling 方法等价代替
# s.shift(2)的rolling等价替代
s.rolling(3).apply(lambda x:list(x)[0])
0 NaN
1 NaN
2 1.0
3 3.0
4 6.0
dtype: float64
# s.diff(3)的rolling等价替代
s.rolling(4).apply(lambda x:list(x)[-1]-list(x)[0])
# list(x)[-1]最后一项
# list(x)[0]第一项
0 NaN
1 NaN
2 NaN
3 9.0
4 12.0
dtype: float64
# s.pct_change()
def my_pct(x):
L = list(x)
return L[-1]/L[0]-1
s.rolling(2).apply(my_pct)
# L[-1]/L[0]-1==(L[-1]-L[0])/L[0]
0 NaN
1 2.000000
2 1.000000
3 0.666667
4 0.500000
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