पोलर्स वेब स्क्रैपिंग: लाइव पेज से तेज़ डेटा फ्रेम तक

संक्षिप्त:

• Polars एक तेज़, Arrow-सहायता प्राप्त DataFrame पुस्तकालय है, और यह Scrapeless के साथ मिलकर एक लाइव पृष्ठ को एक प्रकारित, प्रश्न-योग्य फ्रेम में बदलता है।
• Polars में कोई HTTP क्लाइंट और कोई HTML पार्सर नहीं है, इसलिए फेच और एक्सट्रैक्ट चरण Scrapeless और एक पार्सर से आते हैं; एक बार रिकॉर्ड बनने के बाद Polars उसका प्रबंधन करता है।
• pl.DataFrame(records) के साथ शब्दकोशों की सूची से एक फ्रेम बनाएं, और स्कीमा को एक्सट्रैक्शन के दौरान मानों को बदलते समय पहली पंक्ति से प्रकारित किया जाता है।
• एक्सप्रेशन एपीआई पांडा-शैली की चेन इंडेक्सिंग को प्रतिस्थापित करता है: pl.col("price_gbp").mean() के अंदर group_by(...).agg(...) साफ-सुथरा पढ़ता और चलाता है।
• लेज़ी पथ, df.lazy()...collect(), Polars को सभी प्रश्न की योजना बनाने और उसे ऑप्टिमाइज़ करने की अनुमति देता है इससे पहले कि वह डेटा को छुए, जो बड़े सेट पर इसे आगे बढ़ाता है।
• Scrapeless मुफ्त योजना पर शुरू करें और फेच चरण को अपनी खुद की श्रेणी की ओर इंगित करें।

Polars डेटा कार्यों में लगातार दिखता है क्योंकि यह तेज है और इसका एपीआई सुखद है, लेकिन लगभग हर ट्यूटोरियल इसे एक ऐसा Parquet फ़ाइल सौंपता है जो पहले से मौजूद है। स्क्रैपिंग इसका विपरीत है। डेटा लाइव है, यह HTML है, और जब तक आप इसे प्रकारित नहीं करते, यह अनप्रकारित है। यह गाइड एक सार्वजनिक पुस्तकों के सूची को एक URL से Polars DataFrame में ले जाती है जिसे आप समूहित और संकलित कर सकते हैं, और यह उस एक चीज़ के बारे में ईमानदार है जो Polars आपके लिए नहीं करेगा: पृष्ठ प्राप्त करना।

फेच Scrapeless यूनिवर्सल स्क्रैपिंग एपीआई से आता है, जो एक सार्वजनिक URL के लिए रेंडर किया गया HTML लौटाता है। एक पार्सर उस HTML को रिकॉर्ड में बदलता है। Polars बाकी करता है, और यह तेज़ करता है।

स्क्रैपिंग वर्कफ़्लो में Polars की क्या विशेषताएं हैं

Polars एक DataFrame पुस्तकालय है जो Apache Arrow कॉलम के मेमोरी प्रारूप पर आधारित है, जो इसकी प्रकारित स्तंभों और समूहित संक्षेपों को तेज बनाता है। स्क्रैप किए गए डेटा के लिए यह लाभ स्पष्ट है: एक बार जब आपके रिकॉर्ड एक फ्रेम में होते हैं, तो उन्हें साफ़ करना और संक्षेपित करना कुछ एक्सप्रेशनों का काम होता है न कि हाथ से लिखी गई लूप का, और स्तंभ अपने प्रकार बनाए रखते हैं। Polars Apache Arrow कॉलम प्रारूप पर निर्भर करता है, इसलिए कीमतों का एक कॉलम एक असली संख्यात्मक कॉलम है, न कि हर ऑपरेशन पर आप फिर से पार्स करने वाले स्ट्रिंग की सूची।

इंस्टॉल

Polars फ्रेम का प्रबंधन करता है; एक पार्सर HTML का प्रबंधन करता है। दोनों इंस्टॉल करें।

pip install polars lxml

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

export SCRAPELESS_API_KEY="sk_your_key_here"

फेच, एक्सट्रैक्ट, और एक फ्रेम बनाना

