(2) python--pandas

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import pandas as pd
import numpy as np
 
# 创建的Series几种方式
s1 = pd.Series(range(4))
s2 = pd.Series([0, 1, 2, 3])
s3 = pd.Series(np.arange(4))
print(s1)
'''
0    0
1    1
2    2
3    3
dtype: int64
'''
print(s2)
'''
0    0
1    1
2    2
3    3
dtype: int64
'''
print(s3)
'''
0    0
1    1
2    2
3    3
dtype: int32
'''
 
 
# 之前在numpy中说过Series相当于给array加上了index。如果不定义index那么默认为0,1,2····
s4 = pd.Series(["satori", "mashiro", "nagisa", "sora"], index=["东方地灵殿", "樱花庄的宠物女孩", "clannad", "缘之空"])
print(s4)
'''
东方地灵殿        satori
樱花庄的宠物女孩    mashiro
clannad      nagisa
缘之空            sora
dtype: object
'''
# 并且索引还可以重复
s5 = pd.Series(["satori", "tomoyo", "mashiro", "nagisa", "sora"], index=["东方地灵殿", "clannad", "樱花庄的宠物女孩", "clannad", "缘之空"])
print(s5)
'''
东方地灵殿        satori
clannad      tomoyo
樱花庄的宠物女孩    mashiro
clannad      nagisa
缘之空            sora
dtype: object
'''
print(s5["clannad"])
'''
clannad    tomoyo
clannad    nagisa
dtype: object
'''
 
# 即便定义了index仍然可以通过索引来获取
print(s5[0])  # satori
print(s5[1])  # tomoyo
print(s5[2])  # mashiro
print(s5[3])  # nagisa
print(s5[4])  # sora

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
import pandas as pd
import numpy as np
 
# DataFrame相当于二维的Series,行索引为0,1,2····，列索引如果不指定也为0,1,2····
df = pd.DataFrame(np.arange(12).reshape(3, 4))
print(df)
'''
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
'''
# head,接收一个整型,表示打印前多少行的数据
# tail,接收一个整型,表示打印后多少行的数据
print(df.head(2))
'''
   0  1  2  3
0  0  1  2  3
1  4  5  6  7
'''
print(df.tail(2))
'''
   0  1   2   3
1  4  5   6   7
2  8  9  10  11
'''
 
 
# -------------------------------
df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=["A", "B", "C", "D"])
print(df)
'''
   A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
'''
 
 
# 通过索引或者切片获取元素
# 如果直接使用df的话，那么不能通过df[,]的方式，只能df[][]，df[]找到对应的列(注意是列)，df[][]再找到当前列的某个值
print(df["A"][1])  # 4
# 如果我一定要通过df[,]的方式呢？
# 有以下几种方式
# iloc，一定要传入索引。行就不必说了，列虽然我们指定了名字，但仍然可以通过索引来传值。A的索引是0，B的索引是1·····，当然这里还是按照行和列的顺序的
print(df.iloc[0, 1])  # 1
# iloc是通过索引传的，如果我想用值传呢？使用loc，而且loc只能传值。行的索引和值都相同，但列必须穿指定的index
print(df.loc[0, "B"])  # 1
# at，同样需要传入值
print(df.at[0, "B"])  # 1
# ix,既可以传值，又可以传索引。但是貌似要被移除了，提示使用iloc或者loc。
print(df.ix[0, "B"], df.ix[0, 1])  # 1 1
 
# 数据的形状
print(df.shape)  # (3, 4)
 
# 数据的类型
print(df.dtypes)
'''
A    int32
B    int32
C    int32
D    int32
dtype: object
'''
 
# 数组的维度
print(df.ndim)  # 2,表明两行四列，维度是2
 
# 数组元素的个数
print(df.size)  # 12
 
# 数组的索引
print(df.index)  # RangeIndex(start=0, stop=3, step=1)
 
# 数组的列名
print(df.columns)  # Index(['A', 'B', 'C', 'D'], dtype='object')
 
# 数组的值，打印的是一个array
print(df.values)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''
 
