6.4 增量式解析大型XML文件

问题

你想使用尽可能少的内存从一个超大的XML文档中提取数据。

解决方案

任何时候只要你遇到增量式的数据处理时，第一时间就应该想到迭代器和生成器。下面是一个很简单的函数，只使用很少的内存就能增量式的处理一个大型XML文件：

  1. from xml.etree.ElementTree import iterparse
  2.  
  3. def parse_and_remove(filename, path):
  4.     path_parts = path.split('/')
  5.     doc = iterparse(filename, ('start', 'end'))
  6.     # Skip the root element
  7.     next(doc)
  8.  
  9.     tag_stack = []
  10.     elem_stack = []
  11.     for event, elem in doc:
  12.         if event == 'start':
  13.             tag_stack.append(elem.tag)
  14.             elem_stack.append(elem)
  15.         elif event == 'end':
  16.             if tag_stack == path_parts:
  17.                 yield elem
  18.                 elem_stack[-2].remove(elem)
  19.             try:
  20.                 tag_stack.pop()
  21.                 elem_stack.pop()
  22.             except IndexError:
  23.                 pass

为了测试这个函数，你需要先有一个大型的XML文件。通常你可以在政府网站或公共数据网站上找到这样的文件。例如，你可以下载XML格式的芝加哥城市道路坑洼数据库。在写这本书的时候，下载文件已经包含超过100,000行数据，编码格式类似于下面这样：

  1. <response>
  2.     <row>
  3.         <row ...>
  4.             <creation_date>2012-11-18T00:00:00</creation_date>
  5.             <status>Completed</status>
  6.             <completion_date>2012-11-18T00:00:00</completion_date>
  7.             <service_request_number>12-01906549</service_request_number>
  8.             <type_of_service_request>Pot Hole in Street</type_of_service_request>
  9.             <current_activity>Final Outcome</current_activity>
  10.             <most_recent_action>CDOT Street Cut ... Outcome</most_recent_action>
  11.             <street_address>4714 S TALMAN AVE</street_address>
  12.             <zip>60632</zip>
  13.             <x_coordinate>1159494.68618856</x_coordinate>
  14.             <y_coordinate>1873313.83503384</y_coordinate>
  15.             <ward>14</ward>
  16.             <police_district>9</police_district>
  17.             <community_area>58</community_area>
  18.             <latitude>41.808090232127896</latitude>
  19.             <longitude>-87.69053684711305</longitude>
  20.             <location latitude="41.808090232127896"
  21.             longitude="-87.69053684711305" />
  22.         </row>
  23.         <row ...>
  24.             <creation_date>2012-11-18T00:00:00</creation_date>
  25.             <status>Completed</status>
  26.             <completion_date>2012-11-18T00:00:00</completion_date>
  27.             <service_request_number>12-01906695</service_request_number>
  28.             <type_of_service_request>Pot Hole in Street</type_of_service_request>
  29.             <current_activity>Final Outcome</current_activity>
  30.             <most_recent_action>CDOT Street Cut ... Outcome</most_recent_action>
  31.             <street_address>3510 W NORTH AVE</street_address>
  32.             <zip>60647</zip>
  33.             <x_coordinate>1152732.14127696</x_coordinate>
  34.             <y_coordinate>1910409.38979075</y_coordinate>
  35.             <ward>26</ward>
  36.             <police_district>14</police_district>
  37.             <community_area>23</community_area>
  38.             <latitude>41.91002084292946</latitude>
  39.             <longitude>-87.71435952353961</longitude>
  40.             <location latitude="41.91002084292946"
  41.             longitude="-87.71435952353961" />
  42.         </row>
  43.     </row>
  44. </response>

假设你想写一个脚本来按照坑洼报告数量排列邮编号码。你可以像这样做：

  1. from xml.etree.ElementTree import parse
  2. from collections import Counter
  3.  
  4. potholes_by_zip = Counter()
  5.  
  6. doc = parse('potholes.xml')
  7. for pothole in doc.iterfind('row/row'):
  8.     potholes_by_zip[pothole.findtext('zip')] += 1
  9. for zipcode, num in potholes_by_zip.most_common():
  10.     print(zipcode, num)

这个脚本唯一的问题是它会先将整个XML文件加载到内存中然后解析。在我的机器上，为了运行这个程序需要用到450MB左右的内存空间。如果使用如下代码，程序只需要修改一点点：

  1. from collections import Counter
  2.  
  3. potholes_by_zip = Counter()
  4.  
  5. data = parse_and_remove('potholes.xml', 'row/row')
  6. for pothole in data:
  7.     potholes_by_zip[pothole.findtext('zip')] += 1
  8. for zipcode, num in potholes_by_zip.most_common():
  9.     print(zipcode, num)

结果是：这个版本的代码运行时只需要7MB的内存–大大节约了内存资源。

讨论

这一节的技术会依赖 ElementTree 模块中的两个核心功能。第一，iterparse() 方法允许对XML文档进行增量操作。使用时，你需要提供文件名和一个包含下面一种或多种类型的事件列表：start , end, start-ns 和 end-ns 。由 iterparse() 创建的迭代器会产生形如 (event, elem) 的元组，其中 event 是上述事件列表中的某一个，而 elem 是相应的XML元素。例如：

  1. >>> data = iterparse('potholes.xml',('start','end'))
  2. >>> next(data)
  3. ('start', <Element 'response' at 0x100771d60>)
  4. >>> next(data)
  5. ('start', <Element 'row' at 0x100771e68>)
  6. >>> next(data)
  7. ('start', <Element 'row' at 0x100771fc8>)
  8. >>> next(data)
  9. ('start', <Element 'creation_date' at 0x100771f18>)
  10. >>> next(data)
  11. ('end', <Element 'creation_date' at 0x100771f18>)
  12. >>> next(data)
  13. ('start', <Element 'status' at 0x1006a7f18>)
  14. >>> next(data)
  15. ('end', <Element 'status' at 0x1006a7f18>)
  16. >>>

start 事件在某个元素第一次被创建并且还没有被插入其他数据(如子元素)时被创建。而 end 事件在某个元素已经完成时被创建。尽管没有在例子中演示， start-ns 和 end-ns 事件被用来处理XML文档命名空间的声明。

这本节例子中， start 和 end 事件被用来管理元素和标签栈。栈代表了文档被解析时的层次结构，还被用来判断某个元素是否匹配传给函数 parse_and_remove() 的路径。如果匹配，就利用 yield 语句向调用者返回这个元素。

在 yield 之后的下面这个语句才是使得程序占用极少内存的ElementTree的核心特性：

  1. elem_stack[-2].remove(elem)

这个语句使得之前由 yield 产生的元素从它的父节点中删除掉。假设已经没有其它的地方引用这个元素了，那么这个元素就被销毁并回收内存。

对节点的迭代式解析和删除的最终效果就是一个在文档上高效的增量式清扫过程。文档树结构从始自终没被完整的创建过。尽管如此，还是能通过上述简单的方式来处理这个XML数据。

这种方案的主要缺陷就是它的运行性能了。我自己测试的结果是，读取整个文档到内存中的版本的运行速度差不多是增量式处理版本的两倍快。但是它却使用了超过后者60倍的内存。因此，如果你更关心内存使用量的话，那么增量式的版本完胜。

原文:

http://python3-cookbook.readthedocs.io/zh_CN/latest/c06/p04_parse_huge_xml_files_incrementally.html