在 Python (Django) 中基于 Django 查询集创建 JSON 的最快方法是什么。请注意，按照建议在模板中解析它 here不是一种选择。

背景是我创建了一个循环遍历树中所有节点的方法，但是在转换大约 300 个节点时已经非常慢了。我想到的第一个(可能也是最糟糕的)想法是以某种方式“手动”创建 json。请参阅下面的代码。

#! Solution 1 !!#
def quoteStr(input):
    return "\"" + smart_str(smart_unicode(input)) + "\""

def createJSONTreeDump(user, node, root=False, lastChild=False):
    q = "\""

    #open tag for object
    json = str("\n" + indent + "{" +
                  quoteStr("name") + ": " + quoteStr(node.name) + ",\n" +
                  quoteStr("id") + ": " + quoteStr(node.pk) + ",\n" +
                )

    childrenTag = "children"
    children = node.get_children()
    if children.count() > 0 :
        #create children array opening tag
        json += str(indent + quoteStr(childrenTag) + ": [")
        #for child in children:
        for idx, child in enumerate(children):
            if (idx + 1) == children.count():
                //recursive call
                json += createJSONTreeDump(user, child, False, True, layout)
            else:
                //recursive call
                json += createJSONTreeDump(user, child, False, False, layout)
        #add children closing tag
        json += "]\n"

    #closing tag for object
    if lastChild == False:
        #more children following, add ","
        json += indent + "},\n"
    else:
        #last child, do not add ","
        json += indent + "}\n"
    return json

要渲染的树结构是用 mptt 构建的树。 ，其中调用 .get_children() 返回一个节点的所有子节点。

模型看起来就这么简单，mptt 负责其他一切。

class Node(MPTTModel, ExtraManager):
    """
    Representation of a single node
    """ 
    name = models.CharField(max_length=200)
    parent = TreeForeignKey('self', null=True, blank=True, related_name='%(app_label)s_%(class)s_children')

预期的 JSON result在模板 var root = {{ jsonTree|safe }}

编辑: 基于 this回答我创建了以下代码(绝对是更好的代码)，但感觉只是稍微快了一点。

解决方案 2:

def serializable_object(node):
    "Recurse into tree to build a serializable object"
    obj = {'name': node.name, 'id': node.pk, 'children': []}
    for child in node.get_children():
        obj['children'].append(serializable_object(child))
    return obj

import json
jsonTree = json.dumps(serializable_object(nodeInstance))

解决方案 3:

def serializable_object_List_Comprehension(node):
    "Recurse into tree to build a serializable object"
    obj = {
        'name': node.name,
        'id': node.pk,
        'children': [serializable_object(ch) for ch in node.get_children()]
    }
    return obj

解决方案 4:

def recursive_node_to_dict(node):
    result = {
        'name': node.name, 'id': node.pk
    }
    children = [recursive_node_to_dict(c) for c in node.get_children()],
    if children is not None:
        result['children'] = children
    return result

from mptt.templatetags.mptt_tags import cache_tree_children
root_nodes = cache_tree_children(root.get_descendants())
dicts = []
for n in root_nodes:
    dicts.append(recursive_node_to_dict(root_nodes[0]))
    jsonTree = json.dumps(dicts, indent=4)

解决方案5(使用select_related到pre_fetch，但不确定是否正确使用)

def serializable_object_select_related(node):
    "Recurse into tree to build a serializable object, make use of select_related"
    obj = {'name': node.get_wbs_code(), 'wbsCode': node.get_wbs_code(), 'id': node.pk, 'level': node.level, 'position': node.position, 'children': []}
    for child in node.get_children().select_related():
        obj['children'].append(serializable_object(child))
    return obj

解决方案 6(改进的解决方案 4，使用子节点的缓存):

def recursive_node_to_dict(node):
    return {
        'name': node.name, 'id': node.pk,
         # Notice the use of node._cached_children instead of node.get_children()
        'children' : [recursive_node_to_dict(c) for c in node._cached_children]
    }

调用方式:

from mptt.templatetags.mptt_tags import cache_tree_children
subTrees = cache_tree_children(root.get_descendants(include_self=True))
subTreeDicts = []
for subTree in subTrees:
    subTree = recursive_node_to_dict(subTree)
    subTreeDicts.append(subTree)
jsonTree = json.dumps(subTreeDicts, indent=4)
#optional clean up, remove the [ ] at the beginning and the end, its needed for D3.js
jsonTree = jsonTree[1:len(jsonTree)]
jsonTree = jsonTree[:len(jsonTree)-1]

您可以在下面看到分析结果，按照 MuMind 的建议使用 cProfile 创建，设置 Django View 以启动独立方法 profileJSON()，然后调用不同的解决方案来创建 JSON 输出。

def startProfileJSON(request):
    print "startProfileJSON"
    import cProfile
    cProfile.runctx('profileJSON()', globals=globals(), locals=locals())
    print "endProfileJSON"

结果:

解决方案 1: 3350347 次函数调用(3130372 次原始调用)在 4.969 秒内 (details)

解决方案 2: 2533705 次函数调用(2354516 次原始调用)在 3.630 秒内 (details)

解决方案 3: 2533621 次函数调用(2354441 次原始调用)在 3.684 秒内 (details)

解决方案 4: 2812725 次函数调用(2466028 次原始调用)在 3.840 秒内 (details)

解决方案 5: 2536504 次函数调用(2357256 次原始调用)在 3.779 秒内 (details)

解决方案 6(改进的解决方案 4): 2593122 次函数调用(2299165 次原始调用)在 3.663 秒内 (details)

讨论:

解决方案 1:自己的编码实现。坏主意

解决方案 2 + 3:目前最快，但仍然非常缓慢

解决方案 4:缓存子元素看起来很有希望，但性能相似，并且当前生成无效的 json，因为子元素被放入双 []:

"children": [[]] instead of "children": []

解决方案 5:使用 select_related 并没有什么不同，但可能以错误的方式使用，因为一个节点总是有一个 ForeignKey 到它的父节点，我们正在从根解析到子节点。

更新:解决方案 6:对我来说，它看起来是最干净的解决方案，使用子节点缓存。但只执行类似于解决方案 2 + 3。这对我来说很奇怪。

还有更多关于性能改进的想法吗？

最佳答案

我怀疑到目前为止最大的减速是每个节点执行 1 次数据库查询。与数据库的数百次往返相比，json 呈现微不足道。

您应该在每个节点上缓存子节点，以便可以一次完成所有查询。 django-mptt 有一个 cache_tree_children()您可以使用的函数。

import json
from mptt.templatetags.mptt_tags import cache_tree_children

def recursive_node_to_dict(node):
    result = {
        'id': node.pk,
        'name': node.name,
    }
    children = [recursive_node_to_dict(c) for c in node.get_children()]
    if children:
        result['children'] = children
    return result

root_nodes = cache_tree_children(Node.objects.all())
dicts = []
for n in root_nodes:
    dicts.append(recursive_node_to_dict(n))

print json.dumps(dicts, indent=4)

自定义 json 编码虽然在某些情况下可能会稍微加快速度，但我强烈反对这样做，因为它会包含大量代码，而且很容易获得 very wrong .

关于python - 使用 mptt 在 Python/Django 中创建 JSON 以反射(reflect)树结构的最快方法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12556268/