# 整体信息描述
print(df.describe())
'''
         A    B     C     D
count  3.0  3.0   3.0   3.0
mean   4.0  5.0   6.0   7.0
std    4.0  4.0   4.0   4.0
min    0.0  1.0   2.0   3.0
25%    2.0  3.0   4.0   5.0
50%    4.0  5.0   6.0   7.0
75%    6.0  7.0   8.0   9.0
max    8.0  9.0  10.0  11.0
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
import pandas as pd
 
# 关于pandas如何读取文件
# pd.read_sql(sql, conn)
    # 读取数据库里的文件,sql为查询的函数，conn则为数据库驱动的connect，或者SQLAlchemy的create_engine()创建的一个引擎
# pd.read_csv()，用来处理CSV文件
    # 这里面的参数非常多，介绍几个常用的
    # 第一个参数：一定要传文件路径或者buf。后面的参数，传入的时候最好加上参数名
    # 第二个参数：sep,表示用什么分割，不指定的话默认用空格
    # 第三个参数：usecols,如果csv文件中有很多列，而我们只需要某几个，这个时候就可以使用usecols，将需要筛选的列作为列表传给usecols
    # 第四个参数：nrows，有的时候我们不一样要全部读到内存中，所有nrows指定读取的行数
    # 第五个参数：index_col,将内容读到DataFrame的时候，选择哪一列作为索引。
    # 第六个参数：encoding，选择编码，除了文件路径
# pd.read_excel()，用来处理Excel文件
    # 参数依旧有很多，想介绍的和read_csv()差不多
    # 第一个参数：文件名路径
    # 第二个参数：sheetname
    # 后面的参数和read_csv()类似
# pd.read_table()，用来处理TXT文件
    # 参数有很多，和read_csv()传参一样，
 
 
# 这里介绍处理CSV，其实主要还是把内容读成DataFrame之后的操作，从这个角度来说，读取什么文件不重要，重要的是在读取之后如何进行操作
df = pd.read_csv(r"C:\Users\Administrator\Desktop\satori.csv", encoding="gbk")
print(df)
# 可以看到文件全部读进来了
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  16     东方地灵殿  女  紫红
1  椎名真白  17  樱花庄的宠物女孩  女  金色
2   宫园薰  16   四月是你的谎言  女  金色
3  春日野穹  15       缘之空  女  银白
4   古河渚  18   clannad  女  棕色
5  坂上智代  17   clannad  女  银白
6  雨宫优子  16      悠久之翼  女  黑色
7  四方茉莉  17      sola  女  黑色
'''
 
# ---------------------------
'''
# 测试nrows
df = pd.read_csv(r"C:\\Users\Administrator\Desktop\satori.csv", encoding="gbk", nrows=3)
print(df)
# 可以看到我们只读了三行
     姓名  年龄      登场作品 性别  发色
0  古明地觉  16     东方地灵殿  女  紫红
1  椎名真白  17  樱花庄的宠物女孩  女  金色
2   宫园薰  16   四月是你的谎言  女  金色
 
'''
 
# ------
'''
# 测试usecols，注意这里的usecols还可以用对应的索引代替，从零开始慢慢数。
df = pd.read_csv(r"C:\\Users\Administrator\Desktop\satori.csv", encoding="gbk", nrows=3, usecols=["姓名", "发色"])
print(df)
# 可以看到在读取了三行的基础上，只读了两列
     姓名  发色
0  古明地觉  紫红
1  椎名真白  金色
2   宫园薰  金色
'''
 
# --------
# 现在df长这个样子
print(df)
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  16     东方地灵殿  女  紫红
1  椎名真白  17  樱花庄的宠物女孩  女  金色
2   宫园薰  16   四月是你的谎言  女  金色
3  春日野穹  15       缘之空  女  银白
4   古河渚  18   clannad  女  棕色
5  坂上智代  17   clannad  女  银白
6  雨宫优子  16      悠久之翼  女  黑色
7  四方茉莉  17      sola  女  黑色
 
'''
 
# 筛选出年龄大于16的
print(df[df["年龄"] > 16])
'''
     姓名  年龄      登场作品 性别  发色
1  椎名真白  17  樱花庄的宠物女孩  女  金色
4   古河渚  18   clannad  女  棕色
5  坂上智代  17   clannad  女  银白
7  四方茉莉  17      sola  女  黑色
'''
 
# 将每个人的年龄减去一
df["年龄"] = df["年龄"].apply(lambda x: x-1)
print(df)
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色
2   宫园薰  15   四月是你的谎言  女  金色
3  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色
5  坂上智代  16   clannad  女  银白
6  雨宫优子  15      悠久之翼  女  黑色
7  四方茉莉  16      sola  女  黑色
'''
 
