2. 智能切分时间序列

  1. #  从hdf5文件crime.h5读取丹佛市的crimes数据集，输出列数据的数据类型和数据的前几行
  2.  In[44]: crime = pd.read_hdf('data/crime.h5', 'crime')
  3.          crime.dtypes
  4. Out[44]: OFFENSE_TYPE_ID              category
  5.          OFFENSE_CATEGORY_ID          category
  6.          REPORTED_DATE          datetime64[ns]
  7.          GEO_LON                       float64
  8.          GEO_LAT                       float64
  9.          NEIGHBORHOOD_ID              category
  10.          IS_CRIME                        int64
  11.          IS_TRAFFIC                      int64
  12.          dtype: object
  14.  In[45]: crime = crime.set_index('REPORTED_DATE')
  15.          crime.head()
  16. Out[45]:

2. 智能切分时间序列 - 图1

  1. #  注意到有三个类型列和一个Timestamp对象列，这些数据的数据类型在创建时就建立了对应的数据类型。
  2. #  这和csv文件非常不同，csv文件保存的只是字符串。
  3. #  由于前面已经将REPORTED_DATE设为了行索引，所以就可以进行智能Timestamp对象切分。
  4.  In[46]: pd.options.display.max_rows = 4
  5.  In[47]: crime.loc['2016-05-12 16:45:00']
  6. Out[47]:

2. 智能切分时间序列 - 图2

  1. #  可以进行时间部分匹配
  2.  In[48]: crime.loc['2016-05-12']
  3. Out[48]:

2. 智能切分时间序列 - 图3

  1. #  也可以选取一整月、一整年或某天的某小时
  2.  In[49]: crime.loc['2016-05'].shape
  3. Out[49]: (8012, 7)
  5.  In[50]: crime.loc['2016'].shape
  6. Out[50]: (91076, 7)
  8.  In[51]: crime.loc['2016-05-12 03'].shape
  9. Out[51]: (4, 7)
  1. #  也可以包含月的名字
  2.  In[52]: crime.loc['Dec 2015'].sort_index()
  3. Out[52]:

2. 智能切分时间序列 - 图4

  1. #  其它一些字符串的格式也可行
  2.  In[53]: crime.loc['2016 Sep, 15'].shape
  3. Out[53]: (252, 7)
  5.  In[54]: crime.loc['21st October 2014 05'].shape
  6. Out[54]: (4, 7)
  1. #  可以进行切片
  2.  In[55]: crime.loc['2015-3-4':'2016-1-1'].sort_index()
  3. Out[55]:

2. 智能切分时间序列 - 图5

  1. #  提供更为精确的时间
  2.  In[56]: crime.loc['2015-3-4 22':'2016-1-1 23:45:00'].sort_index()
  3. Out[56]:

2. 智能切分时间序列 - 图6

原理

  1. #  hdf5文件可以保存每一列的数据类型，可以极大减少内存的使用。
  2. #  在上面的例子中，三个列被存成了类型，而不是对象。存成对象的话，消耗的内存会变为之前的四倍。
  3.  In[57]: mem_cat = crime.memory_usage().sum()
  4.          mem_obj = crime.astype({'OFFENSE_TYPE_ID':'object', 
  5.                                  'OFFENSE_CATEGORY_ID':'object', 
  6.                                  'NEIGHBORHOOD_ID':'object'}).memory_usage(deep=True)\
  7.                                                     .sum()
  8.          mb = 2 ** 20
  9.          round(mem_cat / mb, 1), round(mem_obj / mb, 1)
  10. Out[57]: (29.4, 122.7)
  1. #  为了用日期智能选取和切分，行索引必须包含日期。
  2. #  在前面的例子中，REPORTED_DATE被设成了行索引，行索引从而成了DatetimeIndex对象。
  3.  In[58]: crime.index[:2]
  4. Out[58]: DatetimeIndex(['2014-06-29 02:01:00', '2014-06-29 01:54:00'], dtype='datetime64[ns]', name='REPORTED_DATE', freq=None)

更多

  1. #  对行索引进行排序，可以极大地提高速度
  2.  In[59]: %timeit crime.loc['2015-3-4':'2016-1-1']
  3.          42.4 ms ± 865 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
  5.  In[60]: crime_sort = crime.sort_index()
  7.  In[61]: %timeit crime_sort.loc['2015-3-4':'2016-1-1']
  8.          840 µs ± 32.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
  10.  In[62]: pd.options.display.max_rows = 60