पायथन 3 - एक्सएमएल प्रोसेसिंग

XML एक पोर्टेबल, ओपन सोर्स भाषा है जो प्रोग्रामर को उन एप्लिकेशन को विकसित करने की अनुमति देता है, जो ऑपरेटिंग सिस्टम और / या डेवलपमेंट लैंग्वेज की परवाह किए बिना अन्य एप्लिकेशन द्वारा पढ़े जा सकते हैं।

XML क्या है?

एक्स्टेंसिबल मार्कअप लैंग्वेज (एक्सएमएल) एचटीएमएल या एसजीएमएल जैसी मार्कअप भाषा है। यह वर्ल्ड वाइड वेब कंसोर्टियम द्वारा अनुशंसित है और एक खुले मानक के रूप में उपलब्ध है।

SQL- आधारित बैकबोन की आवश्यकता के बिना डेटा की छोटी से मध्यम मात्रा का ट्रैक रखने के लिए XML बेहद उपयोगी है।

XML पार्सर आर्किटेक्चर और एपीआई

पायथन मानक पुस्तकालय XML के साथ काम करने के लिए इंटरफेस का एक न्यूनतम लेकिन उपयोगी सेट प्रदान करता है।

XML डेटा में दो सबसे बुनियादी और व्यापक रूप से उपयोग किए जाने वाले एपीआई SAX और DOM इंटरफेस हैं।

• Simple API for XML (SAX)- यहां, आप ब्याज की घटनाओं के लिए कॉलबैक रजिस्टर करते हैं और फिर दस्तावेज़ के माध्यम से पार्सर को आगे बढ़ने देते हैं। यह तब उपयोगी होता है जब आपके दस्तावेज़ बड़े होते हैं या आपकी मेमोरी सीमाएँ होती हैं, यह फ़ाइल को पार्स करता है क्योंकि यह इसे डिस्क से पढ़ता है और पूरी फ़ाइल मेमोरी में कभी संग्रहीत नहीं होती है।

• Document Object Model (DOM) API - यह एक वर्ल्ड वाइड वेब कंसोर्टियम की सिफारिश है जिसमें पूरी फ़ाइल को मेमोरी में पढ़ा जाता है और एक XML दस्तावेज़ की सभी विशेषताओं का प्रतिनिधित्व करने के लिए एक पदानुक्रमित (ट्री-आधारित) फ़ॉर्म में संग्रहीत किया जाता है।

SAX स्पष्ट रूप से बड़ी फ़ाइलों के साथ काम करते समय डोम के रूप में तेजी से जानकारी संसाधित नहीं कर सकता है। दूसरी ओर, विशेष रूप से DOM का उपयोग वास्तव में आपके संसाधनों को मार सकता है, खासकर अगर कई छोटी फ़ाइलों पर उपयोग किया जाता है।

SAX केवल-पढ़ने के लिए है, जबकि DOM XML फ़ाइल में परिवर्तन की अनुमति देता है। चूंकि ये दो अलग-अलग एपीआई सचमुच एक-दूसरे के पूरक हैं, इसलिए कोई कारण नहीं है कि आप बड़ी परियोजनाओं के लिए इन दोनों का उपयोग नहीं कर सकते हैं।

हमारे सभी XML कोड उदाहरणों के लिए, इनपुट के रूप में एक सरल XML फ़ाइल मूवी. xml का उपयोग करें -

<collection shelf = "New Arrivals">
<movie title = "Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title = "Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

एसएएक्स एपीआई के साथ पार्सिंग एक्सएमएल

SAX ईवेंट-चालित XML पार्सिंग के लिए एक मानक इंटरफ़ेस है। SAX के साथ XML को पार्स करने के लिए आम तौर पर आपको xml.sax.ContentHandler को उप-लिंक करके अपना खुद का ContentHandler बनाना पड़ता है।

आपका ContentHandler XML के विशेष स्वादों और विशेषताओं को संभालता है। एक ContentHandler ऑब्जेक्ट विभिन्न पार्सिंग घटनाओं को संभालने के लिए तरीके प्रदान करता है। इसका अपना पार्सर कंटेंटहैंडलर विधियों को कॉल करता है क्योंकि यह XML फ़ाइल को पार्स करता है।

XML फ़ाइल के प्रारंभ और अंत में तरीके startDocument और endDocument कहलाते हैं। विधि वर्ण (पाठ) पैरामीटर पाठ के माध्यम से XML फ़ाइल के चरित्र डेटा को पारित किया जाता है।

ContentHandler को प्रत्येक तत्व के आरंभ और अंत में कहा जाता है। यदि पार्सर नेमस्पेस मोड में नहीं है, तो तरीके startElement (टैग, गुण) और endElement (टैग) कहा जाता है; अन्यथा, इसी तरीके startElementNS और endElementNS को कहा जाता है। यहाँ, टैग तत्व टैग है, और गुण एक विशेषता वस्तु है।

आगे बढ़ने से पहले समझने के लिए अन्य महत्वपूर्ण तरीके हैं -

