पायथन के साथ मिनीडोम के साथ तत्व मूल्य प्राप्त करें

Question

मैं पायथन में ईव ऑनलाइन एपीआई के लिए एक जीयूआई दृश्यपटल बना रहा हूं।

मैंने उनके सर्वर से XML डेटा को सफलतापूर्वक खींच लिया है।

मैं "नाम" नामक नोड से मान को हथियाने की कोशिश कर रहा हूं:

from xml.dom.minidom import parse
dom = parse("C:\\eve.xml")
name = dom.getElementsByTagName('name')
print name

यह नोड खोजने के लिए लगता है, लेकिन आउटपुट नीचे है:

[<DOM Element: name at 0x11e6d28>]

मैं इसे नोड के मूल्य को प्रिंट करने के लिए कैसे प्राप्त कर सकता हूं?

Comments

यह सबसे "मिनिडोम" सवालों के जवाब की तरह लग रहा है "एलीमेंटट्री का उपयोग करें"।

— वारेन P

Answer 1

यह सिर्फ होना चाहिए

name[0].firstChild.nodeValue

Comments

जब मैं नाम [0] .nodeValue वापस देता है "कोई नहीं", बस परीक्षण करने के लिए मैंने इसे नाम दे दिया [0] .nodeName और इसने मुझे "नाम" दिया जो सही है। कोई विचार?

— रेल्सन

नाम के बारे में क्या है [0]।

— शराबी

बस सावधान रहें कि आप xml- जनरेटर में कार्यान्वयन विवरण पर भरोसा नहीं कर रहे हैं। कोई गारंटी देता है कि पहला बच्चा है पाठ नोड है और न ही केवल किसी भी मामले में पाठ नोड जहां एक से अधिक बच्चे नोड हो सकता है।

— हेनरिक गुस्ताफसन

कोई भी ऐसा पुस्तकालय क्यों डिज़ाइन करेगा, जिसमें <name> स्मिथ </ name> का नोडवैल कुछ भी हो लेकिन "स्मिथ" ?! उस छोटी सी डली की कीमत मेरे बालों को फाड़ने के 30 मिनट थी। मैं अब गंजा हूं। धन्यवाद, minidom

— असफ लवी

यह सिर्फ इस तरह से है क्योंकि उन्होंने इसे html के साथ काम करने के लिए डिज़ाइन किया है, इस तरह के तत्वों के लिए अनुमति देने के लिए इस तरह के <नोडए> कुछ पाठ <नोडिंथेमेल्ड> __ complex__structure __ </ नोडिंटहेल्ड> कुछ और पाठ </ नोडए>, इस मामले में आपको लगता है कि नोड का नोडवैल्यू सभी पाठ सम्‍मिलित होना चाहिए जिसमें जटिल संरचना, या केवल 2 पाठ नोड और मध्य नोड शामिल हैं। इसे देखने का सबसे अच्छा तरीका नहीं है, लेकिन मैं देख सकता हूं कि उन्होंने ऐसा क्यों किया।

— जोश मैक

Answer 2

शायद ऐसा ही कुछ है अगर यह पाठ हिस्सा आप चाहते हैं ...

from xml.dom.minidom import parse
dom = parse("C:\\eve.xml")
name = dom.getElementsByTagName('name')

print " ".join(t.nodeValue for t in name[0].childNodes if t.nodeType == t.TEXT_NODE)

नोड का टेक्स्ट हिस्सा अपने आप में एक नोड माना जाता है, जिसे आप जिस बच्चे के लिए कहते हैं, उसके बच्चे के नोड के रूप में रखा जाता है। इस प्रकार आप अपने सभी बच्चों के माध्यम से जाना चाहते हैं और उन सभी बाल नोड्स को ढूंढना चाहते हैं जो पाठ नोड्स हैं। एक नोड में कई पाठ नोड हो सकते हैं; जैसे।

<name>
  blabla
  <somestuff>asdf</somestuff>
  znylpx
</name>

आप 'ब्लाब्ला' और 'znylpx' दोनों चाहते हैं; इसलिए "" .join ()। आप अंतरिक्ष को एक नई रेखा के साथ बदलना चाह सकते हैं, या शायद कुछ भी नहीं।

Answer 3

आप इस तरह से कुछ का उपयोग कर सकते हैं। यह मेरे लिए काम किया

doc = parse('C:\\eve.xml')
my_node_list = doc.getElementsByTagName("name")
my_n_node = my_node_list[0]
my_child = my_n_node.firstChild
my_text = my_child.data 
print my_text

Answer 4

मुझे पता है कि यह प्रश्न अभी बहुत पुराना है, लेकिन मुझे लगा कि एलीमेंटट्री के साथ आपके पास एक आसान समय हो सकता है

from xml.etree import ElementTree as ET
import datetime

