TL;DR:

• Scrapeless यूनिवर्सल स्क्रैपिंग एपीआई एक सार्वजनिक पृष्ठ के लिए रेंडर्ड HTML लौटाता है, और पांडा read_html उस पृष्ठ पर तालिकाओं को एकल कॉल में DataFrames में बदल देता है।
• यह गाइड काम को पांच स्पष्ट चरणों में बनाता है: प्राप्त करना, खोज करना, निकालना, बदलना, और संग्रहित करना, जो प्रत्येक कुछ पंक्तियों का पायथन कोड है।
• पांडा 3.x में, read_html को HTML स्ट्रिंग के चारों ओर एक io.StringIO नकली वस्तु की आवश्यकता होती है, क्योंकि एक साधारण स्ट्रिंग अब फाइल पथ के रूप में पढ़ी जाती है और एक त्रुटि उत्पन्न करती है।
• स्वच्छता निकासी के बाद आती है: कॉलम का नाम बदलें, pd.to_numeric का उपयोग करके संख्यात्मक प्रकारों को मजबूर करें, और किसी भी चीज़ को डिस्क पर लिखे जाने से पहले व्युत्पन्न कॉलम जोड़ें।
• पार्क्वेट कॉलम प्रकारों को बनाए रखता है लेकिन CSV से स्वचालित रूप से छोटा नहीं होता; 75-पंक्ति नमूने पर इसके फुटर ओवरहेड के कारण यह बड़ा फ़ाइल बनता है, और आकार का लाभ वॉल्यूम के साथ आता है।
• Scrapeless मुफ्त योजना पर शुरू करें और प्राप्त करने के चरण को अपने स्रोत पर इंगित करें।

अधिकतर पांडा ट्यूटोरियल एक CSV के साथ शुरू होते हैं जो पहले से मौजूद है। असली काम वहां से कभी शुरू नहीं होता है। आप जो आँकड़े चाहते हैं वे एक HTML पृष्ठ के अंदर हैं, जो नेविगेशन, शैली और मार्कअप में लिपटे हुए हैं कि एक साधारण requests.get अक्सर साफ-सुथरे तरीके से भी प्राप्त नहीं कर सकता। "उस पृष्ठ पर एक तालिका है" और "मेरीMemory में एक Typed DataFrame है" के बीच का अंतर एक स्क्रैपिंग पाइपलाइन में रहता है।

यह पोस्ट इस अंतर को दो टूल के साथ समाप्त करती है। Scrapeless यूनिवर्सल स्क्रैपिंग एपीआई पुनर्प्राप्ति हैंडल करता है और पृष्ठ को HTML के रूप में लौटाता है। पांडा संरचना संभालता है: यह तालिकाओं को पढ़ता है, उन्हें साफ करता है, और टाइप की गई फ़ाइलें लिखता है जिन्हें आप विश्लेषण कर सकते हैं। उदाहरण लक्ष्य एक सार्वजनिक स्क्रैपिंग सैंडबॉक्स है जिसमें NHL टीम सीज़न की पृष्ठांकित तालिका है, इसलिए नीचे हर संख्या एक वास्तविक पृष्ठ के खिलाफ एक वास्तविक रन से आती है।

पाइपलाइन एक नज़र में

पाइपलाइन में पांच चरण हैं, और प्रत्येक एकल, स्पष्ट रूप से परिभाषित वस्तु को अगले चरण को सौंपता है:

प्राप्त करना (HTML स्ट्रिंग) → खोज करना (कौन सी तालिका) → निकालना (DataFrame) → बदलना (टाइप किया गया, साफ DataFrame) → संग्रहित करना (CSV + पार्क्वेट)

चरणों को अलग रखना तब लाभकारी होता है जब एक पृष्ठ बदलता है। जब लेआउट बदलता है, केवल खोज चरण चलता है। जब कोई कॉलम टेक्स्ट के रूप में आने लगता है, तो केवल रूपांतरण चरण बदलता है। प्राप्त करना और संग्रहित करना चरण बिना छेड़े रहते हैं।

चरण 1: पृष्ठ को साफ HTML के रूप में प्राप्त करना