पहला चरण पृष्ठ को फेच करता है, प्रति उत्पाद एक रिकॉर्ड प्राप्त करता है, और DataFrame का निर्माण करता है। चूंकि Polars HTML को फेच या पार्स नहीं कर सकता, इसलिए यह चरण Scrapeless और पार्सर का काम करने का स्थान है; Polars समाप्त रिकॉर्ड लेता है।

import json
import os
import urllib.request

import polars as pl
from lxml import html as lxhtml

API_URL = "https://api.scrapeless.com/api/v2/unlocker/request"
RATINGS = {"One": 1, "Two": 2, "Three": 3, "Four": 4, "Five": 5}


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"]


dom = lxhtml.fromstring(fetch_html("https://books.toscrape.com/"))
records = []
for card in dom.cssselect("article.product_pod"):
    records.append(
        {
            "title": card.cssselect("h3 a")[0].get("title"),
            "price_gbp": float(card.cssselect("p.price_color")[0].text_content().strip().lstrip("£")),
            "rating": RATINGS[card.cssselect("p.star-rating")[0].get("class").split()[-1]],
            "in_stock": "In stock" in card.cssselect("p.instock.availability")[0].text_content(),
        }
    )

df = pl.DataFrame(records)
print(f"अविलंबित रिकॉर्ड: {df.height}")
print("स्कीमा:", dict(df.schema))

एक्सट्रैक्शन CSSSelectors मानक का उपयोग करता है लxml के cssselect के माध्यम से, और यह पढ़ते समय प्रत्येक मान को जबरदस्ती करता है: मूल्य float बन जाता है, स्टार-रेटिंग शब्द int बन जाता है, और उपलब्धता boolean बन जाती है। वह जबरदस्ती महत्वपूर्ण आदत है। वास्तविक Python प्रकारों के साथ रिकॉर्ड बनाएं और Polars उनके आधार पर एक वास्तविक स्कीमा का अनुमान लगाता है।

अविलंबित रिकॉर्ड: 20
स्कीमा: {'title': String, 'price_gbp': Float64, 'rating': Int64, 'in_stock': Boolean}

बीस उत्पाद कार्ड पहले पृष्ठ पर एक रूपरेखा में बदल जाते हैं जिसमें निम्नलिखित प्रकार होते हैं: String, Float64, Int64, और Boolean। कोई भी कॉलम टेक्स्ट के रूप में नहीं छोड़ा जाता जिसे बाद में फिर से पार्स करना पड़े।

अभिव्यक्तियों के साथ रूपांतरण

Polars श्रृंखला अनुक्रमण को एक अभिव्यक्ति API से बदलता है, और यही वह हिस्सा है जिसे ठीक से सीखना महत्वपूर्ण है। एक अभिव्यक्ति जैसे pl.col("price_gbp").mean() एक गणना को दर्शाती है जिसे Polars कुशलता से चलाता है, और अभिव्यक्तियाँ filter, group_by, और agg के भीतर एकीकृत होती हैं।

सारांश = (
    df.lazy()
    .filter(pl.col("in_stock"))
    .group_by("rating")
    .agg(pl.len().alias("books"), pl.col("price_gbp").mean().round(2).alias("avg_price"))
    .sort("rating")
    .collect()
)
print(saransh)

df.lazy() उत्सुक रूपरेखा को एक क्वेरी योजना में बदलता है, श्रृंखला कार्य का वर्णन करती है, और .collect() इसे निष्पादित करता है। इस छोटे सेट पर अंतर अदृश्य है, लेकिन आलसी पथ Polars को पूरे क्वेरी का विश्लेषण करने और एक भी मान पढ़ने से पहले काम को छोड़ने की अनुमति देता है, यही कारण है कि यह स्केल करता है। समुच्चय भंडारित पुस्तकों को स्टार रेटिंग के अनुसार समूहित करता है और प्रति समूह गणना और औसत कीमत की रिपोर्ट करता है।

आकार: (5, 3)
┌────────┬───────┬───────────┐
│ रेटिंग ┆ पुस्तकें ┆ औसत_कीमत │
│ ---    ┆ ---   ┆ ---       │
│ i64    ┆ u32   ┆ f64       │
╞════════╪═══════╪═══════════╡
│ 1      ┆ 6     ┆ 40.02     │
│ 2      ┆ 3     ┆ 36.83     │
│ 3      ┆ 3     ┆ 42.32     │
│ 4      ┆ 4     ┆ 31.1      │
│ 5      ┆ 4     ┆ 39.75     │
└────────┴───────┴───────────┘

