जवाबों:
import xml.dom.minidom
dom = xml.dom.minidom.parse(xml_fname) # or xml.dom.minidom.parseString(xml_string)
pretty_xml_as_string = dom.toprettyxml()lxml हाल ही में अपडेट किया गया है, और इसमें एक सुंदर प्रिंट फ़ंक्शन शामिल है
import lxml.etree as etree
x = etree.parse("filename")
print etree.tostring(x, pretty_print=True)Lxml ट्यूटोरियल देखें: http://lxml.de/tutorial.html
aptitude installदूर हैं। ओएस / एक्स के तहत मुझे यकीन नहीं है।
print(etree.tostring(x, pretty_print=True, encoding="unicode")):। आउटपुट फ़ाइल में लिखना सिर्फ एक पंक्ति में संभव है, किसी मध्यस्थ की आवश्यकता नहीं है:etree.parse("filename").write("outputfile", encoding="utf-8")
2.5 के बाद से पायथन में बनाए गए एलीमेंटट्री लाइब्रेरी के उपयोग के लिए एक और उपाय इस indentफ़ंक्शन को उधार लेना है । यहाँ है कि क्या दिखेगा:
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)tree.write([filename])फाइल करने के लिए लिख सकते हैं ( treeएलिमेंटट्री उदाहरण)।
tree = ElementTree.parse('file) ; root = tree.getroot() ; indent(root); tree.write('Out.xml');
यहाँ बदसूरत पाठ नोड समस्या के आसपास पाने के लिए मेरे (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>अस्वीकरण: शायद कुछ सीमाएँ हैं।
re.compileसे पहले का उपयोग करके sub(मैं re.findall()दो बार उपयोग कर रहा था , zipऔर एक forलूप के साथ str.replace()...)
जैसा कि दूसरों ने बताया, lxml में एक सुंदर प्रिंटर बनाया गया है।
हालांकि यह जान लें कि डिफ़ॉल्ट रूप से यह सीडीएटीए सेक्शन को सामान्य टेक्स्ट में बदल देता है, जिसके बुरे परिणाम हो सकते हैं।
यहां एक पायथन फ़ंक्शन है जो इनपुट फ़ाइल को संरक्षित करता है और केवल इंडेंटेशन (नोटिस strip_cdata=False) को बदलता है । इसके अलावा यह सुनिश्चित करता है कि आउटपुट डिफ़ॉल्ट ASCII के बजाय एन्कोडिंग के रूप में UTF-8 का उपयोग करता है (नोटिस करें 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')BeautifulSoup का उपयोग करना आसान है prettify() तरीका है।
यह इंडेंटेशन लेवल के हिसाब से एक स्पेस देता है। यह lxml के pretty_print से बेहतर काम करता है और यह छोटा और मीठा है।
from bs4 import BeautifulSoup
bs = BeautifulSoup(open(xml_file), 'xml')
print bs.prettify()bs4.FeatureNotFound: Couldn't find a tree builder with the features you requested: xml. Do you need to install a parser library?
यदि आपके पास है तो xmllintआप एक सबप्रोसेस कर सकते हैं और उसका उपयोग कर सकते हैं।xmllint --format <file>सुंदर अपने मानक मानक के लिए इनपुट एक्सएमएल मुद्रित करता है।
ध्यान दें कि यह विधि बाहरी से अजगर के लिए एक प्रोग्राम का उपयोग करती है, जो इसे एक हैक की तरह बनाती है।
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))मैंने ऊपर दिए गए "एडे" के उत्तर को संपादित करने की कोशिश की, लेकिन स्टैक ओवरफ्लो ने मुझे संपादित करने की अनुमति नहीं दी, क्योंकि मैंने शुरुआत में गुमनाम रूप से प्रतिक्रिया प्रदान की थी। यह एक 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 += ' 'यदि आप 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)यदि आप अपने स्वयं के सुंदर-प्रिंटर के बिना कुछ और उपयोग कर रहे हैं - या उन सुंदर-प्रिंटरों को वह नहीं करते हैं, जिस तरह से आप चाहते हैं - तो आपको शायद लिखना होगा या अपने स्वयं के धारावाहिकों को उपवर्ग करना होगा।
मैं minidom सुंदर प्रिंट के साथ कुछ समस्याएं थीं। जब भी मैं दिए गए एन्कोडिंग के बाहर के पात्रों के साथ एक दस्तावेज़ को सुंदर-छपाई करने की कोशिश करता हूं, तो मुझे एक यूनिकोडरप्रिंट मिलेगा, जैसे कि अगर मेरे पास दस्तावेज़ में ode था और मैंने कोशिश की 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')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 होमपेज पर है।
मैंने एक मौजूदा एलिमेंट्री के माध्यम से चलने और इसे आम तौर पर एक के रूप में इंडेंट करने के लिए टेक्स्ट / टेल का उपयोग करने के लिए एक समाधान लिखा।
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अजगर के लिए एक्सएमएल सुंदर प्रिंट इस कार्य के लिए बहुत अच्छा लग रहा है। (उचित रूप से नाम भी दिया गया है।)
एक विकल्प pyXML का उपयोग करना है , जिसमें एक प्रीप्रिंट फ़ंक्शन है ।
HTTPError: 404 Client Error: Not Found for url: https://pypi.org/simple/xmlpp/सोचो कि परियोजना आजकल अटारी में है, शर्म की बात है।
यहाँ एक पायथन 3 समाधान है जो बदसूरत न्यूलाइन मुद्दे (व्हॉट्सएप के टन) से छुटकारा दिलाता है, और यह केवल अन्य पुस्तकालयों के विपरीत मानक पुस्तकालयों का उपयोग करता है।
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)मैंने पाया कि यहां आम न्यूलाइन मुद्दे को कैसे ठीक किया जाए ।
आप लोकप्रिय बाहरी पुस्तकालय 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"?>शीर्ष पर।
Vkbeautify पर नज़र डालें मॉड्यूल ।
यह एक ही नाम के साथ मेरे बहुत लोकप्रिय जावास्क्रिप्ट / नोडजस प्लगइन का एक अजगर संस्करण है। यह 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') एक विकल्प यदि आप नहीं चाहते हैं कि फिर से तैयार किया जाए, तो फ़ंक्शन के साथ xmlpp.py लाइब्रेरी हैget_pprint() । यह मेरे उपयोग के मामलों के लिए अच्छा और सुचारू रूप से काम करता था, बिना एक एलएक्सएमएल एलिमेंट्री ऑब्जेक्ट के पुनर्मिलन के बिना।
आप इस विविधता को आज़मा सकते हैं ...
स्थापित करें 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()) 'lxml'lxml के HTML पार्सर का उपयोग करता है - बीएस 4 डॉक्स देखें । आपको XML पार्सर के लिए 'xml'या उसकी आवश्यकता है 'lxml-xml'।
lxml’s XML parser BeautifulSoup(markup, "lxml-xml") BeautifulSoup(markup, "xml")
lxml-xml), और फिर वे उसी दिन इसे नीचे करने के लिए आगे बढ़े। मैंने एस / ओ को एक आधिकारिक शिकायत सौंपी लेकिन उन्होंने जांच से इनकार कर दिया। वैसे भी, मेरे पास "डी-टैम्परेड" मेरा उत्तर है, जो अब फिर से सही है (और lxml-xmlमूल रूप से यह निर्दिष्ट करता है)। धन्यवाद।
मुझे यह समस्या थी और इसे इस तरह हल किया:
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!")यह केवल इसलिए काम करता है क्योंकि डिफ़ॉल्ट रूप से ईट्री two spacesइंडेंट का उपयोग करता है, जो मुझे इंडेंटेशन पर बहुत जोर नहीं देता है और इसलिए सुंदर नहीं है। मैं किसी भी फ़ंक्शन के लिए किसी भी फ़ंक्शन के लिए मानक ईट्री इंडेंट को बदलने के लिए कोई सेटिंग नहीं कर सकता। मुझे पसंद है कि एट्री का उपयोग करना कितना आसान है, लेकिन यह वास्तव में मुझे परेशान कर रहा था।
एक संपूर्ण xml दस्तावेज़ को एक सुंदर xml दस्तावेज़ में परिवर्तित करने के लिए
(उदा: मान लिया गया है कि आपने [unzipped] एक LibreOffice Writer .odt या .ods फ़ाइल बनाई है, और आप बदसूरत "content.xlml" फ़ाइल को एक सुंदर एक में बदलना चाहते हैं। स्वचालित git संस्करण नियंत्रण और git difftool.odt / .ods फ़ाइलों की आईएनजी , जैसे मैं यहां लागू कर रहा हूं )
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()सन्दर्भ:
- इस पृष्ठ पर बेन नोलैंड के उत्तर के लिए धन्यवाद जो मुझे वहां सबसे ज्यादा मिला।
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 के लिए अच्छी तरह से काम कर रहा है!
यदि किसी कारण से आप पायथन मॉड्यूल में से किसी पर भी अपना हाथ नहीं जमा सकते हैं, जिसका अन्य उपयोगकर्ताओं ने उल्लेख किया है, तो मैं पायथन एक्स के लिए निम्नलिखित समाधान सुझाता हूं:
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पैकेज स्थापित है।
check_outputक्योंकि आपको त्रुटि जाँच करने की आवश्यकता नहीं है
मैंने इसे कोड की कुछ पंक्तियों के साथ हल किया, फ़ाइल खोलना, इसे गर्त में डालना और इंडेंटेशन जोड़ना, फिर इसे सहेजना। मैं छोटी 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()यह मेरे लिए काम करता है, शायद किसी को इसका कुछ उपयोग होगा :)