从数据库加载大数据并转换为 JSON 时如何提高性能

Question

我编写了一个处理财务数据处理的 Djano 应用程序。 我必须从 MySQL 表中加载大数据（超过 1000000 条记录），并将记录转换为 django 视图中的 JSON 数据，如下所示：

trades = MtgoxTrade.objects.all()
data = []
for trade in trades:
            js = dict()
            js['time']= trade.time
            js['price']= trade.price
            js['amount']= trade.amount
            js['type']= trade.type
            data.append(js)
return data

问题是FOR循环很慢（200000条记录需要9秒以上），有没有什么有效的方法可以在Python中将DB记录转换为JSON格式数据？

更新：我已根据 Mike Housky 在我的 ENV(ActivePython2.7,Win7) 中的回答运行代码，代码更改为：

def create_data(n):
    from api.models import MtgoxTrade
    result = MtgoxTrade.objects.all()

    return result


  Build ............ 0.330999851227
  For loop ......... 7.98400020599
  List Comp. ....... 0.457000017166
  Ratio ............ 0.0572394796312
  For loop 2 ....... 0.381999969482
  Ratio ............ 0.047845686326

你会发现 for 循环大约需要 8 秒！如果我注释掉 For 循环，那么 List Comp 也需要这样的时间：

Times:
  Build ............ 0.343000173569
  List Comp. ....... 7.57099986076
  For loop 2 ....... 0.375999927521

我的新问题是for循环是否会触及数据库？但我没有看到任何数据库访问日志。好奇怪！

Answer 1

这里有几个提示/可以尝试的方法。

由于您最终需要从查询集中生成 JSON 字符串，因此请使用 django 的内置 serializers：

from django.core import serializers

data = serializers.serialize("json", 
                             MtgoxTrade.objects.all(), 
                             fields=('time','price','amount','type'))

您可以使用ujson 或simplejson 模块加快序列化速度。请参阅SERIALIZATION_MODULES 设置。

另外，不要从记录中获取所有字段值，而是明确并仅获取您需要序列化的内容：

MtgoxTrade.objects.all().values('time','price','amount','type')

另外，您可能想使用查询集的iterator() 方法：

...对于返回大量对象的查询集 只需要访问一次，这可以带来更好的性能和 显着减少内存...

此外，您可以将庞大的查询集拆分为多个批次，请参阅：Batch querysets。

另见：

• Why is iterating through a large Django QuerySet consuming massive amounts of memory?
• Memory efficient Django Queryset Iterator
• django: control json serialization

Answer 2

您可以使用列表解析，因为它可以防止许多 dict() 和 append() 调用：

trades = MtgoxTrade.objects.all()
data = [{'time': trade.time, 'price': trade.price, 'amount': trade.amount, 'type': trade.type}
        for trade in trades]
return data

函数调用在 Python 中代价高昂，因此您应该避免在慢循环中使用它们。

Answer 3

此答案支持 Simeon Visser 的观察。我运行了以下代码：

import gc, random, time
if "xrange" not in dir(__builtins__):
    xrange = range

class DataObject(object):
    def __init__(self, time, price, amount, type):
        self.time = time
        self.price = price
        self.amount = amount
        self.type = type

def create_data(n):
    result = []
    for index in xrange(n):
        s = str(index);
        result.append(DataObject("T"+s, "P"+s, "A"+s, "ty"+s))
    return result

def convert1(trades):
    data = []
    for trade in trades:
                js = dict()
                js['time']= trade.time
                js['price']= trade.price
                js['amount']= trade.amount
                js['type']= trade.type
                data.append(js)
    return data

def convert2(trades):
    data = [{'time': trade.time, 'price': trade.price, 'amount': trade.amount, 'type': trade.type}
        for trade in trades]
    return data

def convert3(trades):
    ndata = len(trades)
    data = ndata*[None]
    for index in xrange(ndata):
        t = trades[index]
        js = dict()
        js['time']= t.time
        js['price']= t.price
        js['amount']= t.amount
        js['type']= t.type
        #js = {"time" : t.time, "price" : t.price, "amount" : t.amount, "type" : t.type}
    return data

def main(n=1000000):

    t0s = time.time()
    trades = create_data(n);
    t0f = time.time()
    t0 = t0f - t0s

    gc.disable()

    t1s = time.time()
    jtrades1 = convert1(trades)
    t1f = time.time()
    t1 = t1f - t1s

    t2s = time.time()
    jtrades2 = convert2(trades)
    t2f = time.time()
    t2 = t2f - t2s

    t3s = time.time()
    jtrades3 = convert3(trades)
    t3f = time.time()
    t3 = t3f - t3s

    gc.enable()

    print ("Times:")
    print ("  Build ............ " + str(t0))
    print ("  For loop ......... " + str(t1))
    print ("  List Comp. ....... " + str(t2))
    print ("  Ratio ............ " + str(t2/t1))
    print ("  For loop 2 ....... " + str(t3))
    print ("  Ratio ............ " + str(t3/t1))

main()

在 Win7、Core 2 Duo 3.0GHz 上的结果： Python 2.7.3：

Times:
  Build ............ 2.95600008965
  For loop ......... 0.699999809265
  List Comp. ....... 0.512000083923
  Ratio ............ 0.731428890618
  For loop 2 ....... 0.609999895096
  Ratio ............ 0.871428659011

Python 3.3.0：

Times:
  Build ............ 3.4320058822631836
  For loop ......... 1.0200011730194092
  List Comp. ....... 0.7500009536743164
  Ratio ............ 0.7352942070195492
  For loop 2 ....... 0.9500019550323486
  Ratio ............ 0.9313733946208623

即使禁用 GC，这些也会有所不同（启用 GC 时差异更大，但结果大致相同）。第三个转换时间表明，节省的时间中有相当大的一部分来自于不调用 .append() 一百万次。

忽略“For 循环 2”的次数。这个版本有一个错误，我现在没有时间修复它。

Answer 4

首先，您必须检查从数据库或循环内部获取数据时是否发生性能损失。

没有真正的选择可以显着加快速度 - 也没有使用上面提到的列表推导。

但是，Python 2 和 3 之间的性能存在巨大差异。

一个简单的基准测试告诉我，使用 Python 3.3 的 for 循环大约快 2.5 倍（使用一些简单的基准测试，如下所示）：

import time

ts = time.time()
data = list()
for i in range(1000000):
    d = {}
    d['a'] = 1
    d['b'] = 2
    d['c'] = 3
    d['d'] = 4
    d['a'] = 5
    data.append(d)

print(time.time() - ts)



/opt/python-3.3.0/bin/python3 foo2.py 
0.5906929969787598

python2.6 foo2.py 
1.74390792847

python2.7 foo2.py 
0.673550128937

您还会注意到 Python 2.6 和 2.7 之间存在显着的性能差异。

Answer 5

我认为尝试对数据库进行原始查询是值得的，因为模型会将大量额外的样板代码放入字段中（我相信字段是属性），并且就像前面提到的函数调用一样昂贵。请参阅documentation，页面底部有一个使用 dictfetchall 的示例，这似乎是您所追求的。

Answer 6

您可能想查看values method。它将返回一个可迭代的 dicts 而不是模型对象，因此您不必创建很多中间数据结构。您的代码可以简化为

return MtgoxTrade.objects.values('time', 'price', 'amount', 'type')