Python字典的优化使用

我有一个大的xml文件，需要将其转换为制表符分隔格式，如下所示

现在，我可以将每个块制作成一个单独的以制表符分隔的文件。现在我的挑战是创建一个包含所有数据的组合文件

为此，我考虑使用Python字典并在循环中存储数据，然后将该字典转换为文件。比如说,

dict[x] = {'c1':'x1'}
dict[x] = {'c2':'x2'}
dict[y] = {'c1':'y1'}
..................
..................

但是我害怕任何内存问题，因为我可能有上千个名字和上百列

有谁有更好的主意吗

XML格式

<item>
    <col>c1</col>
    <col>c2</col>
    <col>c3</col>
    <mh>
        <name>x</name>
        <val>x1</val>
        <val>x2</val>
        <val>x3</val>
    </mh>
    <mh>
        <name>y</name>
        <val>y1</val>
        <val>y2</val>
        <val>y3</val>
    </mh>
    <mh>
        <name>z</name>
        <val>z1</val>
        <val>z2</val>
        <val>z3</val>
    </mh>
</item>
<item>
    <col>c4</col>
    <col>c5</col>
    <mh>
        <name>x</name>
        <val>x4</val>
        <val>x5</val>
    </mh>
    <mh>
        <name>y</name>
        <val>y4</val>
        <val>y5</val>
    </mh>
    <mh>
        <name>z</name>
        <val>z4</val>
        <val>z5</val>
    </mh>
</item>

FILE1:
name    |   c1  |   c2  |   c3  
x       |   x1  |   x2  |   x3  
y       |   y1  |   y2  |   y3  
z       |   z1  |   z2  |   z3  
FILE2:
name    |   c4  |   c5
x       |   x4  |   x5
y       |   y4  |   y5
z       |   z4  |   z5

name    |   c1  |   c2  |   c3  |   c4  |   c5
x       |   x1  |   x2  |   x3  |   x4  |   x5
y       |   y1  |   y2  |   y3  |   y4  |   y5
z       |   z1  |   z2  |   z3  |   z4  |   z5

我的预期输出

<item>
    <col>c1</col>
    <col>c2</col>
    <col>c3</col>
    <mh>
        <name>x</name>
        <val>x1</val>
        <val>x2</val>
        <val>x3</val>
    </mh>
    <mh>
        <name>y</name>
        <val>y1</val>
        <val>y2</val>
        <val>y3</val>
    </mh>
    <mh>
        <name>z</name>
        <val>z1</val>
        <val>z2</val>
        <val>z3</val>
    </mh>
</item>
<item>
    <col>c4</col>
    <col>c5</col>
    <mh>
        <name>x</name>
        <val>x4</val>
        <val>x5</val>
    </mh>
    <mh>
        <name>y</name>
        <val>y4</val>
        <val>y5</val>
    </mh>
    <mh>
        <name>z</name>
        <val>z4</val>
        <val>z5</val>
    </mh>
</item>

FILE1:
name    |   c1  |   c2  |   c3  
x       |   x1  |   x2  |   x3  
y       |   y1  |   y2  |   y3  
z       |   z1  |   z2  |   z3  
FILE2:
name    |   c4  |   c5
x       |   x4  |   x5
y       |   y4  |   y5
z       |   z4  |   z5

name    |   c1  |   c2  |   c3  |   c4  |   c5
x       |   x1  |   x2  |   x3  |   x4  |   x5
y       |   y1  |   y2  |   y3  |   y4  |   y5
z       |   z1  |   z2  |   z3  |   z4  |   z5

---

您不需要一次完成整个转换。你可以一项一项地做。读入直到第一项末尾的所有XML，将其转换为制表符分隔的格式，然后写入文件。然后做下一个。这样，您的内存中就永远不会有超过一个项。

在我看来，问题的核心在于，在您读取XML文件的末尾之前，您无法写出第一行

有几种方法可以缓解这种情况，但我认为最突出的一种方法是，您的列真的是行吗？如果您的数据如下所示：

name    | x  | y  | z
c1      | x1 | y1 | z1
c2      | x2 | y2 | z2
c2      | x3 | y3 | z3
...

然后，只要到达一个块的末尾，就可以将行写入文件

但是，假设您必须具有指定的格式，并且内存确实是一个问题，那么您可以做一些事情来提供帮助：

使用列表，而不是口述

而不是：

d['x'] = { 'c1': 'x1', 'c2': 'x2', ... }
d['y'] = { 'c1': 'y1', 'c2': 'y2', ... }
...

拥有：

你不会重复很多次键，数据会反映出你想要如何写出它。节省的费用非常少，但是制作CSV会更容易

使用流式解析器

对于大多数解析器来说，您可能已经将完整的XML加载到内存中，这可能会使数据变得矮小，即使您再次保存所有数据。看一看流式XML解析器，它在文件中移动，并且只在内存中保留您正在查看的位

您可以注册有关在看到每个组件时要执行的操作的规则。例如，如果你看到

，你知道你必须清除你的列，并期待在不久的将来

。缺点是流式解析器通常更难使用

多次解析它

圣杯是永远不要将数据同时存储在内存中。您可以通过为每行解析一次文件来实现这一点

---

第一个解析将只写出

名称

行，第二个

x

行等。这可能会比较慢，但这意味着您在任何给定时间都在内存中存储绝对最小值。将其与流式解析器结合使用，您可以解析千兆字节（尽管速度较慢）。

如果您的数据（即使很大）适合内存，请继续。如果不是，请使用SQLite或HDF之类的中间存储。我不认为这是OP所要求的：/