प्राप्त करने के चरण का एक अनुरोध Scrapeless को भेजता है और पृष्ठ को HTML स्ट्रिंग के रूप में लौटाता है। अनुरोध में एक actor और एक input वस्तु होती है; unlocker.webunlocker अभिनेता पृष्ठ को पुनर्प्राप्त करता है, और एपीआई कुंजी x-api-token हेडर में जाती है।

इस पाइपलाइन को तीन पैकेजों की आवश्यकता है: पांडा स्वयं, read_html के लिए एक पार्सर, और संग्रहित करने के चरण के लिए एक पार्क्वेट इंजन। सभी तीन को एक साथ स्थापित करें।

pip install pandas pyarrow lxml

import io
import json
import os
import urllib.request

import pandas as pd

API_URL = "https://api.scrapeless.com/api/v2/unlocker/request"


def fetch_html(url: str) -> str:
    payload = json.dumps(
        {"actor": "unlocker.webunlocker", "input": {"url": url, "js_render": False, "headless": False}}
    ).encode()
    request = urllib.request.Request(
        API_URL,
        data=payload,
        headers={"x-api-token": os.environ["SCRAPELESS_API_KEY"], "Content-Type": "application/json"},
        method="POST",
    )
    with urllib.request.urlopen(request, timeout=90) as response:
        return json.loads(response.read())["data"]


html = fetch_html("https://www.scrapethissite.com/pages/forms/")
tables = pd.read_html(io.StringIO(html))
df = tables[0]
print(f"पृष्ठ पर तालिकाएँ: {len(tables)} | आकार: {df.shape}")
print("कच्चे कॉलम:", list(df.columns))

प्रतिक्रिया शरीर एक JSON लिफाफा है जिसमें रेंडर्ड मार्कअप data कुंजी के तहत है, इसलिए json.loads(response.read())["data"] पूरा पृष्ठ एक स्ट्रिंग के रूप में है। यहां js_render को जानबूझकर False पर सेट किया गया है, जिसे जब आपको रेंडर्ड पृष्ठ की आवश्यकता हो अनुभाग में समझाया गया है।

किसी भी चीज़ को चलाने से पहले एक बार अपने शेल में कुंजी सेट करें। रन टाइम पर असली कुंजी का उपयोग करें और प्लेसहोल्डर को अपने स्रोत से बाहर रखें।

export SCRAPELESS_API_KEY="sk_your_key_here"

चरण 2: तालिका का पता लगाना

खोज एक प्रश्न का उत्तर देती है: पृष्ठ पर कौन सी तालिका डेटा रखती है। उपरोक्त ब्लॉक को चलाने पर इस लक्ष्य का उत्तर प्रिंट होता है।

पृष्ठ पर तालिकाएँ: 1 | आकार: (25, 9)
कच्चे कॉलम: ['टीम का नाम', 'वर्ष', 'जीत', 'हार', 'ओटी हार', 'जीत %', 'गोल के लिए (GF)', 'गोल के खिलाफ (GA)', '+ / -']

read_html HTML को स्कैन करता है और हर <table> तत्व के लिए एक DataFrame के साथ एक सूची लौटाता है, जो कि HTML तालिका डेटा विनिर्देशन के समान तालिका मॉडल का पालन करता है। इस पृष्ठ पर एकल तालिका है, इसलिए tables[0] वही है जो आपको चाहिए। एक पृष्ठ पर जिसमें कई तालिकाएँ हैं, हर तालिका का आकार और पहले पंक्तियाँ प्रिंट करें, उस इंडेक्स को चुनें जो आपके कॉलम से मेल खाता है, और उस इंडेक्स को हार्ड-कोड करें। कच्चे कॉलम नाम सीधे <th> सेल से आते हैं, यही कारण है कि उनमें अभी भी रिक्त स्थान और विराम चिह्न हैं।

चरण 3: इसे DataFrame में पढ़ें

निष्कर्षण पहले से ही हो चुका है। यही read_html का उद्देश्य है: यह पूरी तालिका को बिना पंक्तियों और कोशिकाओं पर मैनुअल लूप के एक DataFrame में बदल देता है। pandas read_html संदर्भ io.StringIO आवश्यकता का दस्तावेज करता है जो अधिकांश पहले प्रयासों को पांडास 3.x पर रोकता है। एक नग्न HTML स्ट्रिंग एक फ़ाइल नाम के रूप में व्याख्यायित की जाती है; इसे io.StringIO(html) में लपेटना पांडास को स्ट्रिंग की स्वयं की पार्सिंग करने के लिए बताता है।