संपूर्ण स्क्रिप्ट

चरणों को एक साथ रखें, सबसे सस्ती पांच सितारा किताब पाने के लिए एक और अभिव्यक्ति जोड़ें, और रूपरेखा को Parquet के रूप में स्टोर करें।

import json
import os
import urllib.request

import polars as pl
from lxml import html as lxhtml

API_URL = "https://api.scrapeless.com/api/v2/unlocker/request"
RATINGS = {"One": 1, "Two": 2, "Three": 3, "Four": 4, "Five": 5}


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"]


dom = lxhtml.fromstring(fetch_html("https://books.toscrape.com/"))
records = []
for card in dom.cssselect("article.product_pod"):
    records.append(
        {
            "title": card.cssselect("h3 a")[0].get("title"),
            "price_gbp": float(card.cssselect("p.price_color")[0].text_content().strip().lstrip("£")),
            "rating": RATINGS[card.cssselect("p.star-rating")[0].get("class").split()[-1]],
            "in_stock": "In stock" in card.cssselect("p.instock.availability")[0].text_content(),
        }
    )

df = pl.DataFrame(records)
print(f"रिकॉर्ड निकाले गए: {df.height} | कॉलम: {df.columns}")

summary = (
    df.lazy()
    .filter(pl.col("in_stock"))
    .group_by("rating")
    .agg(pl.len().alias("books"), pl.col("price_gbp").mean().round(2).alias("avg_price"))
    .sort("rating")
    .collect()
)
print(saransh)

cheapest = df.filter(pl.col("rating") == 5).sort("price_gbp").select("title", "price_gbp").head(1)
print("सबसे सस्ती 5-सितारा:", cheapest.to_dicts())

df.write_parquet("books.parquet")
print(f"parquet बाइट्स: {os.path.getsize('books.parquet')}")

रन प्रत्येक चरण की रिपोर्ट करता है, अंत में एक Parquet फ़ाइल के साथ जो अगले पाठक के लिए स्कीमा बनाए रखती है।

रिकॉर्ड निकाले गए: 20 | कॉलम: ['title', 'price_gbp', 'rating', 'in_stock']
आकार: (5, 3)
┌────────┬───────┬───────────┐
│ रेटिंग ┆ पुस्तकें ┆ औसत_कीमत │
│ ---    ┆ ---   ┆ ---       │
│ i64    ┆ u32   ┆ f64       │
╞════════╪═══════╪═══════════╡
│ 1      ┆ 6     ┆ 40.02     │
│ 2      ┆ 3     ┆ 36.83     │
│ 3      ┆ 3     ┆ 42.32     │
│ 4      ┆ 4     ┆ 31.1      │
│ 5      ┆ 4     ┆ 39.75     │
└────────┴───────┴───────────┘
सबसे सस्ती 5-सितारा: [{'title': 'Set Me Free', 'price_gbp': 17.46}]
parquet बाइट्स: 2233

write_parquet टाइपेड कॉलम को Apache Parquet फ़ाइल प्रारूप में संग्रहीत करता है, इसलिए अगली प्रक्रिया price_gbp को बिना किसी पुनः-कोर्सन के फ्लोट के रूप में पढ़ती है। Polars उपयोगकर्ता गाइड इस उदाहरण से बाहर निकलने पर पूर्ण अभिव्यक्ति और आलसी API का दस्तावेज करती है।

Polars क्या नहीं करेगा

Polars एक डेटा फ्रेम इंजन है, और यही पूरा लक्ष्य है: इसके पास कोई HTTP क्लाइंट और कोई HTML पार्सर नहीं है। यह किसी URL का अनुरोध नहीं करेगा, यह JavaScript को नहीं तैयार करेगा, और यह <article> टैग को पंक्तियों में नहीं बदलेगा। यह डिज़ाइन के अनुसार है, और यही कारण है कि यह कार्यप्रवाह इसके सामने दो उपकरणों का उपयोग करता है। Scrapeless पृष्ठ को पुनर्प्राप्त करता है, और एक पार्सर मार्कअप को रिकॉर्ड में पढ़ता है। यदि आपको पार्सिंग चरण का गहरा उपचार चाहिए, तो वेब स्क्रैपिंग के लिए BeautifulSoup का उपयोग पर गाइड पायथन में HTML निष्कर्षण को कवर करता है, और उन रिकॉर्ड को सीधे pl.DataFrame में दिया जाता है।

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