# ---------------
'''
# 假设df当中存在名为"时间"的时间戳，怎么转化为我们看着舒服的日期呢？
df["时间"] = pd.to_datetime(df["时间"], format="%Y-%d-%m", errors="coerce")
'''
 
# 查找姓名中包含宫的
print(df[df["姓名"].str.contains("宫")])
'''
     姓名  年龄     登场作品 性别  发色
2   宫园薰  15  四月是你的谎言  女  金色
6  雨宫优子  15     悠久之翼  女  黑色
'''
 
# 查找年龄为14或者16的
print(df[df["年龄"].isin([14, 16])])
'''
     姓名  年龄      登场作品 性别  发色
1  椎名真白  16  樱花庄的宠物女孩  女  金色
3  春日野穹  14       缘之空  女  银白
5  坂上智代  16   clannad  女  银白
7  四方茉莉  16      sola  女  黑色
'''
 
# 将DataFrame按照年龄排序，如果按照多个列排序，那么将多个列组成一个列表传进去
# 参数里面还有一个ascending=True，表示正序排，inplace=False，表示不在原来的DataFrame上操作，而是返回一个新的DataFrame
print(df.sort_values(by="年龄"))
'''
     姓名  年龄      登场作品 性别  发色
3  春日野穹  14       缘之空  女  银白
0  古明地觉  15     东方地灵殿  女  紫红
2   宫园薰  15   四月是你的谎言  女  金色
6  雨宫优子  15      悠久之翼  女  黑色
1  椎名真白  16  樱花庄的宠物女孩  女  金色
5  坂上智代  16   clannad  女  银白
7  四方茉莉  16      sola  女  黑色
4   古河渚  17   clannad  女  棕色
'''
 
# 计算不同年龄的出现的次数
print(df["年龄"].value_counts())
'''
15    3
16    3
14    1
17    1
Name: 年龄, dtype: int64
'''
print(type(df["年龄"].value_counts()))  # <class 'pandas.core.series.Series'>
 
 
# groupby汇总,如果按照多列汇总，那么将多列组合成一个列表传进去
# 里面的as_index,默认为True，说明汇总之后，传给by的列名要作为索引，如果多个列，那么共同作为索引
# 里面的sort=True,表示汇总之后自动排序
# 按照发色汇总，count表示每一种发色总共对应多少个name
print(df[["姓名", "发色"]].groupby(by="发色").count())
'''
    姓名
发色   
棕色   1
紫红   1
金色   2
银白   2
黑色   2
'''
# 除了count还有sum，比方我想按照"发色"汇总年龄，把发色相同的人的年龄加在一起
print(df[["年龄", "发色"]].groupby(by="发色").sum())
'''
    年龄
发色   
棕色  17
紫红  15
金色  31
银白  30
黑色  31
'''
 
# 我想把年龄相同的过滤掉
# inplace=False,默认不在原表上进行操作，而是返回新的列表。keep="first",表示去重的时候保留第一个，也可以指定为last
# 按照多个值过滤，组个列表传进去
print(df.drop_duplicates("年龄"))
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色
3  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色
'''
 
# 数据的合并
# 首先是concat,默认是上下合并,里面接受一个列表，列表可以存放很多个df，默认是axis=0，上下合并
print(pd.concat([df, df]))
'''
0  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色
2   宫园薰  15   四月是你的谎言  女  金色
3  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色
5  坂上智代  16   clannad  女  银白
6  雨宫优子  15      悠久之翼  女  黑色
7  四方茉莉  16      sola  女  黑色
'''
# 左右合并
print(pd.concat([df, df], axis=1))
'''
     姓名  年龄      登场作品 性别  发色    姓名  年龄      登场作品 性别  发色