25 पंक्तियों और 9 कॉलमों के साथ, कच्चा फ्रेम उपयोगी है लेकिन अभी तक साफ नहीं है। कॉलम नाम अजीब हैं, और हर मूल्य वह प्रकार है जो HTML पार्सर ने अनुमानित किया। दोनों समस्याएँ अगले चरण की हैं।

चरण 4: डेटा को रूपांतरित करें और उसका प्रकार निर्धारित करें

रूपांतरण चरण तीन कार्य करता है: कॉलम के नाम को कुछ ऐसा बदलना जिसे आप टाइप कर सकें, मूल्यों को संख्याओं में मजबूर करना, और आपके विश्लेषण के लिए आवश्यक व्युत्पन्न कॉलम जोड़ना।

raw.columns = ["team", "year", "wins", "losses", "ot_losses", "win_pct", "goals_for", "goals_against", "goal_diff"]
numeric = ["year", "wins", "losses", "ot_losses", "win_pct", "goals_for", "goals_against", "goal_diff"]
raw[numeric] = raw[numeric].apply(pd.to_numeric, errors="coerce")
raw["games"] = raw["wins"] + raw["losses"] + raw["ot_losses"].fillna(0)
raw["winning_season"] = raw["win_pct"] >= 0.5
clean = raw.dropna(subset=["team", "wins"]).reset_index(drop=True)

pd.to_numeric के साथ errors="coerce" कार्यशीलता है। यह साफ संख्याओं को परिवर्तित करता है और जिसे पार्स नहीं किया जा सकता उसे NaN में बदल देता है बजाय इसके कि पूरी कॉलम विफल हो जाए, जो यहाँ महत्वपूर्ण है क्योंकि पुराने सत्रों में ओवरटाइम-हारे हुए सेल खाली छोड़ दिए जाते हैं। fillna(0) तब उन खाली स्थानों को खेलों की संख्या की गणना करते समय शून्य के रूप में मानता है, और dropna किसी भी पंक्ति को हटा देता है जिसमें टीम का नाम या जीत की संख्या गायब होती है। परिणाम एक फ्रेम है जहां हर संख्या वाली कॉलम सही ढंग से संख्या है और व्युत्पन्न games और winning_season कॉलम समूहित और फ़िल्टर करने के लिए तैयार हैं।

चरण 5: इसे CSV और Parquet के रूप में संग्रहित करें

भंडारण साफ फ्रेम को दो बार लिखता है, क्योंकि दो प्रारूप अलग-अलग आवश्यकताओं का उत्तर देते हैं।

clean.to_csv("teams.csv", index=False)
clean.to_parquet("teams.parquet", index=False)

CSV पोर्टेबल है और किसी भी चीज़ द्वारा पढ़ा जा सकता है, एक स्प्रेडशीट से लेकर एक शेल वन-लाइनर तक, और यह व्यापक रूप से लागू कोमा-सेपरेटेड वैल्यूज़ प्रारूप का पालन करता है। इसका मूल्य यह है कि प्रकार लेखन के क्षण पर गायब हो जाते हैं; हर कॉलम वापस आने पर टेक्स्ट होता है। Parquet स्कीमा को बनाए रखता है। जब आप teams.parquet को फिर से पढ़ते हैं, तो wins अभी भी एक पूर्णांक होता है और win_pct अभी भी एक फ्लोट होता है, बिना फिर से मजबूर किए, क्योंकि Apache Parquet फ़ाइल प्रारूप प्रत्येक कॉलम के प्रकार को उसके मूल्यों के साथ संग्रहीत करता है।

Parquet हमेशा छोटा फ़ाइल नहीं होता, चाहे लोककथाएँ क्या कहती हों। इस 75-पंक्ति नमूने पर CSV 4,379 बाइट्स है और Parquet फ़ाइल 8,999 बाइट्स है, क्योंकि Parquet के प्रति कॉलम मेटाडाटा और फुटर ठीक ओवरहेड होते हैं जिन्हें एक छोटे डेटासेट का अमोर्टाइज नहीं कर सकता। यदि आकार ही आपकी चिंता है तो छोटे परिणामों को CSV के रूप में संग्रहित करें। जब पंक्ति की संख्या हजारों में बढ़ जाती है और प्रकार, कॉलम पढ़ना बाइट की संख्या से अधिक महत्वपूर्ण हो जाता है, तो Parquet का उपयोग करें।

