如何重写此函数以实现OrderedDict？

Question

我有一个函数，它可以把一个XML文件简单地解析成一个字典。

不过，Python里的字典是没有顺序的，所以我不能像想的那样顺序遍历这些节点。

我该怎么改才能输出一个有顺序的字典，这样在用for循环的时候能保持节点的原始顺序呢？

def simplexml_load_file(file):
    import collections
    from lxml import etree

    tree = etree.parse(file)
    root = tree.getroot()

    def xml_to_item(el):
        item = None
        if el.text:
            item = el.text
        child_dicts = collections.defaultdict(list)
        for child in el.getchildren():
            child_dicts[child.tag].append(xml_to_item(child))
        return dict(child_dicts) or item

    def xml_to_dict(el):
        return {el.tag: xml_to_item(el)}

    return xml_to_dict(root)

x = simplexml_load_file('routines/test.xml')

print x

for y in x['root']:
    print y

输出结果：

{'root': {
    'a': ['1'],
    'aa': [{'b': [{'c': ['2']}, '2']}],
    'aaaa': [{'bb': ['4']}],
    'aaa': ['3'],
    'aaaaa': ['5']
}}

a
aa
aaaa
aaa
aaaaa

我该怎么使用collections.OrderedDict，才能确保节点的顺序是正确的呢？

这里有一个XML文件供参考：

<root>
    <a>1</a>
    <aa>
        <b>
            <c>2</c>
        </b>
        <b>2</b>
    </aa>
    <aaa>3</aaa>
    <aaaa>
        <bb>4</bb>
    </aaaa>
    <aaaaa>5</aaaaa>
</root>

Answer 1

在这里，有很多关于OrderedDict的实现方法，详细内容可以查看这个链接：如何按照插入顺序从字典中获取项目？

你可以通过复制其中一种实现方式，自己创建一个OrderedDict模块，用在自己的代码里。我猜测你之所以无法使用OrderedDict，是因为你使用的Python版本不支持。

你提问中一个有趣的点是可能需要defaultdict的功能。如果你需要这个功能，可以实现__missing__方法来达到你想要的效果。

Answer 2

martineau 提供的这个方法对我来说是有效的，但它在使用 DefaultDict 继承的 copy() 方法时会遇到一些问题。下面的方法可以解决这个缺陷：

class OrderedDefaultDict(OrderedDict):
    #Implementation as suggested by martineau

    def copy(self):
         return type(self)(self.default_factory, self)

请注意，这个实现并没有进行深拷贝，而对于默认字典来说，在大多数情况下，这似乎是更合适的做法。

Answer 3

你可以使用新的OrderedDict，这是在Python 2.7版本中加入到标准库的collections模块里的一个字典子类。实际上，你需要的是一个Ordered和defaultdict的组合，但这个组合并不存在——不过你可以通过继承OrderedDict来创建一个，下面的例子就说明了这一点：

^{✶ 如果你的Python版本没有OrderedDict，你可以使用Raymond Hettinger的适用于Py2.4的有序字典作为基础类。}

import collections

class OrderedDefaultdict(collections.OrderedDict):
    """ A defaultdict with OrderedDict as its base class. """

    def __init__(self, default_factory=None, *args, **kwargs):
        if not (default_factory is None or callable(default_factory)):
            raise TypeError('first argument must be callable or None')
        super(OrderedDefaultdict, self).__init__(*args, **kwargs)
        self.default_factory = default_factory  # called by __missing__()

    def __missing__(self, key):
        if self.default_factory is None:
            raise KeyError(key,)
        self[key] = value = self.default_factory()
        return value

    def __reduce__(self):  # Optional, for pickle support.
        args = (self.default_factory,) if self.default_factory else tuple()
        return self.__class__, args, None, None, iter(self.items())

    def __repr__(self):  # Optional.
        return '%s(%r, %r)' % (self.__class__.__name__, self.default_factory, self.items())

def simplexml_load_file(file):
    from lxml import etree

    tree = etree.parse(file)
    root = tree.getroot()

    def xml_to_item(el):
        item = el.text or None
        child_dicts = OrderedDefaultdict(list)
        for child in el.getchildren():
            child_dicts[child.tag].append(xml_to_item(child))
        return collections.OrderedDict(child_dicts) or item

    def xml_to_dict(el):
        return {el.tag: xml_to_item(el)}

    return xml_to_dict(root)

x = simplexml_load_file('routines/test.xml')
print(x)

for y in x['root']:
    print(y)

从你的测试XML文件生成的输出看起来是这样的：

{'root':
    OrderedDict(
        [('a', ['1']),
         ('aa', [OrderedDict([('b', [OrderedDict([('c', ['2'])]), '2'])])]),
         ('aaa', ['3']),
         ('aaaa', [OrderedDict([('bb', ['4'])])]),
         ('aaaaa', ['5'])
        ]
    )
}

a
aa
aaa
aaaa
aaaaa

我觉得这跟你想要的差不多。

小更新：

添加了一个__reduce__()方法，这样这个类的实例就可以正确地进行序列化和反序列化。虽然这个问题不需要这个方法，但在一个类似的问题中提到了。