R Academy · पाठ

html_element() और html_text() की मूल बातें

स्क्रैप किए गए पेजों से टेक्स्ट, एट्रिब्यूट और तालिका डेटा निकालें।

पाठ 2, कुल 4 में से13 चरण

html_element() और html_text() की मूल बातें, CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

read_html(): पृष्ठ लोड करना

read_html() rvest का प्रवेश-बिंदु है। इसमें कोई URL या कच्ची HTML स्ट्रिंग दीजिए। यह पार्स किए गए DOM वृक्ष को दर्शाने वाला xml_document ऑब्जेक्ट लौटाता है, जो क्वेरी करने के लिए तैयार होता है।

library(rvest)

# From a URL (requires internet connection)
# page <- read_html('https://books.toscrape.com')

# From a raw HTML string (great for testing)
page <- read_html('
  <html><body>
    <h1>Book Store</h1>
    <p class="desc">Over 1000 books!</p>
  </body></html>
')
class(page)  # 'xml_document' 'xml_node'

html_element() बनाम html_elements()

html_element() मेल खाने वाले पहले नोड को लौटाता है (या कुछ न मिलने पर NA)। html_elements() मेल खाने वाले सभी नोड को एक सूची के रूप में लौटाता है। जब आपको ठीक एक परिणाम की अपेक्षा हो, तब एकवचन फ़ंक्शन का और सूचियों को स्क्रैप करते समय बहुवचन फ़ंक्शन का उपयोग कीजिए।

library(rvest)
page <- read_html('
  <ul>
    <li class="item">Apple</li>
    <li class="item">Banana</li>
    <li class="item">Cherry</li>
  </ul>
')
# Singular: gets first match
first_item <- html_element(page, '.item')
html_text2(first_item)  # 'Apple'

# Plural: gets all matches
all_items <- html_elements(page, '.item')
html_text2(all_items)  # c('Apple', 'Banana', 'Cherry')
length(all_items)  # 3

स्वच्छ पाठ के लिए html_text2()

html_text2() नोड से पाठ्य सामग्री निकालता है, HTML टैग हटाता है और रिक्त स्थान को सुव्यवस्थित रूप से समेटता है। यह <br> को नई पंक्तियों के रूप में संभालता है। पुराना html_text() रिक्त स्थान को उतनी अच्छी तरह नहीं संभालता।

library(rvest)
page <- read_html('
  <div class="product">
    <h2>  Laptop  </h2>
    <p>Price: <strong>$999</strong></p>
    <p>  Free   shipping  </p>
  </div>
')
# html_text2 trims whitespace intelligently
title <- html_element(page, 'h2')
html_text2(title)  # 'Laptop' (no extra spaces)

# From the whole div - collapses nested text
div <- html_element(page, '.product')
html_text2(div)  # 'Laptop\nPrice: $999\nFree shipping'

html_attr(): एट्रिब्यूट निकालना

html_attr(node, 'attr_name') किसी HTML एट्रिब्यूट का मान निकालता है। लिंक से href, चित्रों से src, data-* एट्रिब्यूट और अन्य मान प्राप्त करने के लिए यह आवश्यक है।

library(rvest)
page <- read_html('
  <div>
    <a href="https://example.com" title="Example site">Visit</a>
    <img src="/images/photo.jpg" alt="A photo">
    <div data-price="29.99">Product</div>
  </div>
')
# Extract href from link
link <- html_element(page, 'a')
html_attr(link, 'href')  # 'https://example.com'
html_attr(link, 'title')  # 'Example site'

# Extract src from image
img <- html_element(page, 'img')
html_attr(img, 'src')  # '/images/photo.jpg'

# Extract data attributes
div <- html_element(page, 'div[data-price]')
html_attr(div, 'data-price')  # '29.99'

html_attrs(): सभी एट्रिब्यूट

html_attrs(node) किसी नोड के सभी एट्रिब्यूट का नामित वर्ण सदिश लौटाता है। जब आपको पहले से एट्रिब्यूट के नाम ज्ञात न हों या किसी तत्व में उपलब्ध एट्रिब्यूट देखना हो, तब यह उपयोगी है।

library(rvest)
page <- read_html('
  <a href="/page" class="nav-link" id="home" data-section="main">Home</a>
')
link <- html_element(page, 'a')

# Get all attributes at once
attrs <- html_attrs(link)
attrs
# href        class        id           data-section
# '/page'     'nav-link'   'home'       'main'

# Access by name
attrs['href']   # '/page'
attrs['class']  # 'nav-link'
names(attrs)    # all attribute names

html_children(): चाइल्ड नोड

html_children(node) किसी तत्व के तात्कालिक चाइल्ड नोड लौटाता है। टैग नाम प्राप्त करने के लिए इसे html_name() के साथ उपयोग करना प्रोग्राम के माध्यम से पृष्ठ की संरचना समझने में उपयोगी है।

library(rvest)
page <- read_html('
  <nav>
    <a href="/">Home</a>
    <a href="/about">About</a>
    <span>|</span>
    <a href="/contact">Contact</a>
  </nav>
')
nav <- html_element(page, 'nav')

# Get all direct children
kids <- html_children(nav)
length(kids)  # 4

# Get tag names of children
html_name(kids)  # c('a', 'a', 'span', 'a')

# Filter to only anchor children
links <- kids[html_name(kids) == 'a']
html_text2(links)  # c('Home', 'About', 'Contact')

html_name(): टैग नाम

html_name(node) किसी नोड का टैग नाम छोटे अक्षरों वाली स्ट्रिंग के रूप में लौटाता है (जैसे, 'div', 'p', 'a')। प्राप्ति के बाद नोड सूचियों को तत्व के प्रकार के आधार पर फ़िल्टर करने में यह उपयोगी है।

library(rvest)
page <- read_html('
  <article>
    <h2>Title</h2>
    <p>First paragraph.</p>
    <img src="img.jpg">
    <p>Second paragraph.</p>
  </article>
')
article <- html_element(page, 'article')
all_children <- html_children(article)

# Check tag name of each child
html_name(all_children)
# c('h2', 'p', 'img', 'p')

# Get only paragraph children
paras <- all_children[html_name(all_children) == 'p']
html_text2(paras)
# c('First paragraph.', 'Second paragraph.')

चयन श्रृंखलाबद्ध करना

आप html_element() के पहले तर्क के रूप में केवल दस्तावेज़ ही नहीं, बल्कि कोई नोड भी दे सकते हैं। इससे खोज उसी नोड के भीतर सीमित हो जाती है—उत्पाद कार्ड या तालिका पंक्तियों जैसी दोहराई जाने वाली संरचनाओं को स्क्रैप करने के लिए यह अत्यंत महत्वपूर्ण है।

library(rvest)
page <- read_html('
  <div class="card">
    <h3>Laptop</h3>
    <span class="price">$999</span>
  </div>
  <div class="card">
    <h3>Phone</h3>
    <span class="price">$499</span>
  </div>
')
# Get all cards, then extract fields from each
cards <- html_elements(page, '.card')

names_list <- html_text2(html_elements(page, '.card h3'))
prices_list <- html_text2(html_elements(page, '.card .price'))

data.frame(name = names_list, price = prices_list)

NodeSet पर html_attr

नोडसमूह (html_elements() का परिणाम) पर लागू किए जाने पर html_attr() एट्रिब्यूट मानों का एक सदिश लौटाता है—प्रत्येक नोड के लिए एक मान। अनुपस्थित एट्रिब्यूट के लिए NA लौटाया जाता है।

library(rvest)
page <- read_html('
  <ul>
    <li><a href="/page1">Page 1</a></li>
    <li><a href="/page2">Page 2</a></li>
    <li><span>No link</span></li>
    <li><a href="/page3">Page 3</a></li>
  </ul>
')
# Get all a elements
links <- html_elements(page, 'a')

# html_attr on a nodeset returns a vector
hrefs <- html_attr(links, 'href')
hrefs  # c('/page1', '/page2', '/page3')

# Link text alongside hrefs
texts <- html_text2(links)
data.frame(text = texts, href = hrefs)

अनुपस्थित तत्वों को संभालना

जब कुछ भी मेल नहीं खाता, तब html_element() NULL नहीं, बल्कि NA नोड लौटाता है। NA नोड पर html_text2() लगाने से NA_character_ लौटता है। जब तत्व वैकल्पिक हो सकते हों, तब अपने परिणामों में NA की जाँच हमेशा कीजिए।

library(rvest)
page <- read_html('
  <div class="product">
    <h3>Widget</h3>
    <!-- No price tag here -->
  </div>
')
# Element exists
title <- html_element(page, 'h3')
html_text2(title)  # 'Widget'

# Element does NOT exist -> NA node
price <- html_element(page, '.price')
html_text2(price)  # NA
is.na(html_text2(price))  # TRUE

# Safe extraction with default
price_text <- html_text2(price)
if (is.na(price_text)) price_text <- 'N/A'
price_text  # 'N/A'

सभी भागों को एक साथ उपयोग करना

संरचित डेटा को डेटा फ़्रेम में स्क्रैप करने के लिए html_elements(), html_text2() और html_attr() को मिलाकर उपयोग कीजिए—rvest के साथ वेब स्क्रैपिंग का सामान्य अंतिम लक्ष्य यही होता है।

library(rvest)
page <- read_html('
  <div class="book">
    <a href="/book/1" class="title">R Programming</a>
    <span class="author">Hadley Wickham</span>
    <span class="rating" data-stars="5">*****</span>
  </div>
  <div class="book">
    <a href="/book/2" class="title">Advanced R</a>
    <span class="author">Hadley Wickham</span>
    <span class="rating" data-stars="5">*****</span>
  </div>
')
titles  <- html_text2(html_elements(page, '.title'))
authors <- html_text2(html_elements(page, '.author'))
links   <- html_attr(html_elements(page, 'a.title'), 'href')
ratings <- html_attr(html_elements(page, '.rating'), 'data-stars')
data.frame(title=titles, author=authors, link=links, stars=ratings)

त्वरित जाँच

HTML दस्तावेज़ों में नेविगेट करने के लिए rvest के मुख्य फ़ंक्शन के अपने ज्ञान की जाँच कीजिए।

पुनरावलोकन: rvest के मुख्य फ़ंक्शन

मुख्य बातें: read_html() पृष्ठ लोड करता है; html_element() पहला मेल प्राप्त करता है; html_elements() सभी मेल प्राप्त करता है। पाठ को html_text2() से, एट्रिब्यूट को html_attr() से, चाइल्ड नोड को html_children() से और टैग नाम को html_name() से निकालिए। अनुपस्थित तत्व NA नोड लौटाते हैं—उत्पादन-स्तर के स्क्रैपर में NA को हमेशा संभालिए।

library(rvest)
# Core rvest workflow:
# 1. Load page
# page <- read_html(url)

# 2. Find elements
# node  <- html_element(page, 'css-selector')
# nodes <- html_elements(page, 'css-selector')

# 3. Extract content
# html_text2(node)        -> text content
# html_attr(node, 'href') -> attribute value
# html_attrs(node)        -> all attributes
# html_name(node)         -> tag name
# html_children(node)     -> child nodes

# 4. Build data frame
# data.frame(title = html_text2(...), link = html_attr(...))
cat('rvest follows the tidy data philosophy')
शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
43
पाठ
159

अक्सर पूछे जाने वाले प्रश्न

क्या “html_element() और html_text() की मूल बातें” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “html_element() और html_text() की मूल बातें” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“html_element() और html_text() की मूल बातें” में मैं क्या सीखूँगा?

स्क्रैप किए गए पेजों से टेक्स्ट, एट्रिब्यूट और तालिका डेटा निकालें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“html_element() और html_text() की मूल बातें” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. HTML संरचना और CSS चयनकर्ता
  2. html_element() और html_text() की मूल बातें
  3. तालिकाएँ और लिंक स्क्रैप करना
  4. पृष्ठांकन और अनेक पेज संभालना
← R Academy पर वापस जाएँ