0  古明地觉  15     东方地灵殿  女  紫红  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色  椎名真白  16  樱花庄的宠物女孩  女  金色
2   宫园薰  15   四月是你的谎言  女  金色   宫园薰  15   四月是你的谎言  女  金色
3  春日野穹  14       缘之空  女  银白  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色   古河渚  17   clannad  女  棕色
5  坂上智代  16   clannad  女  银白  坂上智代  16   clannad  女  银白
6  雨宫优子  15      悠久之翼  女  黑色  雨宫优子  15      悠久之翼  女  黑色
7  四方茉莉  16      sola  女  黑色  四方茉莉  16      sola  女  黑色
'''
 
# 采用merge方式合并
# merge里面只接收两个df，然后是合并方式，how="left",按照左边的df合并，如果左边的df中没有就丢弃，同理right类似。how="inner"，两个df相当于做交集。how="outer",两个df相当于做补集
# on = "",表示按照哪个字段合并，如果多个字段作为列表传进去
print(pd.merge(df, df, how="outer", on="姓名"))
'''
     姓名  年龄_x    登场作品_x 性别_x 发色_x  年龄_y    登场作品_y 性别_y 发色_y
0  古明地觉    15     东方地灵殿    女   紫红    15     东方地灵殿    女   紫红
1  椎名真白    16  樱花庄的宠物女孩    女   金色    16  樱花庄的宠物女孩    女   金色
2   宫园薰    15   四月是你的谎言    女   金色    15   四月是你的谎言    女   金色
3  春日野穹    14       缘之空    女   银白    14       缘之空    女   银白
4   古河渚    17   clannad    女   棕色    17   clannad    女   棕色
5  坂上智代    16   clannad    女   银白    16   clannad    女   银白
6  雨宫优子    15      悠久之翼    女   黑色    15      悠久之翼    女   黑色
7  四方茉莉    16      sola    女   黑色    16      sola    女   黑色
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
'''
df[pd.isnull(df.title)],选出title为空的所有行
df[df.title.contains("aaa", na=False)], 选出title包含aaa的所有行，不包括空值
 
    a
0   10
1   30
2   50
3   70
4   90
5   100
 
labels = ["10到20", "20到40","40到60","60到80", "80到95", "100"]
bins = [20, 40, 60, 80, 95, 100]
pd.cut(df.a, bins, right=True, labels=None)
 
>>>   
    a
0   (1, 20]
1   (20, 40]
2   (40,60]
3   (60, 80]
4   (80, 95]
5   (95, 100]
 
pd.cut(df.a, bins, right=True, labels=labels)
 
>>>   
    a
0   10到20
1   20到40
2   40到60
3   60到80
4   80到95
5   100
 
字符串专程日期格式
df.to_datetime(df.time, format="")
 
日期抽取
df["time"].dt.year
df["time"].dt.month
df["time"].dt.day
df["time"].dt.hour
df["time"].dt.minute
df["time"].dt.second
df["time"].dt.weekday
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
df = pd.DataFrame({"a": [4,3,4,5],
                   "b": [5,2,7,7],
                   "c": [4,4,8,9]})
 
print(df.div(100))
'''
      a     b     c
0  0.04  0.05  0.04
1  0.03  0.02  0.04
2  0.04  0.07  0.08
3  0.05  0.07  0.09
'''
# 表示先对每一行进行求和，让列元素分别去除
print(df.div(df.sum(axis=1), axis=0))
# 会发现每一行相加等于一
'''
          a         b         c
0  0.307692  0.384615  0.307692
1  0.333333  0.222222  0.444444
2  0.210526  0.368421  0.421053
3  0.238095  0.333333  0.428571
'''
# 表示先对每一列进行求和，让行元素分别去除
# 会发现每一列相加等于一
print(df.div(df.sum(axis=0), axis=1))
'''
        a         b     c
0  0.2500  0.238095  0.16
1  0.1875  0.095238  0.16
2  0.2500  0.333333  0.32
3  0.3125  0.333333  0.36
'''
# 查看相关性
'''
df["a"].corr(df["b"]), 查看a和b之间的相关性
df["a", "b", "c"].corr(df["a", "b"]), 查看a,b,c和a,b之间的相关性，a、b和a、b之间肯定高度相关
df["a", "b", "c"].corr(),corr不加参数默认和前面的df保持一致，即查看a、b、c和a、b、c之间的相关性
'''

　　

1
2
pd.set_option("expand_frame_repr", False)  # 列太多时不换行
pd.set_option("max_colwidth", 8)  # 有的列太长，我们可以进行设置，比如设置最大列宽等于8

　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'''
    alpha
0   a
1   b
2   c
3   d
4   e
 
df["new_alpha"] = df["alpha"].shift(1)
那么df["new_data"]会在df["alpha"]的基础上上移1位,超出的部分为NaN,里面的可以为任意数字。如果为负数，那么在原来的基础上下移
 
    alpha new_alpha