पहले पृष्ठ से परे क्रॉल को चौड़ा करने से पहले, लक्ष्य के robots.txt और शर्तों को पढ़ें। The Robots Exclusion Protocol यह बताता है कि एक साइट स्वचालित क्लाइंट से किन पथों को टालने के लिए कहती है, और इसके भीतर रहकर कार्यप्रवाह को स्थायी बनाता है। वॉल्यूम को सीमित रखें और डेटा को सार्वजनिक रखें, जैसे कि यह उदाहरण करता है।

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

निष्कर्ष

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

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

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

प्रश्न: क्या Polars अपने आप वेब पृष्ठों को स्क्रैप करता है?

नहीं। Polars एक DataFrame पुस्तकालय है जिसमें कोई HTTP क्लाइंट और कोई HTML पार्सर नहीं है, इसलिए यह किसी URL का अनुरोध नहीं कर सकता या मार्कअप को नहीं पढ़ सकता। इसे Scrapeless जैसे फ़ेच परत और lxml या BeautifulSoup जैसे पार्सर के साथ जोड़ें; एक बार रिकॉर्ड मौजूद होने पर Polars ही संभालता है।

प्रश्न: स्क्रैप किए गए डेटा के लिए Polars को pandas पर क्यों चुनें?

Polars Apache Arrow कॉलमार प्रारूप पर आधारित है और एक लेज़ी क्वेरी इंजन प्रदान करता है, इसलिए बड़े फ्रेम पर समूहित संकुलन और फ़िल्टर तेज होते हैं, और एक्सप्रेशन API सुसंगत है। एक ट्रेड-ऑफ स्क्रैपिंग से संबंधित है: pandas के पास तालिकाओं के लिए read_html है, जबकि Polars आपसे अपेक्षा करता है कि आप स्वयं रिकॉर्ड से फ्रेम बनाएँ, जो कार्ड-शैली पृष्ठों के लिए तालिका-केवल पृष्ठों से बेहतर है।

प्रश्न: Polars में ईगर और लेज़ी के बीच क्या अंतर है?

एक ईगर DataFrame प्रत्येक संचालन को तुरंत चलाता है, जबकि df.lazy() एक क्वेरी योजना बनाता है जो केवल उस समय निष्पादित होती है जब आप .collect() को कॉल करते हैं। लेज़ी पथ Polars को पूरे क्वेरी को अनुकूलित करने और अनावश्यक काम को छोड़ने की अनुमति देता है, यही कारण है कि यह बड़े डेटा सेट पर बेहतर स्केल करता है, हालांकि परिणाम छोटे डेटा सेट पर समान होते हैं।

प्रश्न: मेरे स्क्रैप किए गए नंबर Polars में स्ट्रिंग के रूप में क्यों दिखाई देते हैं?

स्क्रैप की गई मानें टेक्स्ट के रूप में आती हैं, और यदि आप उन्हें pl.DataFrame में अपरिवर्तित पास करते हैं, तो कॉलम प्रकार String होता है। हर मान को निष्कर्षण के दौरान बदलें, जैसा कि उदाहरण मूल्य को float और रेटिंग शब्द को एक पूर्णांक में बदलता है, ताकि स्कीमा पहले पंक्ति से टाइप की गई हो और कोई कॉलम बाद में फिर से पार्स करने की आवश्यकता न हो।

प्रश्न: मैं स्क्रैप किए गए रिकॉर्ड की एक सूची से Polars DataFrame कैसे बनाऊँ?

प्रत्येक रिकॉर्ड को सुसंगत कुंजियों के साथ एक शब्दकोश के रूप में इकट्ठा करें और सूची को pl.DataFrame(records) में पास करें। Polars मानों से स्कीमा का अनुमान करता है, इसलिए शब्दकोशों में टाइप किए गए मान एक टाइप किए गए फ्रेम का उत्पादन करते हैं, जो एक्सप्रेशन API के लिए तैयार है।