संपूर्ण पाइपलाइन

पांच चरणों को एक स्क्रिप्ट में रखें और पृष्ठांकन जोड़ें, और पाइपलाइन तीन पृष्ठ प्राप्त करती है, 75-पंक्ति का फ्रेम बनाती है, इसे साफ करती है, और दोनों फ़ाइलें लिखती है।

import io
import json
import os
import urllib.request

import pandas as pd

API_URL = "https://api.scrapeless.com/api/v2/unlocker/request"
BASE = "https://www.scrapethissite.com/pages/forms/"
PAGES = 3  # सीमित: सार्वजनिक सैंडबॉक्स तालिका के तीन पृष्ठ


def fetch_html(url: str) -> str:
    """चरण 1 - Scrapeless यूनिवर्सल स्क्रेपिंग API के माध्यम से रेंडर किए गए HTML को प्राप्त करें।"""
    payload = json.dumps(
        {"actor": "unlocker.webunlocker", "input": {"url": url, "js_render": False, "headless": False}}
    ).encode()
    request = urllib.request.Request(
        API_URL,
        data=payload,
        headers={"x-api-token": os.environ["SCRAPELESS_API_KEY"], "Content-Type": "application/json"},
        method="POST",
    )
    with urllib.request.urlopen(request, timeout=90) as response:
        return json.loads(response.read())["data"]

Here is the translated text in Hindi:

चरण 1-3 - प्रत्येक पृष्ठ को लाना, एकल तालिका का पता लगाना, इसे सीधे DataFrame में पढ़ना

फ्रेम = []
के लिए पृष्ठ में सीमा (1, PAGES + 1):
html = fetch_html(f"{BASE}?page_num={page}")
फ्रेम.append(pd.read_html(io.StringIO(html))[0])
कच्चा = pd.concat(फ्रेम, ignore_index=True)
print(f"पृष्ठ लाए गए: {PAGES} | पंक्तियाँ पार्स की गई: {len(raw)}")

चरण 4 - रूपांतरित करें: कॉलम नाम साफ करें, संख्यात्मक प्रकारों को मजबूर करें, व्युत्पन्न कॉलम जोड़ें

कच्चा.columns = ["टीम", "वर्ष", "जीत", "हार", "ओटी_हार", "जीत_प्रतिशत", "लक्ष्य_के_F", "लक्ष्य_के_खिलाफ", "लक्ष्य_अंतर"]
संख्यात्मक = ["वर्ष", "जीत", "हार", "ओटी_हार", "जीत_प्रतिशत", "लक्ष्य_के_F", "लक्ष्य_के_खिलाफ", "लक्ष्य_अंतर"]
कच्चा[संख्यात्मक] = कच्चा[संख्यात्मक].apply(pd.to_numeric, errors="coerce")
कच्चा["खेल"] = कच्चा["जीत"] + कच्चा["हार"] + कच्चा["ओटी_हार"].fillna(0)
कच्चा["जीत_का_ฤतु"] = कच्चा["जीत_प्रतिशत"] >= 0.5
स्वच्छ = कच्चा.dropna(subset=["टीम", "जीत"]).reset_index(drop=True)
print(f"स्वच्छ के बाद की पंक्तियाँ: {len(clean)} | जीतने वाले सीज़न: {int(clean['winning_season'].sum())}")

सर्वश्रेष्ठ = स्वच्छ.sort_values("जीत", ascending=False).iloc[0]
print(f"श्रेष्ठ सीज़न: {best['टीम']} {int(best['वर्ष'])} ({int(best['जीत'])} जीत)")

चरण 5 - फ्रेम को CSV के रूप में संग्रहित करें ताकि पोर्टेबिलिटी और टाइप कॉलम रीड के लिए Parquet

स्वच्छ.to_csv("teams.csv", index=False)
स्वच्छ.to_parquet("teams.parquet", index=False)
print(f"csv बाइट्स: {os.path.getsize('teams.csv')} | parquet बाइट्स: {os.path.getsize('teams.parquet')}")

