दिलचस्प पोस्ट
कमांड लाइन पर 'set var = text' का उपयोग करने के बाद 'echo% var%' के साथ कोई स्ट्रिंग आउटपुट क्यों नहीं है? सी ++ कोड फ़ाइल एक्सटेंशन? । सीसी बनाम। सीपीपी डबल सूचक का उपयोग क्यों करें? या क्यों पॉइंटर्स को पॉइंटर्स का उपयोग करें? PHP और माइक्रोसॉफ्ट एक्सेस डाटाबेस – कनेक्शन और सीआरयूडी मूल वाक्य रचना के लिए वैकल्पिक हल को पार्स नहीं किया जा रहा है डेटासेट बनाम डेटासेट कॉलम डेटाटाइप में बाइट और चाअर के बीच का अंतर क्या एक डाटासेट को ट्रेनिंग और वैल्यूशन सेट में विभाजित करने के लिए एक नियम है? त्रुटि: (1, 0) आईडी के साथ प्लगइन 'com.android.application' नहीं मिला कस्टम ऑब्जेक्ट्स के वेक्टर को छांटें एक स्पर्श के बाद UIButton को चुनना प्रोग्रामेटिक रूप से आईपैड / आईफोन हार्डवेयर का पता लगाने का सर्वोत्तम तरीका क्या इंटरनेट एक्सप्लोरर 8 एचटीएमएल 5 का समर्थन करता है? जावा में "अपरिवर्तनीय बयान" कंपाइलर त्रुटि क्यों है? जीआईटी में दोबारा विलय करने के बाद फिर से करना

पायथन में सुंदर मुद्रण XML

Python में सुंदर प्रिंट XML के लिए सबसे अच्छा तरीका (या यहां तक ​​कि विभिन्न तरीकों) क्या है?

Solutions Collecting From Web of "पायथन में सुंदर मुद्रण XML"

import xml.dom.minidom xml = xml.dom.minidom.parse(xml_fname) # or xml.dom.minidom.parseString(xml_string) pretty_xml_as_string = xml.toprettyxml() 

lxml हाल ही में, अपडेट किया गया है, और इसमें एक सुंदर प्रिंट फ़ंक्शन शामिल है

 import lxml.etree as etree x = etree.parse("filename") print etree.tostring(x, pretty_print=True) 

Lxml ट्यूटोरियल देखें: http://lxml.de/tutorial.html

एक और समाधान है कि यह एलिमेंटटी लाइब्रेरी के साथ प्रयोग के लिए, indent फ़ंक्शन उधार लेना है जो पायथन में 2.5 से निर्मित है। ये ऐसा दिखेगा जो ऐसा दिखेगा:

 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) 

बदसूरत पाठ नोड समस्या के आसपास पाने के लिए मेरा (हैकी?) समाधान है I

 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> 

अस्वीकरण: शायद कुछ सीमाएँ हैं

जैसा कि दूसरों ने बताया है, एलएक्सएमएल में एक सुंदर प्रिंटर बनाया गया है।

ध्यान रखें कि डिफ़ॉल्ट रूप से यह सामान्य पाठ के लिए सीडीएटीए अनुभागों को बदलता है, जो गंदा परिणाम हो सकता है।

यहां एक पायथन फ़ंक्शन है जो इनपुट फ़ाइल को सुरक्षित रखता है और केवल strip_cdata=False को strip_cdata=False ( strip_cdata=False नोटिस करें) इसके अलावा यह सुनिश्चित करता है कि आउटपुट यूटएफ -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') 

यदि आपके पास xmllint तो आप एक उपप्रकाशन पैदा कर सकते हैं और उसका उपयोग कर सकते हैं। xmllint --format <file> इसकी इनपुट XML को मानक आउटपुट पर सुंदर प्रिंट करता है

ध्यान दें कि यह विधि अजगर के बाहर एक प्रोग्राम का उपयोग करता है, जो इसे एक हैक का प्रकार बनाता है।

 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)) 

यदि आप किसी 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) 

