ब्यूटीफुल का उपयोग करके नोड्स के बच्चों को कैसे खोजें

Question

मैं उन सभी <a>टैगों को प्राप्त करना चाहता हूं जो निम्नलिखित हैं <li>:

<div>
<li class="test">
    <a>link1</a>
    <ul> 
       <li>  
          <a>link2</a> 
       </li>
    </ul>
</li>
</div>

मुझे पता है कि इस तरह विशेष वर्ग के साथ तत्व को कैसे खोजना है:

soup.find("li", { "class" : "test" }) 

लेकिन मुझे नहीं पता कि सभी कैसे मिल सकते हैं <a>जो <li class=test>कि किसी और के बच्चे नहीं हैं।

जैसे मैं चयन करना चाहता हूं:

<a>link1</a>

Answer 1

इसे इस्तेमाल करे

li = soup.find('li', {'class': 'text'})
children = li.findChildren("a" , recursive=False)
for child in children:
    print child

Comments

या, केवल उस अभिव्यक्ति को निकालने के लिए जो यह वर्णन करती है कि हम क्या चाहते हैं soup.find('li', {'class': 'text'}).findChildren():।

— कार्ल केनचेल

लेकिन केवल वार्ड के बाद ही फ्रिस्तोग्राफी टैग कैसे प्राप्त करें। कुछ इस तरहfind(li).find(a).firstChild()

— Tej.tan

"पुनरावर्ती" क्वर्ग के लिए धन्यवाद :)

— स्विफ्ट

Answer 2

DOCs में एक सुपर छोटा खंड है जो दिखाता है कि कैसे / पाएं प्रत्यक्ष बच्चों को।

https://www.crummy.com/software/BeautifulSoup/bs4/doc/#the-recursive-argument

आपके मामले में जैसा कि आप चाहते हैं कि link1 जो पहले प्रत्यक्ष बच्चा हो:

# for only first direct child
soup.find("li", { "class" : "test" }).find("a", recursive=False)

यदि आप सभी प्रत्यक्ष बच्चे चाहते हैं:

# for all direct children
soup.find("li", { "class" : "test" }).findAll("a", recursive=False)

Answer 3

शायद आप करना चाहते हैं

soup.find("li", { "class" : "test" }).find('a')

Comments

मुझे लगता है कि यह <a> link2 </a>अच्छी तरह से मिल जाएगा, लेकिन मैं नहीं चाहता कि

— 2

यह प्रश्न में दिए <a>link1</a>गए HTML में चयन करने के तरीके का उत्तर देता है , लेकिन यह तब विफल होगा जब पहले <li class="test">में कोई <a>तत्व नहीं होंगे और वर्ग के liसाथ अन्य तत्व testहैं <a>।

— राडज़क

Answer 4

इसे इस्तेमाल करे:

li = soup.find("li", { "class" : "test" })
children = li.find_all("a") # returns a list of all <a> children of li

अन्य अनुस्मारक:

खोज विधि केवल पहले होने वाले बाल तत्व को प्राप्त करती है। Find_all मेथड को सभी वंशज तत्व मिलते हैं और एक सूची में संग्रहीत किया जाता है।

Comments

प्रश्नकर्ता ऊपर दो विकल्पों में से कोई भी नहीं चाहता है। वह सभी लिंक चाहता है जो केवल प्रत्यक्ष बच्चे हैं।

— अहसन रॉय

Answer 5

"उन सभी को कैसे ढूंढा जाए aजो <li class=test>किसी और के नहीं बल्कि बच्चों के हैं?"

नीचे दिए गए HTML को देखते हुए (मैंने और <a>अंतर दिखाने के लिए एक और जोड़ा ):selectselect_one

<div>
  <li class="test">
    <a>link1</a>
    <ul>
      <li>
        <a>link2</a>
      </li>
    </ul>
    <a>link3</a>
  </li>
</div>

समाधान बाल कॉम्बिनेटर ( >) का उपयोग करना है जो दो सीएसएस चयनकर्ताओं के बीच रखा गया है:

>>> soup.select('li.test > a')
[<a>link1</a>, <a>link3</a>]

मामले में आप केवल पहला बच्चा ढूंढना चाहते हैं:

>>> soup.select_one('li.test > a')
<a>link1</a>

Comments

यह वही है जिसकी मुझे तलाश थी। मैं इसे गलत तरीके से सप्लाई कर रहा था। भूल गया> एक CSS चयनकर्ता है। धन्यवाद!

— LFMekz

Answer 6

फिर भी एक अन्य विधि - एक फ़िल्टर फ़ंक्शन बनाएं जो Trueसभी वांछित टैग के लिए वापस आए :

def my_filter(tag):
    return (tag.name == 'a' and
        tag.parent.name == 'li' and
        'test' in tag.parent['class'])

तो बस find_allतर्क के साथ कॉल करें :

for a in soup(my_filter): # or soup.find_all(my_filter)
    print a