मेक_पर्सर विधि

निम्न विधि एक नया पार्सर ऑब्जेक्ट बनाता है और इसे वापस करता है। बनाया गया पार्सर ऑब्जेक्ट पहले पार्सर प्रकार का होगा, सिस्टम पाता है।

xml.sax.make_parser( [parser_list] )

यहाँ मापदंडों का विवरण दिया गया है -

• parser_list - वैकल्पिक तर्क जिसमें पार्सरों की एक सूची शामिल है, जिसका उपयोग करने के लिए सभी को मेक_पर्सर विधि लागू करनी चाहिए।

पार्स विधि

निम्न विधि SAX पार्सर बनाता है और इसका उपयोग किसी दस्तावेज़ को पार्स करने के लिए करता है।

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

यहाँ मापदंडों का विवरण दिया गया है -

• xmlfile - यह पढ़ने के लिए XML फ़ाइल का नाम है।

• contenthandler - यह एक ContentHandler ऑब्जेक्ट होना चाहिए।

• errorhandler - यदि निर्दिष्ट किया गया है, तो एरैंडहैंडलर SAX ErrorHandler ऑब्जेक्ट होना चाहिए।

ParseString विधि

SAX पार्सर बनाने और निर्दिष्ट पार्स करने के लिए एक और तरीका है XML string।

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

यहाँ मापदंडों का विवरण दिया गया है -

• xmlstring - यह पढ़ने के लिए XML स्ट्रिंग का नाम है।

• contenthandler - यह एक ContentHandler ऑब्जेक्ट होना चाहिए।

• errorhandler - यदि निर्दिष्ट किया गया है, तो एरैंडहैंडलर SAX ErrorHandler ऑब्जेक्ट होना चाहिए।

उदाहरण

#!/usr/bin/python3

import xml.sax

class MovieHandler( xml.sax.ContentHandler ):
   def __init__(self):
      self.CurrentData = ""
      self.type = ""
      self.format = ""
      self.year = ""
      self.rating = ""
      self.stars = ""
      self.description = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # Call when an elements ends
   def endElement(self, tag):
      if self.CurrentData == "type":
         print ("Type:", self.type)
      elif self.CurrentData == "format":
         print ("Format:", self.format)
      elif self.CurrentData == "year":
         print ("Year:", self.year)
      elif self.CurrentData == "rating":
         print ("Rating:", self.rating)
      elif self.CurrentData == "stars":
         print ("Stars:", self.stars)
      elif self.CurrentData == "description":
         print ("Description:", self.description)
      self.CurrentData = ""

   # Call when a character is read
   def characters(self, content):
      if self.CurrentData == "type":
         self.type = content
      elif self.CurrentData == "format":
         self.format = content
      elif self.CurrentData == "year":
         self.year = content
      elif self.CurrentData == "rating":
         self.rating = content
      elif self.CurrentData == "stars":
         self.stars = content
      elif self.CurrentData == "description":
         self.description = content
  
if ( __name__ == "__main__"):
   
   # create an XMLReader
   parser = xml.sax.make_parser()
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)

   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

उत्पादन

यह निम्नलिखित परिणाम का उत्पादन करेगा -

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

एसएएक्स एपीआई प्रलेखन पर पूर्ण विवरण के लिए, कृपया मानक पायथन एसएएक्स एपीआई का संदर्भ लें ।

DOM API के साथ XML को पार्स करना

दस्तावेज़ ऑब्जेक्ट मॉडल ("DOM") XML दस्तावेज़ों तक पहुँचने और संशोधित करने के लिए वर्ल्ड वाइड वेब कंसोर्टियम (W3C) से एक क्रॉस-भाषा एपीआई है।

DOM रैंडम-एक्सेस एप्लिकेशन के लिए बेहद उपयोगी है। SAX आपको केवल एक समय में दस्तावेज़ के एक बिट के दृश्य की अनुमति देता है। यदि आप एक एसएएक्स तत्व को देख रहे हैं, तो आपके पास दूसरे तक पहुंच नहीं है।

यहां XML दस्तावेज़ को जल्दी से लोड करने और xml.dom मॉड्यूल का उपयोग करके एक मिनीडोम ऑब्जेक्ट बनाने का सबसे आसान तरीका है। मिनिडॉम ऑब्जेक्ट एक साधारण पार्सर विधि प्रदान करता है जो एक्सएमएल फ़ाइल से जल्दी से एक डोम ट्री बनाता है।

नमूना वाक्यांश पार्स (ऑब्जेक्ट [फ़ाइल, पार्सर]) को एक्सिड ट्री ट्री ऑब्जेक्ट में फ़ाइल द्वारा निर्दिष्ट XML फ़ाइल को पार्स करने के लिए मिनीडोम ऑब्जेक्ट का कार्य कहता है।

उदाहरण

#!/usr/bin/python3

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)

उत्पादन

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

DOM API प्रलेखन पर पूर्ण विवरण के लिए, कृपया मानक Python DOM APIs देखें ।