0   a     NaN
1   b     a
2   c     b
3   d     c
4   e     d
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'''
    收盘价
0   10
1   12
2   9
3   11
4   13
 
df["涨跌] = df["收盘价"].diff(-1),求本行数据和上行数据相减的结果。为1，则是上行数据和本行数据相减的结果。如果-2，则是本上数据和上两行数据相减的结果
 
    收盘价  涨跌
0   10      2 -->12-10
1   12      -3-->9-12
2   9       2 -->11-9
3   11      2 -->13-11
4   13      NaN -->NaN-13
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'''
    收盘价
0   10
1   12
2   9
3   11
4   13
 
df["涨跌] = df["收盘价"].pct_change(-1), 类似于diff，但求的是增加或者减少的比例
 
    收盘价  涨跌
0   10      (12-10)/2
1   12      (9-12)/12
2   9       (11-9)/9
3   11      (13-11)/11
4   13      NaN
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'''
    收盘价
0   10
1   12
2   9
3   11
4   13
 
df["收盘价_cum"] = df["收盘价"].cumsum() ,累加
 
    收盘价  收盘价_cum
0   10      10
1   12      12+10
2   9       9+12+10
3   11      11+9+12+10
4   13      13+11+9+12+10
 
还有cumprod表示累乘
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'''
    收盘价
0   10
1   12
2   9
3   11
4   13
 
df["收盘价排序"] = df["收盘价"].rank(ascending=True, pct=False)
 
    收盘价 收盘价排序
0   10      2 从小到大排名第2
1   12      4 从小到大排名第4
2   9       1 从小到大排名第1
3   11      3 从小到大排名第3
4   13      5 从小到大排名第5
 
ascending：升序，为True表示从小到大，为False从大到小
pct：percent，为False表示排名，为True表示排名的百分比
'''

　　

1
2
3
4
5
6
'''
df.dropna(how="any")，只要有空值就删
df.dropna(how="all")，必须全为空值才删
 
df.drop(subset=["column1", "column2"], how="all"),其他列不管，只要column1、columns2全为空值就删除这一行。
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
'''
    收盘价 利润
0   10     20
1   12     15
2   9      NaN
3   11     13
4   13     NaN
 
df["利润"] = df["利润"].fillna(value=10)
    收盘价 利润
0   10     20
1   12     15
2   9      10
3   11     13
4   13     10
 
df["利润"] = df["利润"].fillna(value=df["收盘价"])
    收盘价 利润
0   10     20
1   12     15
2   9      9
3   11     13
4   13     13
 
df["利润"] = df["利润"].fillna(method="ffill")，向上寻找最近的一个非空值进行填充
    收盘价 利润
0   10     20
1   12     15
2   9      15
3   11     13
4   13     13
 
同理method="bfill",表示向下寻找一个最近的非空值进行填充
 
    收盘价 利润
0   10     20
1   12     15
2   9      NaN
3   11     13
4   13     NaN
df.notnull(),判断是不是不空值，不空为True， 空为False
df.isnull(),判断是不是空值，空为True， 不空为False
 
df[df["利润"].isnull()]
    收盘价 利润
2   9      NaN
4   13     NaN
 
df[df["利润"].notnull()]
    收盘价 利润
0   10     20
1   12     15
3   11     13
'''

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import pandas as pd
 
df = pd.DataFrame({"a": [0, 1, 2, 3, 4], "b": [5, 6, 7, 8, 9]})
print(df)
'''
   a  b
0  0  5
1  1  6
2  2  7
3  3  8
4  4  9
'''
print(df.rolling(3).mean())
'''
     a    b
0  NaN  NaN
1  NaN  NaN
2  1.0  6.0
3  2.0  7.0
4  3.0  8.0
'''
print(df.rolling(3, min_periods=1).mean())
'''
     a    b
0  0.0  5.0
1  0.5  5.5
2  1.0  6.0
3  2.0  7.0
4  3.0  8.0
'''
print(df.expanding().mean())
'''
     a    b
0  0.0  5.0
1  0.5  5.5
2  1.0  6.0
3  1.5  6.5
4  2.0  7.0
前n行的平均数
'''
posted @ 2019-08-23 09:08  不夜男人  阅读(156)  评论(0)    收藏  举报