如果您的数据集在1到20GB之间，那么您应该使用具有48GB RAM的工作站。然后Pandas可以将整个数据集保存在RAM中。我知道这不是你想要的答案，但是在一个有4GB内存的笔记本电脑上进行科学计算是不合理的。

我发现这一点有点晚，但我也处理过类似的问题(抵押贷款提前支付模型)。我的解决方案是跳过pandas HDFStore层，直接使用pytable。在最终文件中，我将每一列保存为单独的HDF5数组。

我的基本工作流程是首先从数据库中获得一个CSV文件。我把它压缩了，所以它不那么大。然后我将其转换为一个面向行的HDF5文件，方法是在python中遍历它，将每一行转换为真正的数据类型，并将其写入HDF5文件。这需要几十分钟，但它不使用任何内存，因为它只是逐行操作。然后我将面向行的HDF5文件“转置”为面向列的HDF5文件。

表的转置是这样的:

def transpose_table(h_in, table_path, h_out, group_name="data", group_path="/"):
    # Get a reference to the input data.
    tb = h_in.getNode(table_path)
    # Create the output group to hold the columns.
    grp = h_out.createGroup(group_path, group_name, filters=tables.Filters(complevel=1))
    for col_name in tb.colnames:
        logger.debug("Processing %s", col_name)
        # Get the data.
        col_data = tb.col(col_name)
        # Create the output array.
        arr = h_out.createCArray(grp,
                                 col_name,
                                 tables.Atom.from_dtype(col_data.dtype),
                                 col_data.shape)
        # Store the data.
        arr[:] = col_data
    h_out.flush()

然后读取它看起来是这样的:

def read_hdf5(hdf5_path, group_path="/data", columns=None):
    """Read a transposed data set from a HDF5 file."""
    if isinstance(hdf5_path, tables.file.File):
        hf = hdf5_path
    else:
        hf = tables.openFile(hdf5_path)

    grp = hf.getNode(group_path)
    if columns is None:
        data = [(child.name, child[:]) for child in grp]
    else:
        data = [(child.name, child[:]) for child in grp if child.name in columns]

    # Convert any float32 columns to float64 for processing.
    for i in range(len(data)):
        name, vec = data[i]
        if vec.dtype == np.float32:
            data[i] = (name, vec.astype(np.float64))

    if not isinstance(hdf5_path, tables.file.File):
        hf.close()
    return pd.DataFrame.from_items(data)

现在，我通常在内存很大的机器上运行这个程序，所以我可能对内存使用不够小心。例如，默认情况下，load操作读取整个数据集。

这通常适用于我，但它有点笨重，我不能使用华丽的pytables魔法。

编辑:与pytables默认的记录数组相比，这种方法的真正优势在于，我可以使用h5r将数据加载到R中，而h5r不能处理表。或者，至少，我无法让它加载异构表。

如果您的数据集在1到20GB之间，那么您应该使用具有48GB RAM的工作站。然后Pandas可以将整个数据集保存在RAM中。我知道这不是你想要的答案，但是在一个有4GB内存的笔记本电脑上进行科学计算是不合理的。

值得一提的是，雷， 这是一个分布式计算框架，它以分布式的方式对pandas有自己的实现。

只需替换pandas导入，代码应该像这样工作:

# import pandas as pd
import ray.dataframe as pd

# use pd as usual

详情请点击此处:

https://rise.cs.berkeley.edu/blog/pandas-on-ray/

更新: 处理熊猫分布的部分，已经提取到modin项目。

现在正确的用法是:

# import pandas as pd
import modin.pandas as pd

这就是pymongo的情况。我还在python中使用sql server, sqlite, HDF, ORM (SQLAlchemy)进行了原型设计。首先，pymongo是一个基于文档的DB，所以每个人都是一个文档(属性字典)。很多人组成一个集合，你可以有很多集合(人，股票市场，收入)。

pd。注意:我在read_csv中使用chunksize来保持5到10k的记录(如果socket更大，pymongo会丢弃socket)

aCollection.insert((a[1].to_dict() for a in df.iterrows()))

查询:gt = >…

pd.DataFrame(list(mongoCollection.find({'anAttribute':{'$gt':2887000, '$lt':2889000}})))

.find()返回一个迭代器，所以我通常使用ichunked来切成更小的迭代器。

因为我通常会将10个数据源粘贴在一起，那么join呢:

aJoinDF = pandas.DataFrame(list(mongoCollection.find({'anAttribute':{'$in':Att_Keys}})))

然后(在我的情况下，有时我必须agg对aJoinDF首先在它的“可合并”。)

df = pandas.merge(df, aJoinDF, on=aKey, how='left')

然后你可以通过下面的更新方法将新的信息写入你的主集合。(逻辑集合vs物理数据源)。

collection.update({primarykey:foo},{key:change})

对于较小的查找，只需反规范化。例如，文档中有代码，只需添加字段代码文本，并在创建文档时进行字典查找。

现在你已经有了一个很好的基于人的数据集，你可以在每个情况下释放你的逻辑，并创建更多的属性。最后，你可以把你的3到内存max关键指标读入pandas，并做枢轴/agg/数据探索。这适用于我的300万条记录的数字/大文本/类别/代码/浮动…

