1 文件的创建
2 文件读取
- 2.1 文件读取
- 2.2 文件转换
3 基本数据结构
- 3.1 Series
- 3.2 DataFrame
3 常用基本函数
- 3.1 汇总函数
- 3.2 特征统计函数
- 3.3 唯一值函数
- 3.4 替换函数
- 3.5 排序函数
- 3.6 apply方法
4 窗口对象
- 4.1 滑窗对象
- 4.2 扩张窗口
5 练习

1 文件的创建

可创建的文件类型

数据类型	说明	新建方法
csv、tsv、txt	用逗号、tab分割的纯文本文件	pd.to_csv(路径)
excel	xls或xlsx	pd.to_excel(路径)
sql	关系数据库表	pd.to_sql(路径)

【例子1】新建文件并导入数据

import pandas as pd
path = 'd:/新建文件.xlsx' # 文件创建的路径
# 文件中要输入的数据，excel表格用字典，以键值对的形式
value = {'序号':[1,2,3],'姓名':['张三','李四','王五']}
# DATaFrame指二维数据表，可能用的series指一维数据（可行可列），不是一维数组
data=pd.DataFrame(value) # DataFrame()中也可没数据，那就是创建一个空的
data.to_excel(path) # 将数据写入创建的文件中

注意：第一列的序号是索引，它不索引列名

【例子2】将序号设为索引

import pandas as pd
path = 'd:/新建文件.xlsx'
value = {'序号':[1,2,3],'姓名':['张三','李四','王五']}
data=pd.DataFrame(value)
data=data.set_index('序号') # 将序号设置为索引
data.to_excel(path)

2 文件读取

2.1 文件读取

文件的读取：

数据类型	说明	读取方法
csv、tsv、txt	默认用逗号分隔	pd.read_csv(路径)
csv、tsv、txt	默认用\t分隔	pd.read_table(路径)
excel	xls或xlsx	pd.read_excel(路径)
sql	关系数据库表	pd.read_sql(路径)

文件的查看：
- 查看数据的形状，返回（行数，列数）：print(读取数据.shape)
- 查看数据内容：print(读取数据.values)
- 查看列名列表：print(读取数据.columns)
- 查看索引列：print(读取数据.index)
- 查看每一列数据类型：print(读取数据.dtypes)

读取csv/tsv/txt/excel文件的公共参数：

参数	描述
header	列名的行号，默认0（第一行），没有列名为`header=None`
names	自定义的表头，与`header=None`一起使用
index_col	把哪几列作为索引，可以是列名或列号
usecols	读取列的集合，默认读取所有列
skipcrows	从文件开始处，需要跳过的行数或行号列表
encoding	文本编码，常用utf-8
nrows	从文件开头读入的行数
parse_dates	需要转化为时间的列

【例子1】自定义表头，并读取前两列、前三行的数据

a=pd.read_table('data/my_table.txt', header=None,names=['a','b','c','d'],usecols=['a','b'],nrows=3)
print(a)
/*a     b
0  col1  col2
1     2     a
2     3     b
*/

【例子2】将col1和col3作为索引