f = ET.XML(data)

for element in f:
    if element.tag == "currentTime":
        # Handle time data was pulled
        currentTime = datetime.datetime.strptime(element.text, "%Y-%m-%d %H:%M:%S")
    if element.tag == "cachedUntil":
        # Handle time until next allowed update
        cachedUntil = datetime.datetime.strptime(element.text, "%Y-%m-%d %H:%M:%S")
    if element.tag == "result":
        # Process list of skills
        pass

मुझे पता है कि यह सुपर विशिष्ट नहीं है, लेकिन मैंने अभी इसे खोजा है, और अब तक मेरे सिर को मिनीडोम की तुलना में चारों ओर प्राप्त करना बहुत आसान है (क्योंकि इतने सारे नोड अनिवार्य रूप से सफेद स्थान हैं)।

उदाहरण के लिए, आपके पास टैग नाम और साथ में वास्तविक पाठ है, जैसा कि आप शायद उम्मीद करेंगे:

>>> element[0]
<Element currentTime at 40984d0>
>>> element[0].tag
'currentTime'
>>> element[0].text
'2010-04-12 02:45:45'e

Answer 5

उपरोक्त उत्तर सही है, अर्थात्:

name[0].firstChild.nodeValue

हालांकि मेरे लिए, दूसरों की तरह, मेरा मूल्य पेड़ के नीचे था:

name[0].firstChild.firstChild.nodeValue

इसे खोजने के लिए मैंने निम्नलिखित प्रयोग किया:

def scandown( elements, indent ):
    for el in elements:
        print("   " * indent + "nodeName: " + str(el.nodeName) )
        print("   " * indent + "nodeValue: " + str(el.nodeValue) )
        print("   " * indent + "childNodes: " + str(el.childNodes) )
        scandown(el.childNodes, indent + 1)

scandown( doc.getElementsByTagName('text'), 0 )

Inkscape के साथ बनाई गई मेरी सरल SVG फ़ाइल के लिए इसे चलाने से मुझे यह मिला:

nodeName: text
nodeValue: None
childNodes: [<DOM Element: tspan at 0x10392c6d0>]
   nodeName: tspan
   nodeValue: None
   childNodes: [<DOM Text node "'MY STRING'">]
      nodeName: #text
      nodeValue: MY STRING
      childNodes: ()
nodeName: text
nodeValue: None
childNodes: [<DOM Element: tspan at 0x10392c800>]
   nodeName: tspan
   nodeValue: None
   childNodes: [<DOM Text node "'MY WORDS'">]
      nodeName: #text
      nodeValue: MY WORDS
      childNodes: ()

मैंने xml.dom.minidom का उपयोग किया, इस पृष्ठ पर विभिन्न क्षेत्रों को समझाया गया है, मिनीडोम पायथन।

Answer 6

मेरे पास एक समान मामला था, मेरे लिए क्या काम किया गया था:

name.firstChild.childNodes [0] .data

XML को सरल माना जाता है और यह वास्तव में है और मुझे नहीं पता कि अजगर के मिनीडोम ने इसे इतना जटिल क्यों बनाया ... लेकिन यह कैसे बनाया गया

Answer 7

यहाँ हेनरिक के कई नोड्स के लिए थोड़ा संशोधित उत्तर दिया गया है (जैसे। जब getElementsByTagName एक से अधिक उदाहरणों के लिए रिटर्न देता है)

images = xml.getElementsByTagName("imageUrl")
for i in images:
    print " ".join(t.nodeValue for t in i.childNodes if t.nodeType == t.TEXT_NODE)

Answer 8

प्रश्न का उत्तर दिया गया है, मेरे योगदान में एक बात स्पष्ट है जो शुरुआती लोगों को भ्रमित कर सकती है:

सुझाए गए और सही जवाबों में से कुछ का इस्तेमाल किया firstChild.dataऔर दूसरों के firstChild.nodeValueबजाय इस्तेमाल किया। यदि आप सोच रहे हैं कि उन दोनों के बीच क्या अंतर है, तो आपको याद रखना चाहिए कि वे एक ही काम करते हैं क्योंकि nodeValueयह केवल एक उपनाम है data।

मेरे बयान के संदर्भ को मिनीडोम के स्रोत कोड पर एक टिप्पणी के रूप में पाया जा सकता है :

# के nodeValueलिए एक उपनाम हैdata

Answer 9

यह एक पेड़ है, और इसमें नेस्टेड तत्व हो सकते हैं। प्रयत्न:

def innerText(self, sep=''):
    t = ""
    for curNode in self.childNodes:
        if (curNode.nodeType == Node.TEXT_NODE):
            t += sep + curNode.nodeValue
        elif (curNode.nodeType == Node.ELEMENT_NODE):
            t += sep + curNode.innerText(sep=sep)
    return t