您还可以使用MongoDB内置的两种方法(MapReduce和聚合框架)。这里有更多关于聚合框架的信息，因为它似乎比MapReduce更简单，而且看起来很适合快速聚合工作。注意，我不需要定义字段或关系，并且可以向文档添加项。在快速变化的numpy, pandas, python工具集的当前状态下，MongoDB帮助我开始工作:)

我经常以这种方式使用数十gb的数据 例:我在磁盘上有一些表，我通过查询读取它们，创建数据，然后再追加回去。

值得一读文档，在这篇文章的后面，有一些关于如何存储数据的建议。

这些细节会影响你如何存储你的数据，比如: 尽可能多地描述细节;我可以帮你建立一个结构

Size of data, # of rows, columns, types of columns; are you appending rows, or just columns? What will typical operations look like. E.g. do a query on columns to select a bunch of rows and specific columns, then do an operation (in-memory), create new columns, save these. (Giving a toy example could enable us to offer more specific recommendations.) After that processing, then what do you do? Is step 2 ad hoc, or repeatable? Input flat files: how many, rough total size in Gb. How are these organized e.g. by records? Does each one contains different fields, or do they have some records per file with all of the fields in each file? Do you ever select subsets of rows (records) based on criteria (e.g. select the rows with field A > 5)? and then do something, or do you just select fields A, B, C with all of the records (and then do something)? Do you 'work on' all of your columns (in groups), or are there a good proportion that you may only use for reports (e.g. you want to keep the data around, but don't need to pull in that column explicity until final results time)?

解决方案

确保你至少安装了熊猫0.10.1。

逐块读取迭代文件和多个表查询。

由于pytables被优化为按行操作(这是您查询的对象)，因此我们将为每组字段创建一个表。通过这种方式，可以很容易地选择一小组字段(这将与一个大表一起工作，但这样做更有效……我想我可以在将来修复这个限制…这是更直观的): (以下是伪代码。)

import numpy as np
import pandas as pd

# create a store
store = pd.HDFStore('mystore.h5')

# this is the key to your storage:
#    this maps your fields to a specific group, and defines 
#    what you want to have as data_columns.
#    you might want to create a nice class wrapping this
#    (as you will want to have this map and its inversion)  
group_map = dict(
    A = dict(fields = ['field_1','field_2',.....], dc = ['field_1',....,'field_5']),
    B = dict(fields = ['field_10',......        ], dc = ['field_10']),
    .....
    REPORTING_ONLY = dict(fields = ['field_1000','field_1001',...], dc = []),

)

group_map_inverted = dict()
for g, v in group_map.items():
    group_map_inverted.update(dict([ (f,g) for f in v['fields'] ]))

读入文件并创建存储(本质上是做append_to_multiple所做的事情):

for f in files:
   # read in the file, additional options may be necessary here
   # the chunksize is not strictly necessary, you may be able to slurp each 
   # file into memory in which case just eliminate this part of the loop 
   # (you can also change chunksize if necessary)
   for chunk in pd.read_table(f, chunksize=50000):
       # we are going to append to each table by group
       # we are not going to create indexes at this time
       # but we *ARE* going to create (some) data_columns

       # figure out the field groupings
       for g, v in group_map.items():
             # create the frame for this group
             frame = chunk.reindex(columns = v['fields'], copy = False)    

             # append it
             store.append(g, frame, index=False, data_columns = v['dc'])

现在，文件中已经有了所有的表(实际上，如果您愿意，可以将它们存储在单独的文件中，您可能必须将文件名添加到group_map中，但这可能是不必要的)。

下面是获取列并创建新列的方法:

frame = store.select(group_that_I_want)
# you can optionally specify:
# columns = a list of the columns IN THAT GROUP (if you wanted to
#     select only say 3 out of the 20 columns in this sub-table)
# and a where clause if you want a subset of the rows

# do calculations on this frame
new_frame = cool_function_on_frame(frame)

# to 'add columns', create a new group (you probably want to
# limit the columns in this new_group to be only NEW ones
# (e.g. so you don't overlap from the other tables)
# add this info to the group_map
store.append(new_group, new_frame.reindex(columns = new_columns_created, copy = False), data_columns = new_columns_created)

当你准备好post_processing时:

# This may be a bit tricky; and depends what you are actually doing.
# I may need to modify this function to be a bit more general:
report_data = store.select_as_multiple([groups_1,groups_2,.....], where =['field_1>0', 'field_1000=foo'], selector = group_1)

关于data_columns，实际上不需要定义ANY data_columns;它们允许您基于列再选择行。例如:

store.select(group, where = ['field_1000=foo', 'field_1001>0'])

在最终报告生成阶段，它们可能是您最感兴趣的(本质上，数据列与其他列隔离，如果您定义很多，这可能会在一定程度上影响效率)。

你可能还想:

创建一个函数，该函数接受字段列表，在groups_map中查找组，然后选择这些组并连接结果，从而获得结果帧(这实际上是select_as_multiple所做的工作)。这种结构对你来说是相当透明的。 在某些数据列上建立索引(使行子集设置更快)。 启用压缩。

如果你有问题，请告诉我!