本文章仅供我本人学习记录使用，不允许任何转载及引用。特此声明。
Pandas是建立在Numpy的基础上的，处理二维数据时更加得心应手。
Pandas增加了更多高级使用的功能，比如数据自动对齐功能，时间序列的支持，确实数据的灵活处理等等。
In[1]: import pandas as pd
In[2]: import bumpy as np
In[3]: from pandas import Series, DataFrame
Series 和 DataFrame
是Pandas的两种核心数据结构。
Series:
Series是值的序列，可以理解为一维数组，它只有一个列和索引。
索引可以定制，当不指定时默认使用整数索引，而且索引可以被命名：
In[1]:s1 = Series([1, 2, 3, 4, 5])
Out[1]:
0 1
1 2
2 3
3 4
4 5
dtype: int64
# 第一列是未指定时默认的整数索引
In[2]: s2 = Series([1, 2, 3, 4, 5], index = ['a', 'b', 'c', 'd', 'e'])
Out[2]:
a 1
b 2
c 3
d 4
e 5
dtype: int64
# 定制索引时
In[3]: s2.index.name = 'index'
In[4]: s2.index
Out[4]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object', name='index')
In[5]: s2
Out[5]:
index
a 1
b 2
c 3
d 4
e 5
dtype: int64
DataFrame:
DataFrame类似于二维数组，有行和列之分，除了像Series一样，多个行有索引之外，每个列上面还可以有标签label，索引和标签本身都可以被命名：
In[1]: df = DataFrame(np.random.randn(4, 4), index = ['a', 'b', 'c', 'd'], columns = ['A', 'B', 'C', 'D'])
Out[1]:
A B C D
a -0.877290 0.434619 -0.996634 -0.398794
b 1.131611 -1.553991 -0.696632 -0.209264
c 0.785401 -0.967436 -0.063710 -0.442142
d 0.045040 -0.446373 1.835974 0.820756
# index和columns的设置也可以用index = list('abc')
In[2]: df.index
Out[2]: Index(['a', 'b', 'c', 'd'], dtype='object')
In[3]: df.index.name = 'Index1'
Out[3]: Index(['a', 'b', 'c', 'd'], dtype='object', name='Index1')
In [4]: df.columns
Out[4]: Index(['A', 'B', 'C', 'D'], dtype='object')
In[5]: df.columns.name = 'Col'
Out[5]: Index(['A', 'B', 'C', 'D'], dtype='object', name='Col')
In[6]: df
Out[6]:
Col A B C D
Index1
a -0.877290 0.434619 -0.996634 -0.398794
b 1.131611 -1.553991 -0.696632 -0.209264
c 0.785401 -0.967436 -0.063710 -0.442142
d 0.045040 -0.446373 1.835974 0.820756
# ***行列转换***
In[]: df.T
选择
当需要选择部分数据时:
-
Series:
主要通过其索引来进行选择：
In[1]: s2 = Series([1, 2, 3, 4, 5], index = ['a', 'b', 'c', 'd', 'e'])
Out[1]:
a 1
b 2
c 3
d 4
e 5
dtype: int64
In[2]: s2[0]
Out[2]: 1
# 默认整数索引，一直存在的
In[3]: s2['a']
Out[3]: 1
# 指定后的索引
In[4]: s2[0:3]
Out[4]:
a 1
b 2
c 3
dtype: int64
In[5]: s2['a':'c']
Out[5]:
a 1
b 2
c 3
dtype: int64
以上调用多行，使用了s2.N和s2.loc。
- s2[0:3]相当于s2.iloc[0:3]，
- s2['a':'c']相当于s2.loc['a':'c']，
-
不能互换
如下：
In[6]: s2.iloc[0:3]
Out[6]:
a 1
b 2
c 3
dtype: int64
In[7]: s2.loc['a':'c']
Out[7]:
a 1
b 2
c 3
dtype: int64
通过步长，用 iloc [[[间隔调用多行]]]:
In []: s2.iloc[::2]
Out[]:
a 1
c 3
e 5
dtype: int64
方法一：iloc[::5]
方法二：index.isin()
.iloc和.loc和.ix的区别进阶学习：
.ix：(https://fishc.com.cn/thread-79821-1-1.html)
区别：（https://blog.csdn.net/hecongqing/article/details/61927615）
-
DataFrame:
由于有行列之分，所以可以有多种选择数据的方式：
-- 通过索引或标签来选择：
(1) 用标签（列）选择：
In[8]: df
Out[8]:
A B C D
a -1.219787 0.730984 -0.785763 -0.634453
b -0.317280 -1.279367 0.359007 0.700775
c -2.226339 0.380315 2.120930 -1.161018
d -1.212816 -0.777530 -0.130212 1.492688
In[9]: df.A
Out[9]:
a -1.219787
b -0.317280
c -2.226339
d -1.212816
Name: A, dtype: float64
In[10]: df['A']
Out[10]:
a -1.219787
b -0.317280
c -2.226339
d -1.212816
Name: A, dtype: float64
# 使用标签，df.A和df['A']相同，可以选择某1列
# 使用标签，选择多列：
In[11]: df[df.columns[0:2]]
Out[11]:
A B
a -1.219787 0.730984
b -0.317280 -1.279367
c -2.226339 0.380315
d -1.212816 -0.777530
# 只能使用默认整数索引
# 或者df.loc[:, ['A':'B']]，下面有演示
---查看列名：
In[]: df.columns.tolist()
Out[]:
---删除列或删除行：
In[]:
df.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')
# 例：
In[]:
df.drop((0, 'b_amt'), axis=1)
# (0, 'b_amt')就是一个列名，不用加‘’或()或[]
# 或
In[]:
df.drop(['B', 'C'], axis=1)
# 或
In[]:
df.drop(index='cow', columns='small')
# Drop a row by index:
In[]:
df.drop([0, 1])
---重命名列columns：
In[]:
df.rename(columns={'A':'a', 'B':'b'})
(2).选择‘行’：
使用loc和iloc选择一行或多行
In[12]: df
Out[12]:
A B C D
a -1.219787 0.730984 -0.785763 -0.634453
b -0.317280 -1.279367 0.359007 0.700775
c -2.226339 0.380315 2.120930 -1.161018
d -1.212816 -0.777530 -0.130212 1.492688
In[13]: df.loc['a']
Out[13]:
A -1.219787
B 0.730984
C -0.785763
D -0.634453
Name: a, dtype: float64
# df.iloc[0]有同样效果
In[14]: df.loc['a':'b']
Out[14]:
A B C D
a -1.219787 0.730984 -0.785763 -0.634453
b -0.317280 -1.279367 0.359007 0.700775
# 用loc和iloc选择列：
In[15]: df.loc[:, 'A':'B']
Out[15]:
A B
a -1.219787 0.730984
b -0.317280 -1.279367
c -2.226339 0.380315
d -1.212816 -0.777530
# 相当于用‘：’同时选择所有行，并在所有列中选择某几列。
# 由此知道，选择某一行某一列的一个元素，或某几行或某几列的多个元素就简单了：
In[16]: df
Out[16]:
A B C D
a -1.219787 0.730984 -0.785763 -0.634453
b -0.317280 -1.279367 0.359007 0.700775
c -2.226339 0.380315 2.120930 -1.161018
d -1.212816 -0.777530 -0.130212 1.492688
In[17]: df.loc['a', 'A']
Out[17]: -1.2197869779119481
# df.iloc[0, 0]，效果相同
In[18]: df.loc['b':'c', 'C':'D']
Out[18]:
C D
b 0.359007 0.700775
c 2.120930 -1.161018
# df.iloc[1:3, 2:4]， 效果相同
# ***隔列选择***
df[['A','D']]
#选择表格中的'w'、'z'列
#更多请查看：https://blog.csdn.net/wanglingli95/article/details/78887771
缺失值'NaN'和数据自动对齐
在Pandas中最重要的一个功能是，它可以对不同索引的对象进行算术运算。比如将两个Series数据进行相加时，如果存在不同的索引，则结果是两个索引的并集， 示例如下：
In[1]: s1 = Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])
In[2]: s1
Out[2]:
a 1
b 2
c 3
d 4
dtype: int64
In[3]: s2 = Series([2, 3, 4, 5], index = ['b', 'c', 'd', 'e'])
Out[3]:
b 2
c 3
d 4
e 5
dtype: int64
In[4]: s1 + s2
Out[4]:
a NaN
b 4.0
c 6.0
d 8.0
e NaN
dtype: float64
# 两个索引的并集
2个Series中['b', 'c', 'd']的索引是相同的，所以值可以相加，但不重叠的索引引入了NaN值（缺失值）。
而缺失值会在运算中传播，所以最终结果也是NaN值。（后面会讲解）
根据相同的索引进行自动计算，这就是自动对齐功能。
在DataFrame中，相同的规格也生效：
In[5]: df1 = DataFrame(np.arange(9).reshape(3, 3), columns = list('ABC'), index = list('abc'))
Out[5]:
A B C
a 0 1 2
b 3 4 5
c 6 7 8
In[6]: df2 = DataFrame(np.arange(12).reshape(3,
...: 4), index = list('bcd'), columns = list('
...: ABDE'))
Out[6]:
A B D E
b 0 1 2 3
c 4 5 6 7
d 8 9 10 11
In[7]: df1 + df2
Out[7]:
A B C D E
a NaN NaN NaN NaN NaN
b 3.0 5.0 NaN NaN NaN
c 10.0 12.0 NaN NaN NaN
d NaN NaN NaN NaN NaN
可以看出，DataFrame的计算也进行了自动对齐操作，NaN值被自动填充，而由于NaN值会传播（如上解释），所以相加的结果也是NaN。
如果我们想避免结果为NaN值，可以指定使用值来填充（替代）NaN值，如下：
In[8]: df1.add(df2, fill_value = 0)
Out[8]:
A B C D E
a 0.0 1.0 2.0 NaN NaN
b 3.0 5.0 5.0 2.0 3.0
c 10.0 12.0 8.0 6.0 7.0
d 8.0 9.0 NaN 10.0 11.0
# 使用fill_value参数指定NaN值的填充值，使用与Series和DataFrame。
我们指定了‘0’填充了NaN值，然后带入计算过程（这里是先填充值，再运算）。
这里剩余的NaN值是因为df1和df2中都未定义。
常用运算
Series和DataFrame的常用运算和Numpy差不多。
在Pandas中还有一种比较常见的操作时将函数运用到每一行或者每一列上面，DataFrame的apply方法可以实现此功能，比如想统计每行和每列的极差（最大值和最小值之差）：
In[1]: df1 = DataFrame(np.arange(9).reshape(3, 3
...: ), index = list('abc'), columns = list('A
...: BC'))
In[2]: df1
Out[2]:
A B C
a 0 1 2
b 3 4 5
c 6 7 8
In[3]: f = lambda x: x.max() - x.min()
# 定义了f，f是匿名函数
In [4]: f
Out[4]: <function __main__.<lambda>>
# f匿名函数简单的返回列表的极差
In[5]: df1.apply(f)
Out[5]:
A 6
B 6
C 6
dtype: int64
# 将计算极差的匿名函数f使用apply方法应用到df1上
In [6]: df1.apply(f, axis = 1)
Out[6]:
a 2
b 2
c 2
dtype: int64
# 这个加入了参数axis = 1，所以计算df1中每一行的极差（索引‘a’行中max最大值‘2’和min最小值‘0’之差是2）
# 上一个计算中，默认的axis是0（列），所以计算的是每一列的极差（索引‘A’列中max最大值‘6’和min最小值‘0’之差是6）
如果想将某函数应用到每一个元素上，DataFrame可以使用df.applymap方法，Series可以使用s.map方法：
In [7]: df1.applymap(lambda x: x + 1)
Out[7]:
A B C
a 1 2 3
b 4 5 6
c 7 8 9
In [8]: s1
Out[8]:
a 1
b 2
c 3
d 4
dtype: int64
In [9]: s1.map(lambda x: x + 1)
Out[9]:
a 2
b 3
c 4
d 5
dtype: int64
# 以上结果是让所有元素增加1，其结果与df1 + 1和s1 + 1的运算结果相同。
常用统计：
比如求平均值，方差等，同时通过describe方法可以得知当前数据的一些常用统计信息：
In[]: df1 = DataFrame(np.arange(9).reshape(3,3), columns=list('ABC'), index=list('abc'))
In[]: df1
Out[]:
A B C
a 0 1 2
b 3 4 5
c 6 7 8
In[]: df1.sum()
Out[]:
A 9
B 12
C 15
dtype: int64
# 每列求和
In[]: df1.sum(axis = 1)
Out[]:
a 3
b 12
c 21
dtype: int64
# 每行求和
In[]: df1.mean()
Out[]:
A 3.0
B 4.0
C 5.0
dtype: float64
# 每列的平均数
In []: df1.mean(axis = 1)
Out[]:
a 1.0
b 4.0
c 7.0
dtype: float64
# 每行的平均数
In[]: df1.describe()
Out[]:
A B C
count 3.0 3.0 3.0 # 列的元素的数量
mean 3.0 4.0 5.0 # 列的平均值
std 3.0 3.0 3.0 # 列的标准差
min 0.0 1.0 2.0 # 列的最小值(0%)
25% 1.5 2.5 3.5 # 下四分位数
50% 3.0 4.0 5.0 # 中位数
75% 4.5 5.5 6.5 # 上四分位数
max 6.0 7.0 8.0 # 列的最大值(100%)
In[]: df1.loc['b'].describe()
Out[]:
count 3.0
mean 4.0
std 1.0
min 3.0
25% 3.5
50% 4.0
75% 4.5
max 5.0
Name: b, dtype: float64
# 第二行'b'行的统计信息
# *目前还不知道怎么统计多行信息*
数据合并和分组
合并2个DataFrame数据，方法主要有2种：
（1）简单进行拼接，通过pd.concat方法实现
（2）根据列名类像数据库表查询一样进行合并，通过pd.merge方法实现
In[]: df1 = DataFrame(np.random.randn(3, 3))
In[]: df2 = DataFrame(np.random.randn(3, 3), index = [5, 6, 7])
In[]: df1
Out[]:
0 1 2
0 -2.072551 -1.759958 0.465906
1 -1.302374 2.343270 0.233606
2 -1.450751 1.160754 1.271709
In[]: df2
Out[]:
0 1 2
5 0.092593 1.846336 1.757417
6 0.328430 -1.662719 -0.366255
7 -0.360098 -0.334050 -0.032662
In[]: pd.concat([df1, df2])
Out[]:
0 1 2
0 -2.072551 -1.759958 0.465906
1 -1.302374 2.343270 0.233606
2 -1.450751 1.160754 1.271709
5 0.092593 1.846336 1.757417
6 0.328430 -1.662719 -0.366255
7 -0.360098 -0.334050 -0.032662
# 当多个数据集，拥有相同的列时，我们可以按照这个列进行合并操作
# 类似于数据库中的join操作
In[]: df3 = DataFrame({'code':[600276, 600519], 'name':['hengrui', 'maotai'], 'bought_price': [0.00, 649.00]})
In[]: df3
Out[]:
bought_price code name
0 0.0 600276 hengrui
1 649.0 600519 maotai
In[]: df3 = df3.rename(columns = {'bought_price':'in
...: _price'})
Out[]:
in_price code name
0 0.0 600276 hengrui
1 649.0 600519 maotai
# 重命名单个或多个列索引
In[]: df4 = DataFrame({'code': [600276, 600519], 'volume': [100, 100], 'in_date': ['2019-03-18', '2018-02-13']})
In[]: df4
Out[]:
code in_date volume
0 600276 2019-03-18 100
1 600519 2018-02-13 100
In[]: pd.merge(df3, df4)
Out[]:
in_price code name in_date volume
0 0.0 600276 hengrui 2019-03-18 100
1 649.0 600519 maotai 2018-02-13 100
自我理解：
- pd.concat([])用于合并行：当行内容不同时，列名相同
- pd.merge()用于合并列：当列内容不同时，行名相同
上面的代码中我们通过字典创建了两个数据集，可以看到当通过字段创建DataFrame数据集时，键名key变成了列名column name。
df3和df4有共同的列course，当进行merge操作的时候Pandas会自动将这列进行合并。
合并数据集时，有很多参数可以选择，比如选择在根据哪一列进行合并、合并的方式等，可以用help(pd.merge)查看完整的帮助文档。
在Pandas中，也支持类似于数据库查询语句GROUP BY的功能，也就是按照某列进行分组，然后再分组上进行一些计算操作：
In[]: df = DataFrame({'user_id': ['Jack', 'Sam', 'Jack'], 'course': ['Math', 'Sci', 'Eng'], 'minutes': [9, 36, 45]})
In[]: df
Out[]:
course minutes user_id
0 Math 9 Jack
1 Sci 36 Sam
2 Eng 45 Jack
# 方法一：筛选出所有user_id为'Jack'的行，然后进行求和统计：
In[]: df[df['user_id'] == 'Jack']
Out[]:
course minutes user_id
0 Math 9 Jack
2 Eng 45 Jack
In[]: df[df['user_id'] == 'Jack']['minutes']
Out[]:
0 9
2 45
Name: minutes, dtype: int64
In[]: df[df['user_id'] == 'Jack']['minutes'].sum()
Out[]: 54
# 可以看出我们可以先通过df[df['user_id'] =='Jack']布尔索引筛选出所有的相关行，然后通过结合列筛选功能过滤其他列，只剩下时间统计列（minutes所在列为学习时间列），最后通过求和运算统计出了学习时间。
# 方法二：类似于数据库的GROUP BY功能进行计算：
In[]: df[['user_id', 'minutes']]
Out[]:
user_id minutes
0 Jack 9
1 Sam 36
2 Jack 45
In[]: df[['user_id', 'minutes']].groupby('user_id').sum()
Out[]:
minutes
user_id
Jack 54
Sam 36
# 可以看到，我们先过滤列，只剩下了user_id和minutes列，然后通过groupby方法在user_id列上进行分组并求和，相对于前一种方式，分组求和更灵活一些。
自我理解分解：
- 进行逻辑比较运算（Numpy和Pandas都可以），比如我们想知道一个多维数组中哪些值大于某一个指定值
通过一个元素查询行数据
# 1.
In[]: df_bool = df['user_id'] == 'Jack'
# 计算'user_id'列是否等于'Jack', 用df_bool显示
In[]: df_bool
Out[]:
0 True
1 False
2 True
Name: user_id, dtype: bool
In []: df[df_bool]
Out[]:
course minutes user_id
0 Math 9 Jack
2 Eng 45 Jack
# 将a_bool放在df中比较，将只显示a_bool中为'True'的'user_id列'所在的行内容。
# 等同于df[df[...]]
# 2.
In[]: df[df['user_id'] == 'Jack']['minutes']
Out[]:
0 9
2 45
Name: minutes, dtype: int64
In[]: df[df['user_id'] == 'Jack'].minutes
Out[]:
0 9
2 45
Name: minutes, dtype: int64
# ['minutes']和.minutes的输出结果相同，都是对DataFrame的‘列选择’操作
# 3. 上面筛选出来的是‘Name: minutes, dtype: int64’，所以.sum()是对minutes的元素值进行求和
In[]: df[df['user_id'] == 'Jack']['minutes'].sum()
Out[]: 54
时间序列处理
根据数据集中的时间戳进行运算，
在Python中，时间处理方面的相关功能主要集中在datetime包中，主要有三种对象：
- datetime.datetime：代表时间对象；
- datetime.date：代表某一天；
- datetime.timedelta：代表两个datetime.datetime对象之间的时间差。
# datetime.datetime和datetime.timedelta的用法
In[]: from date time import datetime, timedelta
In[]: d1 = datetime(2017, 8, 1)
Out[]: datetime.datetime(2017, 8, 1, 0, 0)
In[]: delta = timedelta(days=10)
In[]: d1 + delta
Out[]: datetime.datetime(2017, 8, 11, 0, 0)
In[]: dates = [datetime(2018, 1, 1), datetime(2018, 1, 2), datetime(2018, 1, 3), datetime(2018, 1, 4)]
Out[]:
[datetime.datetime(2018, 1, 1, 0, 0),
datetime.datetime(2018, 1, 2, 0, 0),
datetime.datetime(2018, 1, 3, 0, 0),
datetime.datetime(2018, 1, 4, 0, 0)]
In[]: ts = Series(np.random.randn(4), index = dates)
Out[]:
2018-01-01 0.241635
2018-01-02 0.121023
2018-01-03 -1.992435
2018-01-04 -0.457257
dtype: float64
In[]: ts.index
Out[]: DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04'], dtype='datetime64[ns]', freq=None)
In[]: ts.index[0]
Out[]: Timestamp('2018-01-01 00:00:00')
# 通过datetime时间类型生成了一堆时间，然后基于此创建了一个时间序列ts， 可以看到ts的索引类型为DatetimeIndex类型。
生成ts以后我们就有多种方法选择元素了，只需要传入一个能被Pandas识别的日期字符串就可以了，如下：
In []: ts
Out[]:
2018-01-01 0.241635
2018-01-02 0.121023
2018-01-03 -1.992435
2018-01-04 -0.457257
dtype: float64
In []: ts.index[0]
Out[]: Timestamp('2018-01-01 00:00:00')
In []: ts[ts.index[0]]
Out[]: 0.2416345185713773
In [311]: ts['2018-01-01']
Out[311]: 0.2416345185713773
In [312]: ts['2018/01/01']
Out[312]: 0.2416345185713773
In [313]: ts['1/1/2018']
Out[313]: 0.2416345185713773
In[]: ts[datetime(2018, 1, 1)]
Out[315]: 0.2416345185713773
# ts[ts.index[0]] ， ts['2018-01-01']， ['2018-01-01']， ts['1/1/2018']， ts['1/1/2018'] 都可以选择同一个元素
生成日期范围：
在Pandas中生成日期范围主要通过pandas.date_range函数完成，该函数主要有以下几个参数：
- start：指定了日期范围的起始时间；
- end：指定了日期范围的结束时间；
- periods：指定了间隔范围，如果只是指定了start和end日期中的其中一个，则需要改参数；
- freq：指定了日期频率，比如D代表每天，H代表每小时，M代表月，这些频率字符前也可以指定一个整数，代表具体多少天。。。，比如5D代表5天。还有一些其他的频率字符串，比如MS代表每月第一天，BM代表每月最后一个工作日，或者是频率组合字符串，比如1h30min代表1小时30分钟。
如下：
In[]: pd.date_range('2018-1-1', '2019', freq = 'M')
Out[]:
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
'2018-05-31', '2018-06-30', '2018-07-31', '2018-08-31',
'2018-09-30', '2018-10-31', '2018-11-30', '2018-12-31'],
dtype='datetime64[ns]', freq='M')
In[]: pd.date_range('2018-01-01', '2019', freq = 'BM')
Out[]:
DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-30', '2018-04-30',
'2018-05-31', '2018-06-29', '2018-07-31', '2018-08-31',
'2018-09-28', '2018-10-31', '2018-11-30', '2018-12-31'],
dtype='datetime64[ns]', freq='BM')
In[]: pd.date_range('2018-1-1', '2019', freq = 'MS')
Out[]:
DatetimeIndex(['2018-01-01', '2018-02-01', '2018-03-01', '2018-04-01',
'2018-05-01', '2018-06-01', '2018-07-01', '2018-08-01',
'2018-09-01', '2018-10-01', '2018-11-01', '2018-12-01',
'2019-01-01'],
dtype='datetime64[ns]', freq='MS')
# 更多date_range()方法的使用请看Pandas datetime学习笔记
有的时候时间序列是按每小时显示统计的，但是我们想将统计频率转换成按天来统计，这个时候可以使用时间序列的resample方法，该方法非常强大，不仅仅支持高频率的数据聚合到低频率（降采样），也支持低频率转化到高频率统计（升采样）：
In[]: dates = pd.date_range('2018-1-1', '2018-1-2 23:00:00', freq = 'H')
In[]: len(dates)
Out[]: 48
In[]: ts = Series(np.arange(len(dates)), index = dates)
In[]: ts.size
Out[]: 48
In[]: ts.head(5)
Out[]:
2018-01-01 00:00:00 0
2018-01-01 01:00:00 1
2018-01-01 02:00:00 2
2018-01-01 03:00:00 3
2018-01-01 04:00:00 4
Freq: H, dtype: int64
In[]: ts.tail(5)
Out[]:
2018-01-02 19:00:00 43
2018-01-02 20:00:00 44
2018-01-02 21:00:00 45
2018-01-02 22:00:00 46
2018-01-02 23:00:00 47
Freq: H, dtype: int64
以上代码中，我们创建了以每小时为频率的时间序列.
如果我们将以上数据转换为按每天的数据统计：
In[]: ts.resample('D').sum()
Out[]:
2018-01-01 276
2018-01-02 852
Freq: D, dtype: int64
# 先使用resample('D')方法指定了按天统计，接着使用sum方法求和了按天的所有数据（0-23相加，24-47相加）
# 当把底频率的数据转换成高频率的数据时，默认情况下Pandas会引入NaN值，因为没办法从低频率的数据计算出高频率的数据，但可以通过fill_method参数指定插入值的方式：
In[]: ts.resample('D').mean().resample('H').mean()
Out[]:
2018-01-01 00:00:00 11.5
2018-01-01 01:00:00 NaN
2018-01-01 02:00:00 NaN
2018-01-01 03:00:00 NaN
2018-01-01 04:00:00 NaN
2018-01-01 05:00:00 NaN
2018-01-01 06:00:00 NaN
2018-01-01 07:00:00 NaN
2018-01-01 08:00:00 NaN
2018-01-01 09:00:00 NaN
2018-01-01 10:00:00 NaN
2018-01-01 11:00:00 NaN
2018-01-01 12:00:00 NaN
2018-01-01 13:00:00 NaN
2018-01-01 14:00:00 NaN
2018-01-01 15:00:00 NaN
2018-01-01 16:00:00 NaN
2018-01-01 17:00:00 NaN
2018-01-01 18:00:00 NaN
2018-01-01 19:00:00 NaN
2018-01-01 20:00:00 NaN
2018-01-01 21:00:00 NaN
2018-01-01 22:00:00 NaN
2018-01-01 23:00:00 NaN
2018-01-02 00:00:00 35.5
Freq: H, dtype: float64
In[]: ts.resample('D').mean().resample('H').ffill()
# .fill()代表用前面的值替代NaN值
Out[]:
2018-01-01 00:00:00 11.5
2018-01-01 01:00:00 11.5
2018-01-01 02:00:00 11.5
2018-01-01 03:00:00 11.5
2018-01-01 04:00:00 11.5
2018-01-01 05:00:00 11.5
2018-01-01 06:00:00 11.5
2018-01-01 07:00:00 11.5
2018-01-01 08:00:00 11.5
2018-01-01 09:00:00 11.5
2018-01-01 10:00:00 11.5
2018-01-01 11:00:00 11.5
2018-01-01 12:00:00 11.5
2018-01-01 13:00:00 11.5
2018-01-01 14:00:00 11.5
2018-01-01 15:00:00 11.5
2018-01-01 16:00:00 11.5
2018-01-01 17:00:00 11.5
2018-01-01 18:00:00 11.5
2018-01-01 19:00:00 11.5
2018-01-01 20:00:00 11.5
2018-01-01 21:00:00 11.5
2018-01-01 22:00:00 11.5
2018-01-01 23:00:00 11.5
2018-01-02 00:00:00 35.5
Freq: H, dtype: float64
网友评论