b=pd.read_table('data/my_table.txt',index_col=['col1','col3'])
print(b)
/*col2             col4
col1 col3
2    1.4     a   apple 2020/1/1
3    3.4     b  banana 2020/1/2
6    2.5     c  orange 2020/1/5
5    3.2     d   lemon 2020/1/7
*/```

读取txt/csv/tsv文件：
当遇到分隔符不是逗号和\t时，可以使用sep参数，来自定义分隔符。
【例子】

import pandas as pd
a=pd.read_table('data/my_table_special_sep.txt',sep='\|\|\|\|',engine='python',index=Flase)
print(a)
/*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 。

2.2 文件转换

txt文件转csv文件
特别当索引没有特殊意义的时候，在保存的时候把 index设置为 False。
转换方法：
```
数据=pd.read_csv('文件路径.txt')
数据.to_csv('文件路径.csv',index=False)
```
表格转markdown和latex：以使用to_markdown和to_latex 函数，此处需要安装tabulate包。
【例子】rint(df_csv.to_markdown())

3 基本数据结构

pandas 中具有两种基本的数据存储结构，存储一维 values 的Series 和存储二维values 的 DataFrame。

3.1 Series

含义：一维数据，一行或一列数据
常用参数：序列的值：data，索引：index ，存储类型：dtype，序列的名字： name。
【例子】
```
a=pd.Series(data=[1,'b',{'c':2}],index=[0,1,2],dtype='object',name='my_name')
print(a)
/*
0           1
1           b
2    {'c': 2}
Name: my_name, dtype: object
*/
```
注意：object 代表了一种混合类型，目前 pandas 把纯字符串序列也默认认为是一种 object 类型的序列，但它也可以用 string 类型存储。
常用查询方法：
- 数据.index：查看索引 # Index(['id1', 20, 'third'], dtype='object', name='my_idx')
- 数据.values：查看索引 # array([100, 'a', {'dic1': 5}], dtype=object)
- 数据.isnull()：查看索引
- 数据.notnull()：查看索引
- 数据.sort_index()：按索引排序
- 数据.sort_values()：按数值排序

3.2 DataFrame

含义：两维数据，多行多列，由多个series构成，在 Series 的基础上增加了列索引。
特点：既有行索引index，也有列索引columns。

使用方法：

1 二维数据与行列索引：

data = [[0, 'a', 1.0], [1, 'b', 2.1], [2, 'c', 3.2]]
df=pd.DataFrame(data=data,index=['row_%d'%i for i in range(3)],columns=['col_0','col_1','col_2'])
print(df)
/*col_0 col_1  col_2
row_0      0     a    1.0
row_1      1     b    2.1
row_2      2     c    3.
*/

2 从列索引名到数据的映射来构造数据框，同时再加上行索引：

dir={'姓名':['张三','李四','王五'],'年龄':[1,2,3],'性别':['男','女','女']}
df=pd.DataFrame(data=dir,index=['row_%d'%i for i in range(3)])
print(df)
print(df['姓名']) # 取出相应列，Series
print(df[['姓名','年龄']]) # 取出多个列构成的表，DataFrame
/*姓名  年龄 性别
row_0  张三   1  男
row_1  李四   2  女
row_2  王五   3  女row_0    张三
row_1    李四
row_2    王五
Name: 姓名, dtype: objec姓名  年龄
row_0  张三   1
row_1  李四   2
row_2  王五   3
*/

注意：在DataFrame中可以用[col_name]与[col_list] 来取出相应的列与由多个列组成的表，结果分别为Series和DataFrame.

3 常用基本函数

3.1 汇总函数

head(),tail()：表示返回表或者序列的前 n 行和后 n 行，其中 n 默认为5。
info(),describe()：返回表的信息概况和表中数值列对应的主要统计量

注意：info, describe 只能实现较少信息的展示

3.2 特征统计函数

常见的函数()：sum,mean（平均值）,median(中值),var(方差),std(均方差),max,min
quantile(),count(),idxmax()：分别返回分位数、非缺失值个数、最大值对应索引。(分位数指将一个随机变量的概率分布范围分为几个等份的数值点)
【例子】
```
path='data/learn_pandas.csv'
df=pd.read_csv(path)
df_demo = df[['Height', 'Weight']]
a=df_demo.quantile(0.75)
print(a)
/*
Height    167.5
Weight     65.0
Name: 0.75, dtype: float64
*/
```

注意：以上返回的都是标量，因此以上函数也被称为聚合函数。有一个公共参数 axis ，默认为0代表逐列聚合，如果设置为1则表示逐行聚合。df_demo.mean(axis=1)

3.3 唯一值函数

unique(),nuique()：对序列使用，可分别得到其唯一值组成的列表和唯一值的个数

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’ 表示每个组合保留第一次出现的所在行， 'last '表示保留最后一次出现的所在行， ‘False’ 表示把所有重复组合所在的行剔除。

df_demo = df[['Gender','Transfer','Name']]
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
*/

duplicated：返回了是否为唯一值的布尔列表，keep的用法和上面的一样。duplicated返回的序列，把重复元素设为 True ，否则为 False 。 drop_duplicates等价于把 duplicated为 True 的对应行剔除。
```
df_demo.duplicated(['Gender', 'Transfer']).head() # 默认时前5行
/*
0    False
1    False
2     True
3     True
4     True
dtype: bool
*/
```

3.4 替换函数

替换：替换操作是针对某一个列进行的， pandas中的替换函数可以归纳为三类：映射替换、逻辑替换、数值替换。

映射替换：包含replace、str.replace、cat.codes。在replace中，可以通过字典构造，或者传入两个列表来进行替换：

df['Gender'].replace({'Female':0, 'Male':1}).head()
# 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.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
*/

逻辑替换：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.mask(s<0, -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])
s.round(2)
/*
0     -1.00
1      1.23
2    100.00
3    -50.00
dtype: float64
*/
s.clip(0, 2) # 前两个数分别表示上下截断边界
/*
0    0.0000
1    1.2345
2    2.0000
3    0.0000
dtype: float64
*/

3.5 排序函数

排序方式：值排序和索引排序，分别为sort-values和sort_index，默认参数ascending=True为升序
【例子1】单列排序

df_demo = df[['Grade', 'Name', 'Height','Weight']].set_index(['Grade','Name'])
# 按身高降序排序
df_demo.sort_values('Height', ascending=False).head()
/*Height  Weight
Grade    Name
Senior   Xiaoqiang Qin   193.9    79.0Mei Sun         188.9    89.0Gaoli Zhao      186.5    83.0
Freshman Qiang Han       185.3    87.0
Senior   Qiang Zheng     183.9    87.0
*/

【例子2】多列排序

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.0Yanqiang Xu     152.4    38.0Yanqiang Feng   162.3    51.0Yanpeng Lv        NaN    65.0Yanli Zhang     165.1    52.0
*/

注意：字符串的排列顺序由字母顺序决定。

3.6 apply方法

函数：函数作为一个对象，能作为参数传递给其他参数，并能作为函数的返回值。

apply函数：pandas的apply()函数可以作用于Series或者整个DataFrame，功能也是自动遍历整个Series或DataFrame，对每个元素运行指定的函数。
【例子1】

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
*/

【例子2】使用lambda表达式

df_demo = df[['Height', 'Weight']]
df_demo.apply(lambda x:x.mean())
/*
Height    163.218033
Weight     55.015873
dtype: float64
*/

axis参数：若指定axis=1，则每次传入函数的就是行元素组成的Series，默认axis=0按列传入。

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
*/

注意：使用 pandas 的内置函数处理和 apply 来处理同一个任务，其速度会相差较多，因此只有在确实存在自定义需求的情境下才考虑使用 apply 。

4 窗口对象

Pandas 窗口函数：为了处理数字数据，pandas中有3类窗口函数，分别是滑动窗口 rolling()、扩张窗口 expanding()以及指数加权窗口ewm()。
窗口：为了提升数据的准确性，将某个点的取值扩大到包含这个点的一段区间，用区间来进行判断，这个区间就是窗口。

4.1 滑窗对象

.rolling()：移动窗口函数，移动窗口就是窗口向一端滑行，默认是从右往左，每次滑行并不是区间整块的滑行，而是一个单位一个单位的滑行。最重要的参数为窗口大小 window。
```
s = pd.Series([1,2,3,4,5])
roller = s.rolling(window = 3)
print(s)
print(roller.mean())
/*
0    1
1    2
2    3
3    4
4    5
dtype: int64
*/
/*
0    NaN
1    NaN
2    2.0
3    3.0
4    4.0
dtype: float64
*/
```
分析：设置的窗口大小window=3，即每有3个数就取平均值。index0和index1为NaN，是因为它们前面不够三个数，当到了index2的时候，它的值的计算方式为(index0+index1+index2)/3，同理，index3=(index1+index2+index3)/3，第n个元素的值是n，n-1，n-2元素的平均值。
.rolling()函数的衍生用法：

函数	说明
rolling_count()	计算各个窗口中非NA观测值的数量
rolling_sum()	计算各个移动窗口中的元素之和
rolling_mean()	计算各个移动窗口中元素的均值
rolling_median()	计算各个移动窗口中元素的中位数
rolling_var()	计算各个移动窗口中元素的方差
rolling_std()	计算各个移动窗口中元素的标准差
rolling_min()	计算各个移动窗口中元素的最小值
rolling_max()	计算各个移动窗口中元素的最大值
rolling_corr()	计算各个移动窗口中元素的相关系数
rolling_corr_pairwise()	计算各个移动窗口中配对数据的相关系数
rolling_cov()	计算各个移动窗口中元素的的协方差
rolling_quantile()	计算各个移动窗口中元素的分位数

配合apply函数：支持使用 apply 传入自定义函数，其传入值是对应窗口的 Series。
```
roller.apply(lambda x:x.mean())
/*
0    NaN
1    NaN
2    2.0
3    3.0
4    4.0
dtype: float64
*/
```

类滑窗函数：公共参数为 periods=n ，默认为1。这里的 n 可以为负，表示反方向的类似操作。

shift()：表示取向前第 n 个元素的值
diff()：表示与向前第 n 个元素做差
pct_change()：表示与向前第 n 个元素相比计算增长率

s = pd.Series([1,3,6,10,15])
# shift()函数
s.shift(-2)
/*
0    6.0
1    10.0
2    15.0
3    NaN
4    NaN
dtype: float64
*/
# diff()函数
s.diff(3)
/*
0     NaN
1     NaN
2     NaN
3     9.0
4    12.0
dtype: float64
*/
# pct_change()
s.pct_change()
/*
0         NaN
1    2.000000
2    1.000000
3    0.666667
4    0.500000
dtype: float64
*/

将其视作类滑窗函数的原因是，它们的功能可以用窗口大小为 n+1 的 rolling 方法等价代替

s.rolling(3).apply(lambda x:list(x)[0]) # s.shift(2)
s.rolling(4).apply(lambda x:list(x)[-1]-list(x)[0]) # s.diff(3)
s.rolling(2).apply(my_pct) # s.pct_change()

4.2 扩张窗口

.expanding()：扩张函数，和.rolling()函数参数用法相同，不同的是，其不是固定窗口长度，其长度是不断的扩大的。类似cumsum()函数的累计求和，其优势在于还可以进行更多的聚类计算。重要参数min_periods = n，指定开始的窗口大小。
```
s = pd.Series([1,2,3,4,5])
expand = s.expanding(min_periods=3)
print(expand.mean())
/*
0    NaN
1    NaN
2    2.0
3    2.5
4    3.0
dtype: float64
*/
```
分析：设置的min_periods=3，即至少3个数取一个平均数。前两个是NaN是因为前面两个不够3个数，等到index2时，计算方式为(index0+index1+index2)/3，在index3时，index3=(index0+index1+index2+index3)/4，依次类推。

5 练习

1.现有一份口袋妖怪的数据集，下面进行一些背景说明：

#代表全国图鉴编号，不同行存在相同数字则表示为该妖怪的不同状态。
妖怪具有单属性和双属性两种，对于单属性的妖怪， Type 2 为缺失值
Total, HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 分别代表种族值、体力、物攻、防御、特攻、特防、速度，其中种族值为后6项之和

In [116]: df = pd.read_csv('data/pokemon.csv')In [117]: df.head(3)
Out[117]: #       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

要求：
1.对 HP, Attack, Defense, Sp. Atk, Sp. Def, Speed 进行加总，验证是否为 Total 值。

df = pd.read_csv('data/pokemon.csv')
df=pd.read_csv('data/pokemon.csv')
print(all(df[['HP','Attack','Defense','Sp. Atk','Sp. Def','Speed']].sum(axis=1)==df['Total']))
# Ture

参考答案：
df = pd.read_csv('data/pokemon.csv')
(df[['HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed' ]].sum(1)!=df['Total']).mean()
# 0.0

2.对于 # 重复的妖怪只保留第一条记录，解决以下问题：
a.求第一属性的种类数量和前三多数量对应的种类
b.求第一属性和第二属性的组合种类
c.求尚未出现过的属性组合

df=pd.read_csv('data/pokemon.csv')
df_record=df.drop_duplicates('#',keep='first') # 保留第一次出现的所在行
print(df_record['Type 1'].nunique()) # 唯一值的个数
print(df_record['Type 1'].value_counts().index[:3]) #得到唯一值和其对应出现的频数，再取前三
#18
#Index(['Water', 'Normal', 'Grass'], dtype='object')

df_comb=df_record.drop_duplicates(['Type 1','Type 2']) 两列组合同时
print(df_comb.shape[0]) # 只返回行数
# 143

第三题参照参考答案

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))
print(len(res))

3.按照下述要求，构造 Series ：
a.取出物攻，超过120的替换为 high ，不足50的替换为 low ，否则设为 mid
b.取出第一属性，分别用 replace 和 apply 替换所有字母为大写
c.求每个妖怪六项能力的离差，即所有能力中偏离中位数最大的值，添加到 df 并从大到小排序

df_attack=df['Attack'].mask(df['Attack']>120,'high')\.mask(df['Attack']<50,'low')\.mask((df['Attack']<120)&(df['Attack']>50),'mid')
print(df_attack.head(4))
/*
0    low
1    mid
2    mid
3    mid
Name: Attack, dtype: object
*/

# replace
df_replace=df['Type 1'].replace({i:str.upper(i) for i in df['Type 1'].unique()}).head(4)
print(df_replace)
/*
0    GRASS
1    GRASS
2    GRASS
3    GRASS
Name: Type 1, dtype: object
*/
# apply
df_apply=df['Type 1'].apply(lambda x:str.upper(x)).head(4)
print(df_apply)

3参考答案：

import numpy as np
df['Deviation'] = df[['HP', 'Attack', 'Defense', 'Sp. Atk','Sp. Def', 'Speed']]\.apply(lambda x:np.max( (x-x.median()).abs()), 1)
print(df.sort_values('Deviation', ascending=False).head())
/*#               Name  Type 1 Type 2  ...  Sp. Atk  Sp. Def  Speed  Deviation
230  213            Shuckle     Bug   Rock  ...       10      230      5      215.0
121  113            Chansey  Normal    NaN  ...       35      105     50      207.5
261  242            Blissey  Normal    NaN  ...       75      135     55      190.0
333  306  AggronMega Aggron   Steel    NaN  ...       60       80     50      155.0
*/

2.指数加权窗口
2.1 作为扩张窗口的 ewm 窗口
在扩张窗口中，用户可以使用各类函数进行历史的累计指标统计，但这些内置的统计函数往往把窗口中的所有元素赋予了同样的权重。事实上，可以给出不同的权重来赋给窗口中的元素，指数加权窗口就是这样一种特殊的扩张窗口。
其中，最重要的参数是 alpha ，它决定了默认情况下的窗口权重为 w i = ( 1 − α ) i , i ∈ { 0 , 1 , … , t } w_{i}=(1-\alpha)^{i}, i \in\{0,1, \ldots, t\} wi=(1−α)i,i∈{0,1,…,t},其中 i=t 表示当前元素， i=0 表示序列的第一个元素。
从权重公式可以看出，离开当前值越远则权重越小，若记原序列为 x ，更新后的当前元素为 y t y_{t} yt ，此时通过加权公式归一化后可知： y t = ∑ i = 0 t w i x t − i ∑ i = 0 t w i = x t + ( 1 − α ) x t − 1 + ( 1 − α ) 2 x t − 2 + … + ( 1 − α ) t x 0 1 + ( 1 − α ) + ( 1 − α ) 2 + … + ( 1 − α ) t \begin{aligned} y_{t} &=\frac{\sum_{i=0}^{t} w_{i} x_{t-i}}{\sum_{i=0}^{t} w_{i}} \\ &=\frac{x_{t}+(1-\alpha) x_{t-1}+(1-\alpha)^{2} x_{t-2}+\ldots+(1-\alpha)^{t} x_{0}}{1+(1-\alpha)+(1-\alpha)^{2}+\ldots+(1-\alpha)^{t}} \end{aligned} yt=∑i=0twi∑i=0twixt−i=1+(1−α)+(1−α)2+…+(1−α)txt+(1−α)xt−1+(1−α)2xt−2+…+(1−α)tx0
对于 Series 而言，可以用 ewm 对象如下计算指数平滑后的序列：

In [118]: np.random.seed(0)In [119]: s = pd.Series(np.random.randint(-1,2,30).cumsum())In [120]: s.head()
Out[120]:
0   -1
1   -1
2   -2
3   -2
4   -2
dtype: int32In [121]: s.ewm(alpha=0.2).mean().head()
Out[121]:
0   -1.000000
1   -1.000000
2   -1.409836
3   -1.609756
4   -1.725845
dtype: float64

用expanding 窗口实现；

np.random.seed(0)
s = pd.Series(np.random.randint(-1,2,30).cumsum())
print(s.ewm(alpha=0.2).mean().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
print(s.expanding().apply(ewm_func).head())
/*
0   -1.000000
1   -1.000000
2   -1.409836
3   -1.609756
4   -1.725845
dtype: float64
*/

2.2作为滑动窗口的 ewm 窗口
从第1问中可以看到， ewm 作为一种扩张窗口的特例，只能从序列的第一个元素开始加权。现在希望给定一个限制窗口 n ，只对包含自身的最近的 n 个元素作为窗口进行滑动加权平滑。请根据滑窗函数，给出新的 w i w_{i} wi 与 y t y_{t} yt的更新公式，并通过 rolling 窗口实现这一功能。

s.rolling(window=4).apply(ewm_func).head() # 无需对原函数改动
/*
0         NaN
1         NaN
2         NaN
3   -1.609756
4   -1.826558
dtype: float64
*/

(数学实在没时间弄了，缺了好多，回头把参考答案的理解注释补上)

Pandas02--pandas基础相关推荐

快乐学习Pandas入门篇：Pandas基础
Datawhale学习作者:杨煜,Datawhale成员寄语:本文对Pandas基础内容进行了梳理,从文件读取与写入.Series及DataFrame基本数据结构.常用基本函数及排序四个模块快速入 ...
pandas object转float_数据分析篇 | Pandas基础用法6【完结篇】
这是最后一篇,至此Pandas系列终于连载完了,有需要的也可以看看前面6篇,尽请收藏. 数据分析篇 | Pandas 概览数据分析篇 | Pandas基础用法1数据分析篇 | Pandas基础用法2 ...
Numpy与Pandas基础
Numpy与Pandas基础 Cyczz 计算机小白关注他 1 人赞同了该文章本文包括: 一维数据分析二维数据分析一.一维数组 Numpy的一维数组(array) 创建一个一维数组,参数传入 ...
【Python】Pandas基础：结构化数据处理
python:Pandas基础:结构化数据处理目录: 文章目录 @[toc] 一 pandas及其重要性二 pandas的数据结构介绍 1 Series 2 DataFrame 3 索引对象三 ...
利用Python进行数据分析(7) pandas基础: Series和DataFrame的简单介绍一、pandas 是什么 pandas 是基于 NumPy 的一个 Python 数据分析包，主
利用Python进行数据分析(7) pandas基础: Series和DataFrame的简单介绍一.pandas 是什么 pandas 是基于 NumPy 的一个 Python 数据分析包,主要目 ...
Python科学计算之Pandas基础学习
Python科学计算之Pandas基础学习导入Pandas 我们首先要导入我们的演出明星--Pandas. 这是导入Pandas的标准方式.显然,我们不希望每时每刻都在程序中写'pandas',但是 ...
pandas pivot 计算占比_数据分析Pandas 基础（二）
推荐阅读:数据分析--Pandas 基础(一) 上一节课介绍了 Pandas 的基本用法,这一章节我们通过对 "泰坦尼克号" 幸存者进行数据分析,来进一步的学习 pandas. t ...
数据载入、Pandas基础和探索性数据分析
1. 载入数据及初步观察 1.1 载入数据数据集下载 https://www.kaggle.com/c/titanic/overview 1.1.1 导入numpy和pandas import nu ...
【Python 数据科学】Numpy和Pandas基础
文章目录一.Numpy基础简介 1.基础 2. 数组的加减乘除.切片与列表相同二.Pandas 基础 1.series 1)基础 2)切片 2.dataframe 1).构造 2).切片取行取 ...
【Python｜Kaggle】机器学习系列之Pandas基础练习题（五）
前言 Hello!小伙伴! 非常感谢您阅读海轰的文章,倘若文中有错误的地方,欢迎您指出- 自我介绍 ଘ(੭ˊᵕˋ)੭ 昵称:海轰标签:程序猿|C++选手|学生简介:因C语言结识编程,随后转入计 ...

Pandas02--pandas基础

目录