在Pandas中查询HDF5

Question

我有以下数据(18,619,211行)存储为hdf5文件中的pandas dataframe对象:

             date    id2         w
id                              
100010 1980-03-31   10401  0.000839
100010 1980-03-31   10604  0.020140
100010 1980-03-31   12490  0.026149
100010 1980-03-31   13047  0.033560
100010 1980-03-31   13303  0.001657

id索引在哪里,其他是列.date是np.datetime64.我需要执行这样的查询(代码当然不起作用):

db=pd.HDFStore('database.h5')
data=db.select('df', where='id==id_i & date>bgdt & date<endt')

注意id_i, bgdt, endt是所有变量,而不是实际值,需要在循环中传递.例如:

dates 是一个Pandas Period索引或时间戳索引,无论哪种方式,我都可以互相转换.

dates=['1990-01', 1990-04','1990-09',......]  

id_list 是一个ID列表

id_list=[100010, 100011,1000012,.......]

循环看起来像这样(我做循环的原因是因为数据很大,我有其他数据集在同一时间查询然后执行一些操作)

db=pd.HDFStore('database.h5')
for id_i in id_list:
    for date in dates:
        bgdt=date-1 (move to previous month)
        endt=date-60 (previous 60 month)
        data=db.select('df', where='index==id_i & date>bgdt & date<endt')
        ......

这个问题有两个部分:

• 我不知道如何在同一时间查询索引和列.pandas中的doc显示了如何基于索引条件或列条件进行查询,但没有关于如何在相同时间内基于它们进行查询的示例.
  • (顺便说一句,这在Pandas文档中很常见.文档通常显示非常简单的事情,比如如何做'A',或者如何做'B',但不是如何做'A'和'B'.示例是query在MultiIndex pandas数据帧上使用.文档显示基于level=0OR level=1,但没有关于如何在相同时间内执行两个操作的示例.)
• 我不知道如何将三个变量传递id_i, bgdt, endt给查询.我知道如何通过使用%s,但不是全部通过.
  • 我也对datetime数据类型有点困惑.似乎有好几个日期时间的:datetime.datetime,numpy.datetime64,pandas.Period.我主要处理月度数据,因此pandas.Period最有用的数据.但我无法轻松转换时间戳的列(而不是索引)(从原始数据中解析时的Pandas的默认日期类型).是否有任何数据类型只是一个'日期',而不是时间戳,而不是句号,但只是一个只有年,月和日的简单日期？

很麻烦,但我真的很喜欢python和pandas(我正在努力将我的工作流程从SAS转移到Python).任何帮助将不胜感激!

Answer 1

这里是查询非索引列的文档.

创建测试数据.目前尚不清楚如何构造原始帧,例如它的唯一数据和范围,因此我创建了一个样本,具有10M行,以及具有id列的多级日期范围.

In [60]: np.random.seed(1234)

In [62]: pd.set_option('display.max_rows',20)

In [63]: index = pd.MultiIndex.from_product([np.arange(10000,11000),pd.date_range('19800101',periods=10000)],names=['id','date'])

In [67]: df = DataFrame(dict(id2=np.random.randint(0,1000,size=len(index)),w=np.random.randn(len(index))),index=index).reset_index().set_index(['id','date'])

In [68]: df
Out[68]: 
                  id2         w
id    date                     
10000 1980-01-01  712  0.371372
      1980-01-02  718 -1.255708
      1980-01-03  581 -1.182727
      1980-01-04  202 -0.947432
      1980-01-05  493 -0.125346
      1980-01-06  752  0.380210
      1980-01-07  435 -0.444139
      1980-01-08  128 -1.885230
      1980-01-09  425  1.603619
      1980-01-10  449  0.103737
...               ...       ...
10999 2007-05-09    8  0.624532
      2007-05-10  669  0.268340
      2007-05-11  918  0.134816
      2007-05-12  979 -0.769406
      2007-05-13  969 -0.242123
      2007-05-14  950 -0.347884
      2007-05-15   49 -1.284825
      2007-05-16  922 -1.313928
      2007-05-17  347 -0.521352
      2007-05-18  353  0.189717

[10000000 rows x 2 columns]

将数据写入磁盘,显示如何创建数据列(请注意,索引可自动查询,这也允许id2可查询).这事实上等同于做.这需要打开和关闭商店(你可以通过打开商店,追加和关闭来完成同样的事情).

为了查询列,它必须是数据列或帧的索引.

In [70]: df.to_hdf('test.h5','df',mode='w',data_columns=['id2'],format='table')

In [71]: !ls -ltr test.h5
-rw-rw-r-- 1 jreback users 430540284 May 26 17:16 test.h5

查询

In [80]: ids=[10101,10898]

In [81]: start_date='20010101'

In [82]: end_date='20010301'

您可以将日期指定为字符串(内联或变量;您也可以指定类似对象的时间戳)

In [83]: pd.read_hdf('test.h5','df',where='date>start_date & date<end_date')
Out[83]: 
                  id2         w
id    date                     
10000 2001-01-02  972 -0.146107
      2001-01-03  954  1.420412
      2001-01-04  567  1.077633
      2001-01-05   87 -0.042838
      2001-01-06   79 -1.791228
      2001-01-07  744  1.110478
      2001-01-08  237 -0.846086
      2001-01-09  998 -0.696369
      2001-01-10  266 -0.595555
      2001-01-11  206 -0.294633
...               ...       ...
10999 2001-02-19  616 -0.745068
      2001-02-20  577 -1.474748
      2001-02-21  990 -1.276891
      2001-02-22  939 -1.369558
      2001-02-23  621 -0.214365
      2001-02-24  396 -0.142100
      2001-02-25  492 -0.204930
      2001-02-26  478  1.839291
      2001-02-27  688  0.291504
      2001-02-28  356 -1.987554

[58000 rows x 2 columns]

您可以使用内嵌列表

In [84]: pd.read_hdf('test.h5','df',where='date>start_date & date<end_date & id=ids')
Out[84]: 
                  id2         w
id    date                     
10101 2001-01-02  722  1.620553
      2001-01-03  849 -0.603468
      2001-01-04  635 -1.419072
      2001-01-05  331  0.521634
      2001-01-06  730  0.008830
      2001-01-07  706 -1.006412
      2001-01-08   59  1.380005
      2001-01-09  689  0.017830
      2001-01-10  788 -3.090800
      2001-01-11  704 -1.491824
...               ...       ...
10898 2001-02-19  530 -1.031167
      2001-02-20  652 -0.019266
      2001-02-21  472  0.638266
      2001-02-22  540 -1.827251
      2001-02-23  654 -1.020140
      2001-02-24  328 -0.477425
      2001-02-25  871 -0.892684
      2001-02-26  166  0.894118
      2001-02-27  806  0.648240
      2001-02-28  824 -1.051539

[116 rows x 2 columns]

您还可以指定布尔表达式

In [85]: pd.read_hdf('test.h5','df',where='date>start_date & date<end_date & id=ids & id2>500 & id2<600')
Out[85]: 
                  id2         w
id    date                     
10101 2001-01-12  534 -0.220692
      2001-01-14  596 -2.225393
      2001-01-16  596  0.956239
      2001-01-30  513 -2.528996
      2001-02-01  572 -1.877398
      2001-02-13  569 -0.940748
      2001-02-14  541  1.035619
      2001-02-21  571 -0.116547
10898 2001-01-16  591  0.082564
      2001-02-06  586  0.470872
      2001-02-10  531 -0.536194
      2001-02-16  586  0.949947
      2001-02-19  530 -1.031167
      2001-02-22  540 -1.827251

要回答你的实际问题,我会这样做(他们的信息真的不够,但我会给出一些合理的期望):

• 除非您有非常少量的绝对查询,否则不要循环查询
• 尽可能将最大的块读入内存.通常,这是通过选择所需的最大数据范围来完成的,即使您选择了比实际需要的更多数据.
• 然后使用内存表达式进行子选择,这通常会快几个数量级.
• List元素总共限制为大约30个元素(这是PyTables方面当前的实现限制).如果你指定更多,它将起作用,但会发生什么是你将读入大量数据,然后它将被重新索引(内存中).所以用户需要意识到这一点.

例如,假设您有1000个唯一ID,每个10000个日期,如我的示例所示.您想要选择其中200个,日期范围为1000.

所以在这种情况下我只需选择日期然后进行内存中的比较,如下所示:

df = pd.read_hdf('test.h5','df',where='date=>global_start_date & date<=global_end_date')
df[df.isin(list_of_ids)]

您也可能有每个ID更改的日期.所以他们使用一个id列表进行分块.

像这样的东西:

output = []
for i in len(list_of_ids) % 30:
    ids = list_of_ids[i:(i+30)]
    start_date = get_start_date_for_these_ids (global)
    end_date = get_end_date_for_these_ids (global)
    where = 'id=ids & start_date>=start_date & end_date<=end_date'
    df = pd.read_hdf('test.h5','df',where=where)
    output.append(df)

 final_result = concat(output)

那么基本的想法是使用你想要的标准选择数据的超集,进行子选择以使其适合内存,但是你限制了你所做的查询的数量(例如,想象你最终选择了一行查询,如果你要查询18M次这是坏的).