在 Python 中漂亮地打印 XML 的最佳方式是什么（或者是各种方式）？
问问题
458878 次
27 回答
426
import xml.dom.minidom
dom = xml.dom.minidom.parse(xml_fname) # or xml.dom.minidom.parseString(xml_string)
pretty_xml_as_string = dom.toprettyxml()
于 2009-07-30T14:12:29.050 回答
184
lxml 是最新的、更新的，并且包含一个漂亮的打印功能
import lxml.etree as etree
x = etree.parse("filename")
print etree.tostring(x, pretty_print=True)
查看 lxml 教程： http: //lxml.de/tutorial.html
于 2009-04-15T00:21:19.413 回答
118
另一种解决方案是借用这个indent函数，用于自 2.5 以来内置于 Python 的 ElementTree 库。这就是它的样子：
from xml.etree import ElementTree
def indent(elem, level=0):
i = "\n" + level*" "
j = "\n" + (level-1)*" "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for subelem in elem:
indent(subelem, level+1)
if not elem.tail or not elem.tail.strip():
elem.tail = j
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = j
return elem
root = ElementTree.parse('/tmp/xmlfile').getroot()
indent(root)
ElementTree.dump(root)
于 2011-01-04T01:57:31.667 回答
49
这是我（hacky？）解决丑陋文本节点问题的解决方案。
uglyXml = doc.toprettyxml(indent=' ')
text_re = re.compile('>\n\s+([^<>\s].*?)\n\s+</', re.DOTALL)
prettyXml = text_re.sub('>\g<1></', uglyXml)
print prettyXml
上面的代码将产生：
<?xml version="1.0" ?>
<issues>
<issue>
<id>1</id>
<title>Add Visual Studio 2005 and 2008 solution files</title>
<details>We need Visual Studio 2005/2008 project files for Windows.</details>
</issue>
</issues>
而不是这个：
<?xml version="1.0" ?>
<issues>
<issue>
<id>
1
</id>
<title>
Add Visual Studio 2005 and 2008 solution files
</title>
<details>
We need Visual Studio 2005/2008 project files for Windows.
</details>
</issue>
</issues>
免责声明：可能存在一些限制。
于 2010-07-29T22:18:57.243 回答
41
你有几个选择。
ElementTree.indent()
使用简单，输出漂亮。
但需要 Python 3.9+
import xml.etree.ElementTree as ET
element = ET.XML("<html><body>text</body></html>")
ET.indent(element)
print(ET.tostring(element, encoding='unicode'))
美丽汤.prettify()
BeautifulSoup 可能是 Python <=3.9 最简单的解决方案。
from bs4 import BeautifulSoup
bs = BeautifulSoup(open(xml_file), 'xml')
pretty_xml = bs.prettify()
print(pretty_xml)
输出：
<?xml version="1.0" encoding="utf-8"?> <issues> <issue> <id> 1 </id> <title> Add Visual Studio 2005 and 2008 solution files </title> </issue> </issues>
这是我的答案。默认参数按原样工作。但是文本内容分散在不同的行上，就好像它们是嵌套元素一样。
lxml
更漂亮的输出，但有参数。
from lxml import etree
x = etree.parse(FILE_NAME)
pretty_xml = etree.tostring(x, pretty_print=True, encoding=str)
产生：
<issues> <issue> <id>1</id> <title>Add Visual Studio 2005 and 2008 solution files</title> <details>We need Visual Studio 2005/2008 project files for Windows.</details> </issue> </issues>
这对我来说没有问题。
xml
没有外部依赖，但有后处理。
import xml.dom.minidom as md
dom = md.parse(FILE_NAME)
# To parse string instead use: dom = md.parseString(xml_string)
pretty_xml = dom.toprettyxml()
# remove the weird newline issue:
pretty_xml = os.linesep.join([s for s in pretty_xml.splitlines()
if s.strip()])
输出与上面相同，但代码更多。
于 2016-09-14T04:54:09.893 回答
23
正如其他人指出的那样，lxml 内置了一个漂亮的打印机。
请注意，默认情况下它会将 CDATA 部分更改为普通文本，这可能会产生令人讨厌的结果。
这是一个 Python 函数，它保留输入文件并且只更改缩进（注意strip_cdata=False）。此外，它确保输出使用 UTF-8 作为编码而不是默认的 ASCII（注意encoding='utf-8'）：
from lxml import etree
def prettyPrintXml(xmlFilePathToPrettyPrint):
assert xmlFilePathToPrettyPrint is not None
parser = etree.XMLParser(resolve_entities=False, strip_cdata=False)
document = etree.parse(xmlFilePathToPrettyPrint, parser)
document.write(xmlFilePathToPrettyPrint, pretty_print=True, encoding='utf-8')
示例用法：
prettyPrintXml('some_folder/some_file.xml')
于 2011-04-13T12:33:29.490 回答
23
从 Python 3.9 开始，ElementTree 具有indent()漂亮打印 XML 树的功能。
请参阅https://docs.python.org/3/library/xml.etree.elementtree.html#xml.etree.ElementTree.indent。
示例用法：
import xml.etree.ElementTree as ET
element = ET.XML("<html><body>text</body></html>")
ET.indent(element)
print(ET.tostring(element, encoding='unicode'))
好处是它不需要任何额外的库。有关更多信息，请查看https://bugs.python.org/issue14465和https://github.com/python/cpython/pull/15200
于 2020-08-12T09:26:14.843 回答
13
如果你有xmllint，你可以生成一个子进程并使用它。xmllint --format <file>将其输入 XML 漂亮地打印到标准输出。
请注意，此方法使用 python 外部的程序，这使其有点像 hack。
def pretty_print_xml(xml):
proc = subprocess.Popen(
['xmllint', '--format', '/dev/stdin'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
)
(output, error_output) = proc.communicate(xml);
return output
print(pretty_print_xml(data))
于 2012-04-12T23:40:33.900 回答
11
我试图编辑上面“ade”的答案，但在我最初匿名提供反馈后，Stack Overflow 不允许我编辑。这是用于漂亮打印 ElementTree 的函数的错误较少的版本。
def indent(elem, level=0, more_sibs=False):
i = "\n"
if level:
i += (level-1) * ' '
num_kids = len(elem)
if num_kids:
if not elem.text or not elem.text.strip():
elem.text = i + " "
if level:
elem.text += ' '
count = 0
for kid in elem:
indent(kid, level+1, count < num_kids - 1)
count += 1
if not elem.tail or not elem.tail.strip():
elem.tail = i
if more_sibs:
elem.tail += ' '
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
if more_sibs:
elem.tail += ' '
于 2012-10-17T17:32:01.123 回答
9
如果您使用的是 DOM 实现，则每个实现都有自己的内置漂亮打印形式：
# minidom
#
document.toprettyxml()
# 4DOM
#
xml.dom.ext.PrettyPrint(document, stream)
# pxdom (or other DOM Level 3 LS-compliant imp)
#
serializer.domConfig.setParameter('format-pretty-print', True)
serializer.writeToString(document)
如果您正在使用没有自己的漂亮打印机的其他东西——或者那些漂亮的打印机不完全按照你想要的方式做——你可能必须编写或子类化你自己的序列化器。
于 2009-04-15T00:48:22.377 回答
7
我在 minidom 的漂亮打印上遇到了一些问题。每当我尝试使用给定编码之外的字符漂亮地打印文档时，我都会得到一个 UnicodeError，例如，如果我在文档中有一个 β 并且我尝试了doc.toprettyxml(encoding='latin-1'). 这是我的解决方法：
def toprettyxml(doc, encoding):
"""Return a pretty-printed XML document in a given encoding."""
unistr = doc.toprettyxml().replace(u'<?xml version="1.0" ?>',
u'<?xml version="1.0" encoding="%s"?>' % encoding)
return unistr.encode(encoding, 'xmlcharrefreplace')
于 2009-04-15T13:46:01.617 回答
6
from yattag import indent
pretty_string = indent(ugly_string)
它不会在文本节点内添加空格或换行符，除非您通过以下方式要求：
indent(mystring, indent_text = True)
您可以指定缩进单元应该是什么以及换行符应该是什么样子。
pretty_xml_string = indent(
ugly_xml_string,
indentation = ' ',
newline = '\r\n'
)
该文档位于http://www.yattag.org主页上。
于 2014-05-13T14:49:14.603 回答
6
我编写了一个解决方案来遍历现有的 ElementTree 并使用 text/tail 来缩进它，就像人们通常期望的那样。
def prettify(element, indent=' '):
queue = [(0, element)] # (level, element)
while queue:
level, element = queue.pop(0)
children = [(level + 1, child) for child in list(element)]
if children:
element.text = '\n' + indent * (level+1) # for child open
if queue:
element.tail = '\n' + indent * queue[0][0] # for sibling open
else:
element.tail = '\n' + indent * (level-1) # for parent close
queue[0:0] = children # prepend so children come before siblings
于 2016-07-25T17:25:06.227 回答
4
这是一个 Python3 解决方案，它摆脱了丑陋的换行问题（大量空白），并且它只使用标准库，与大多数其他实现不同。
import xml.etree.ElementTree as ET
import xml.dom.minidom
import os
def pretty_print_xml_given_root(root, output_xml):
"""
Useful for when you are editing xml data on the fly
"""
xml_string = xml.dom.minidom.parseString(ET.tostring(root)).toprettyxml()
xml_string = os.linesep.join([s for s in xml_string.splitlines() if s.strip()]) # remove the weird newline issue
with open(output_xml, "w") as file_out:
file_out.write(xml_string)
def pretty_print_xml_given_file(input_xml, output_xml):
"""
Useful for when you want to reformat an already existing xml file
"""
tree = ET.parse(input_xml)
root = tree.getroot()
pretty_print_xml_given_root(root, output_xml)
我在这里找到了如何解决常见的换行问题。
于 2020-02-12T17:03:19.483 回答
3
Python 的 XML 漂亮打印看起来非常适合这项任务。（也有恰当的名字。）
另一种方法是使用具有PrettyPrint 功能的pyXML。
于 2009-04-15T00:07:19.557 回答
3
你可以使用流行的外部库xmltodict，你会得到最好的结果unparse：pretty=True
xmltodict.unparse(
xmltodict.parse(my_xml), full_document=False, pretty=True)
full_document=False反对<?xml version="1.0" encoding="UTF-8"?>在顶部。
于 2016-09-07T17:02:38.220 回答
2
看看vkbeautify模块。
它是我非常流行的同名 javascript/nodejs 插件的 python 版本。它可以漂亮地打印/缩小 XML、JSON 和 CSS 文本。输入和输出可以是任意组合的字符串/文件。它非常紧凑，没有任何依赖。
例子：
import vkbeautify as vkb
vkb.xml(text)
vkb.xml(text, 'path/to/dest/file')
vkb.xml('path/to/src/file')
vkb.xml('path/to/src/file', 'path/to/dest/file')
于 2017-01-04T01:50:28.117 回答
2
你可以试试这个变化...
安装BeautifulSoup和后端lxml（解析器）库：
user$ pip3 install lxml bs4
处理您的 XML 文档：
from bs4 import BeautifulSoup
with open('/path/to/file.xml', 'r') as doc:
for line in doc:
print(BeautifulSoup(line, 'lxml-xml').prettify())
于 2019-09-29T20:49:25.363 回答
1
如果您不想重新解析，另一种方法是使用带有该函数的xmlpp.py 库。get_pprint()它在我的用例中运行良好且流畅，无需重新解析为 lxml ElementTree 对象。
于 2017-07-25T14:38:25.697 回答
0
我遇到了这个问题并像这样解决了它：
def write_xml_file (self, file, xml_root_element, xml_declaration=False, pretty_print=False, encoding='unicode', indent='\t'):
pretty_printed_xml = etree.tostring(xml_root_element, xml_declaration=xml_declaration, pretty_print=pretty_print, encoding=encoding)
if pretty_print: pretty_printed_xml = pretty_printed_xml.replace(' ', indent)
file.write(pretty_printed_xml)
在我的代码中，这个方法是这样调用的：
try:
with open(file_path, 'w') as file:
file.write('<?xml version="1.0" encoding="utf-8" ?>')
# create some xml content using etree ...
xml_parser = XMLParser()
xml_parser.write_xml_file(file, xml_root, xml_declaration=False, pretty_print=True, encoding='unicode', indent='\t')
except IOError:
print("Error while writing in log file!")
这只是因为 etree 默认情况下使用two spaces缩进，我发现它不太强调缩进，因此不漂亮。我找不到任何 etree 的设置或任何函数的参数来更改标准 etree 缩进。我喜欢使用 etree 是多么容易，但这真的让我很烦。
于 2015-07-27T23:06:29.990 回答
0
用于将整个 xml 文档转换为漂亮的 xml 文档
（例如：假设您已提取 [解压缩] LibreOffice Writer .odt 或 .ods 文件，并且您希望将丑陋的“content.xml”文件转换为漂亮的自动 git 版本控制和git difftool.odt/.ods 文件的 ing，例如我在这里实现的）
import xml.dom.minidom
file = open("./content.xml", 'r')
xml_string = file.read()
file.close()
parsed_xml = xml.dom.minidom.parseString(xml_string)
pretty_xml_as_string = parsed_xml.toprettyxml()
file = open("./content_new.xml", 'w')
file.write(pretty_xml_as_string)
file.close()
参考资料：
- 感谢Ben Noland 在此页面上的回答，这让我大部分时间都到达了那里。
于 2018-09-01T06:48:53.660 回答
0
from lxml import etree
import xml.dom.minidom as mmd
xml_root = etree.parse(xml_fiel_path, etree.XMLParser())
def print_xml(xml_root):
plain_xml = etree.tostring(xml_root).decode('utf-8')
urgly_xml = ''.join(plain_xml .split())
good_xml = mmd.parseString(urgly_xml)
print(good_xml.toprettyxml(indent=' ',))
它适用于带有中文的xml！
于 2019-08-12T09:24:45.103 回答
0
如果由于某种原因您无法使用其他用户提到的任何 Python 模块，我建议使用以下 Python 2.7 解决方案：
import subprocess
def makePretty(filepath):
cmd = "xmllint --format " + filepath
prettyXML = subprocess.check_output(cmd, shell = True)
with open(filepath, "w") as outfile:
outfile.write(prettyXML)
据我所知，此解决方案将适用于xmllint安装了该软件包的基于 Unix 的系统。
于 2020-05-14T04:16:29.647 回答
0
我在寻找“如何漂亮地打印 html”时发现了这个问题
使用此线程中的一些想法，我调整了 XML 解决方案以适用于 XML 或 HTML：
from xml.dom.minidom import parseString as string_to_dom
def prettify(string, html=True):
dom = string_to_dom(string)
ugly = dom.toprettyxml(indent=" ")
split = list(filter(lambda x: len(x.strip()), ugly.split('\n')))
if html:
split = split[1:]
pretty = '\n'.join(split)
return pretty
def pretty_print(html):
print(prettify(html))
使用时是这样的：
html = """\
<div class="foo" id="bar"><p>'IDK!'</p><br/><div class='baz'><div>
<span>Hi</span></div></div><p id='blarg'>Try for 2</p>
<div class='baz'>Oh No!</div></div>
"""
pretty_print(html)
返回：
<div class="foo" id="bar">
<p>'IDK!'</p>
<br/>
<div class="baz">
<div>
<span>Hi</span>
</div>
</div>
<p id="blarg">Try for 2</p>
<div class="baz">Oh No!</div>
</div>
于 2020-10-01T20:01:23.287 回答
0
使用etree.indent和etree.tostring
import lxml.etree as etree
root = etree.fromstring('<html><head></head><body><h1>Welcome</h1></body></html>')
etree.indent(root, space=" ")
xml_string = etree.tostring(root, pretty_print=True).decode()
print(xml_string)
输出
<html>
<head/>
<body>
<h1>Welcome</h1>
</body>
</html>
删除命名空间和前缀
import lxml.etree as etree
def dump_xml(element):
for item in element.getiterator():
item.tag = etree.QName(item).localname
etree.cleanup_namespaces(element)
etree.indent(element, space=" ")
result = etree.tostring(element, pretty_print=True).decode()
return result
root = etree.fromstring('<cs:document xmlns:cs="http://blabla.com"><name>hello world</name></cs:document>')
xml_string = dump_xml(root)
print(xml_string)
输出
<document>
<name>hello world</name>
</document>
于 2020-10-08T21:01:26.833 回答
-1
我找到了一种很好地打印 xml 文件的简单方法：
import xml.etree.ElementTree as ET
xmlTree = ET.parse('your XML file')
xmlRoot = xmlTree.getroot()
xmlDoc = ET.tostring(xmlRoot, encoding="unicode")
print(xmlDoc)
输出：
<root>
<child>
<subchild>.....</subchild>
</child>
<child>
<subchild>.....</subchild>
</child>
...
...
...
<child>
<subchild>.....</subchild>
</child>
</root>
于 2021-05-17T13:20:56.647 回答
-2
我用几行代码解决了这个问题，打开文件，浏览它并添加缩进，然后再次保存。我正在处理小型 xml 文件，并且不想添加依赖项或为用户安装更多库。无论如何，这是我最终得到的：
f = open(file_name,'r')
xml = f.read()
f.close()
#Removing old indendations
raw_xml = ''
for line in xml:
raw_xml += line
xml = raw_xml
new_xml = ''
indent = ' '
deepness = 0
for i in range((len(xml))):
new_xml += xml[i]
if(i<len(xml)-3):
simpleSplit = xml[i:(i+2)] == '><'
advancSplit = xml[i:(i+3)] == '></'
end = xml[i:(i+2)] == '/>'
start = xml[i] == '<'
if(advancSplit):
deepness += -1
new_xml += '\n' + indent*deepness
simpleSplit = False
deepness += -1
if(simpleSplit):
new_xml += '\n' + indent*deepness
if(start):
deepness += 1
if(end):
deepness += -1
f = open(file_name,'w')
f.write(new_xml)
f.close()
它对我有用，也许有人会使用它:)
于 2013-07-12T11:01:36.767 回答