Python Pandas学习笔记。 vol4. 20190317

阿里云2000元红包!本站用户参与享受九折优惠!

本文章仅供我本人学习记录使用,不允许任何转载及引用。特此声明。


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

https://www.jianshu.com/p/736b2587534e

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论