यदि आप अपने खुद के सुंदर-प्रिंटर के बिना कुछ और का उपयोग कर रहे हैं – या उन सुंदर-प्रिंटर आप जिस तरीके से चाहते हैं, वह काफी नहीं करते – आपको शायद अपना खुद का सीरियलाइज़र लिखना होगा या उप-वर्ग बनाना होगा

मैंने ऊपर "एडे" के उत्तर को संपादित करने की कोशिश की, लेकिन स्टैक ओवरफ़्लो ने मुझे शुरू से ही गुमनाम रूप से फ़ीडबैक प्रदान करने के बाद संपादित करने की इजाजत नहीं दी। एलीमेंटट्री को सुंदर प्रिंट करने के लिए यह फ़ंक्शन का एक छोटा बूगी संस्करण है

 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 += ' ' 

मुझे मिनीडोम की सुंदर प्रिंट के साथ कुछ समस्या थी जब भी मैंने दिए गए एन्कोडिंग के बाहर वर्णों के साथ एक दस्तावेज को सुंदर प्रिंटिंग करने की कोशिश की तो उदाहरण के लिए, उदाहरण के लिए, अगर मेरे पास दस्तावेज़ में एक β था और मैंने doc.toprettyxml(encoding='latin-1') की कोशिश की थी 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') 

खूबसूरत prettify() का उपयोग करना आसान है prettify() फ़ंक्शन।

यह इंडेंटेशन स्तर पर एक स्थान को इंडेंट करता है। यह lxml के pretty_print से बेहतर काम करता है और छोटी और प्यारी है

 from bs4 import BeautifulSoup bs = BeautifulSoup(open(xml_file), 'xml') print bs.prettify() 
 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 

Vkbeautify मॉड्यूल पर एक नज़र डालें।

यह मेरे बहुत लोकप्रिय जावास्क्रिप्ट / एक ही नाम के साथ nodejs प्लगइन का एक अजगर संस्करण है। यह सुंदर प्रिंट / minify XML, JSON और सीएसएस पाठ कर सकते हैं किसी भी संयोजन में इनपुट और आउटपुट स्ट्रिंग / फ़ाइल हो सकते हैं। यह बहुत कॉम्पैक्ट है और इसमें कोई निर्भरता नहीं है।

उदाहरण :

 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') 

एक विकल्प यदि आप reparse नहीं करना चाहते हैं, तो get_pprint() फ़ंक्शन के साथ xmlpp.py लाइब्रेरी है । यह मेरे उपयोग के मामलों के लिए एक एलएक्सएमएल एलिमेंटट्री ऑब्जेक्ट की मरम्मत के बिना अच्छा और आसानी से काम करता है।

मुझे इस समस्या थी और इसे इस तरह हल किया गया था:

 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 का उपयोग करती है, जिस पर मुझे इंडेंटेशन पर ज्यादा बल नहीं मिलता है और इसलिए सुंदर नहीं है मानक एट्री इंडेंट को बदलने के लिए मैं किसी भी कार्य के लिए एट्री या पैरामीटर के लिए कोई भी सेटिंग नहीं जोड़ सकता। मुझे एट्री का प्रयोग करना कितना आसान है, लेकिन यह वास्तव में मुझे गुस्सा आ रहा था

आप लोकप्रिय बाहरी लाइब्रेरी xmltodict का उपयोग कर सकते हैं, जिसमें आप pretty=True unparse और pretty=True साथ मिल सकते हैं:

 xmltodict.unparse( xmltodict.parse(my_xml), full_document=False, pretty=True) 

full_document=False <?xml version="1.0" encoding="UTF-8"?> खिलाफ full_document=False <?xml version="1.0" encoding="UTF-8"?>

मैंने इसे कोड की कुछ पंक्तियों के साथ सुलझाया, फ़ाइल खोलना, उसे गड़बड़ाना और जोड़ना जोड़ने, फिर इसे फिर से सहेजना मैं छोटी सी 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() 

यह मेरे लिए काम करता है, शायद किसी का इसका कुछ उपयोग होगा 🙂