चलाने से हर चरण का संक्षिप्त ट्रेस प्रिंट होता है:

```text
पृष्ठ लाए गए: 3 | पंक्तियाँ पार्स की गई: 75
स्वच्छ के बाद की पंक्तियाँ: 75 | जीतने वाले सीज़न: 26
श्रेष्ठ सीज़न: पिट्सबर्ग पेन्गुइन्स 1992 (56 जीत)
csv बाइट्स: 4379 | parquet बाइट्स: 8999

page_num क्वेरी पैरामीटर पेजिनेशन को नियंत्रित करता है, और PAGES रन को तीन पृष्ठों तक सीमित करता है ताकि उदाहरण छोटा और विनम्र बना रहे। उस स्थिरांक को बढ़ाएं ताकि कवरेज बढ़ सके, और इसे एक जगह रखें ताकि सीमा एक निर्णय हो, न कि एक दुर्घटना।

इस पाइपलाइन को एक स्रोत की ओर इंगित करें जिससे आप संबंधित हैं BASE URL और कॉलम नामों को बदलकर, और पाँच-चरणीय आकार अपरिवर्तित रहता है। यदि आप यह जानना चाहते हैं कि इन चरणों में से प्रत्येक कहां फिट होता है, तो ETL पाइपलाइन क्या है पर मार्गदर्शिका आपको सामान्य पैटर्न के रूप में निष्कर्षण, रूपांतरण और लोडिंग का परिचय देती है।

जब आपको एक रेंडर किया गया पृष्ठ की आवश्यकता हो

यह पाइपलाइन js_render को False पर सेट करती है, और यह एक जानबूझकर किया गया विकल्प है, न कि एक डिफ़ॉल्ट जो छोड़ना है। सैंडबॉक्स तालिका HTML में मौजूद है जो सर्वर भेजता है, इसलिए रेंडर करने के लिए कुछ नहीं है, और रेंडरिंग छोड़ने से प्रत्येक फ़ेच तेज़ हो जाता है। कई पृष्ठ अलग हैं: जो तालिका आप चाहते हैं वह प्रारंभिक HTML लोड होने के बाद JavaScript द्वारा इंजेक्ट की जाती है, और एक गैर-रेंडर्ड फ़ेच एक खाली खोल लौटाता है। जब read_html किसी पृष्ठ पर शून्य तालिकाएं पाती है, जिन्हें आप ब्राउज़र में देख सकते हैं, तो js_render को True पर सेट करें ताकि Scrapeless स्क्रिप्ट चलने के बाद पृष्ठ लौटाए। प्रत्येक स्रोत के लिए निर्णय लें, न कि हर जगह रेंडरिंग को चालू करने दें, क्योंकि जरूरत न होने पर रेंडर करने से केवल विलंब बढ़ता है।

आप इनमें से किसी भी चीज़ को स्केल करने से पहले, लक्षित के robots.txt और शर्तों को पढ़ें। रोबोट्स बहिष्करण प्रोटोकॉल आपको बताता है कि कोई साइट स्वचालित ग्राहकों से किन पथों को छोड़ने के लिए कहती है, और इसे मानना ​​एक डेटा पाइपलाइन को उन साइटों के सही पक्ष में रखता है जिन पर यह निर्भर करता है। मात्रा सीमित रखें और लक्षित सार्वजनिक रखें, जैसे कि यह उदाहरण करता है।

क्या आप इसे एक वास्तविक स्रोत के खिलाफ चलाने के लिए तैयार हैं? एक निःशुल्क Scrapeless खाता बनाएं और फ़ेच चरण में URL बदलें।

निष्कर्ष

एक स्क्रैपिंग पाइपलाइन पाँच छोटे चरणों का एक समूह है, प्रत्येक एक कार्य करता है। Scrapeless पृष्ठ लाती है, read_html तालिका निकालती है, to_numeric और कुछ असाइनमेंट इसे साफ करते हैं, और दो to_ कॉल इसे संग्रहीत करते हैं। चूंकि चरण अलग हैं, पाइपलाइन परिवर्तन को सहन करती है: एक नया लेआउट खोज को प्रभावित करता है, एक नया कॉलम प्रकार रूपांतरण को प्रभावित करता है, और बाकी रहता है। उपरोक्त कार्यशील स्क्रिप्ट से शुरू करें, अपना लक्ष्य स्वैप करें, और अपने डेटा की मांग के अनुसार रूपांतरण चरण को बढ़ाएं।

Scrapeless मुफ्त योजना से शुरू करें अपने अपने पृष्ठों के खिलाफ फ़ेच चरण चलाने के लिए, और जब आप एक आवर्ती नौकरी के आकार में हों तो Scrapeless मूल्य निर्धारण की जांच करें।

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

प्रश्न: pandas.read_html pandas 3.x में HTML स्ट्रिंग पर क्यों विफल होती है?

एक नग्न स्ट्रिंग तर्क को फ़ाइल पथ या URL के रूप में माना जाता है, इसलिए pandas इसे खोलने की कोशिश करता है और एक त्रुटि उठाता है। मार्कअप को io.StringIO(html) में लपेटें और उसे पास करें; read_html फिर मेमोरी में स्ट्रिंग को पार्स करती है और DataFrames की एक सूची लौटाती है।

प्रश्न: क्या मुझे read_html का उपयोग करने के लिए BeautifulSoup या lxml की आवश्यकता है?
read_html को एक HTML पार्सर स्थापित करने की आवश्यकता होती है, और यह अंतःक्रियात्मक रूप से lxml या html5lib का उपयोग करता है, इसलिए पांडा के साथ इनमें से एक को स्थापित करें। आप तालिका निकालने के लिए खुद पार्सर कोड नहीं लिखते हैं; read_html पार्सर को चलाता है और DataFrames को वापस करता है।

प्रश्न: मुझे js_render को True कब सेट करना चाहिए?

जब डेटा को प्रारंभिक HTML लोड होने के बाद JavaScript द्वारा पृष्ठ पर जोड़ा जाता है, तो इसे True पर सेट करें, जो तब दिखाई देता है जब read_html ब्राउज़र में स्पष्ट रूप से एक टेबल होने के बावजूद एक पृष्ठ पर शून्य टेबल पाता है। जब तालिका पहले से ही सर्वर के HTML में हो, तो इसे False पर छोड़ दें, क्योंकि अनावश्यक पृष्ठ को रेंडर करना केवल विलंब जोड़ता है।

प्रश्न: क्या मुझे स्क्रैप किया गया डेटा CSV या Parquet के रूप में स्टोर करना चाहिए?

जब आप एक पोर्टेबल, मानव-पठनीय फ़ाइल चाहते हैं और पंक्ति की संख्या छोटी है, तो CSV चुनें; जब आप कॉलम प्रकारों को बनाए रखना चाहते हैं और डेटा सेट इतना बड़ा है कि टाइप किए गए, कॉलमार रीड्स मायने रखते हैं, तो Parquet चुनें। छोटे नमूनों पर Parquet स्थिर फुटर ओवरहेड के कारण बड़ा फ़ाइल हो सकता है, इसलिए आकार अकेले CSV को प्राथमिकता देता है जब तक डेटा न बढ़े।

प्रश्न: मुझे एक पृष्ठ को कैसे संभालना चाहिए जिसमें कई तालिकाएँ हैं?

read_html हर तालिका को एक सूची में एक अलग DataFrame के रूप में लौटाता है, इसलिए आपको जो चाहिए उसे पहचानने के लिए प्रत्येक तत्व का आकार और पहले रो को प्रिंट करें, फिर सीधे उसे अनुक्रमित करें। एक बार जब आप जान लें कि स्थिति स्थिर है, तो निकासी चरण में उस अनुक्रमांक को हार्डकोड करें।

प्रश्न: जब मैं और पृष्ठ जोड़ता हूं तो मैं स्क्रेप को विनम्र कैसे रखूं?

पृष्ठ को एकल स्थिरांक में बांधकर रखें, जैसा कि यहाँ PAGES करता है, ताकि कवरेज को व्यापक बनाना एक जानबूझकर संपादन हो बजाय एक अव्यवस्थित लूप के। पहले साइट के robots.txt और नियमों को पढ़ें, और केवल सार्वजनिक डेटा को उस मात्रा में एकत्र करें जिसे लक्षित साइट ग्रहण कर सके।