dask.dataframe.from_bcolz（）立即开始处理

我想知道为什么dd.from_bcolz（）在被调用时立即开始进行一些处理（当N列增加并且有字符串类型的列时，处理量会增加很多）

而dd.read_hdf（）在调用时不会进行太多处理，但只有在使用dask.dataframe时才进行处理-然后read_hdf（）逐块读取并处理HDF5

我喜欢read_hdf现在的工作方式，唯一的问题是hdf5表不能有超过1200列，dataframe不支持数组的列。hdf5格式毕竟不是基于列的

In [1]: import dask.dataframe as dd

In [2]: import pandas as pd

In [3]: import bcolz, random

In [4]: import numpy as np

In [5]: N = int(1e7)

In [6]: int_col = np.linspace(0, 1, N)

In [7]: ct_disk = bcolz.fromiter(((i,i) for i in range(N)), dtype="i8,i8",\
   ...:                          count=N, rootdir=r'/mnt/nfs/ct_.bcolz')

In [8]: for i in range(10): ct_disk.addcol(int_col)

In [9]: import dask.dataframe as dd

In [10]: %time dd.from_bcolz(r'/mnt/nfs/ct_.bcolz', chunksize=1000000, lock=False)
CPU times: user 8 ms, sys: 16 ms, total: 24 ms
Wall time: 32.6 ms
Out[10]: dd.DataFrame<from_bc..., npartitions=10, divisions=(0, 1000000, 2000000, ..., 9000000, 9999999)>

In [11]: str_col= [''.join(random.choice('ABCD1234') for _ in range(5)) for i in range(int(N/10))]*10

In [12]: ct_disk.addcol(str_col, dtype='S5')

In [13]: %time dd.from_bcolz(r'/mnt/nfs/ct_.bcolz', chunksize=1000000, lock=False)
CPU times: user 2.36 s, sys: 56 ms, total: 2.42 s
Wall time: 2.44 s
Out[13]: dd.DataFrame<from_bc..., npartitions=10, divisions=(0, 1000000, 2000000, ..., 9000000, 9999999)>

In [14]: for i in range(10): ct_disk.addcol(str_col, dtype='S5')

In [15]: %time dd.from_bcolz(r'/mnt/nfs/ct_.bcolz', chunksize=1000000, lock=False)
CPU times: user 25.3 s, sys: 511 ms, total: 25.8 s
Wall time: 25.9 s
Out[15]: dd.DataFrame<from_bc..., npartitions=10, divisions=(0, 1000000, 2000000, ..., 9000000, 9999999)>

[1]中的

：将dask.dataframe作为dd导入
在[2]中：导入熊猫作为pd
在[3]中：导入bcolz，随机
在[4]中：将numpy作为np导入
In[5]：N=int（1e7）
[6]中：int_col=np.linspace（0，1，N）
在[7]中：ct_disk=bcolz.fromiter（（i，i）表示范围（N）中的i），dtype=“i8，i8”\
…：count=N，rootdir=r'/mnt/nfs/ct_uz.bcolz'）
In[8]：对于范围（10）中的i:ct\u disk.addcol（int\u col）
在[9]中：导入dask.dataframe作为dd
在[10]中：%time dd.from_bcolz（r'/mnt/nfs/ct_.bcolz'，chunksize=1000000，lock=False）
CPU时间：用户8毫秒，系统16毫秒，总计24毫秒
壁时间：32.6毫秒
Out[10]：dd.DataFrame
[11]中：str_col=[''.join（random.choice（'ABCD1234'）表示范围（5）中的u），而i表示范围（int（N/10））]*10
In[12]：ct_disk.addcol（str_col，dtype='S5'）
在[13]中：%time dd.from_bcolz（r'/mnt/nfs/ct_.bcolz'，chunksize=1000000，lock=False）
CPU时间：用户2.36秒，系统56毫秒，总计2.42秒
壁时间：2.44秒
Out[13]：dd.DataFrame
In[14]：对于范围（10）中的i:ct_disk.addcol（str_col，dtype='S5'））
在[15]中：%time dd.from_bcolz（r'/mnt/nfs/ct_bcolz'，chunksize=1000000，lock=False）
CPU时间：用户25.3秒，系统511毫秒，总计25.8秒
壁时间：25.9秒
Out[15]：dd.DataFrame

---

当N（nrows）增长时，情况会变得更糟。

看起来就像今天从_bcolz编写的

自动对对象数据类型列进行分类一样。因此，它对所有对象数据类型列进行完全读取，并对它们调用
unique
。您可以通过设置
categorize=False
来关闭此功能

如果您认为应该更改此行为，请提出github问题。
它看起来像是今天从\u bcolz编写的
自动对对象数据类型列进行分类。因此，它对所有对象数据类型列进行完全读取，并对它们调用
unique
。您可以通过设置
categorize=False
来关闭此功能

如果您认为应该更改此行为，请提出github问题