प्रसंस्करण विफल: {e}
    ```
    यह विधि मुख्य रूप से बुनियादी स्क्रैपिंग को समझने के लिए शैक्षिक उद्देश्यों के लिए है। वास्तविक Google SERP स्क्रैपिंग के लिए, इसे शायद अवरुद्ध कर दिया जाएगा या अधूरी जानकारी लौटाई जाएगी।

### 2. जावास्क्रिप्ट रेंडरिंग के लिए सेलेनियम का उपयोग करना

सेलेनियम एक शक्तिशाली उपकरण है जो ब्राउज़र स्वचालित करने के लिए सक्षम है, जो जावास्क्रिप्ट-भारी पृष्ठों को रेंडर करने में सक्षम है, जिससे यह Google SERPs जैसे गतिशील सामग्री को स्क्रैप करने के लिए उपयुक्त है। यह पृष्ठ के साथ इंटरैक्ट करने के लिए एक वास्तविक ब्राउज़र (हेडलस या हेडफुल) को नियंत्रित करता है [3]।

**कोड संचालन चरण:**

1.  **सेलेनियम और एक वेबड्राइवर (जैसे, क्रोमड्राइवर) स्थापित करें:**
    ```bash
    पिप स्थापित करें सेलेनियम
    # https://chromedriver.chromium.org/downloads से क्रोमड्राइवर डाउनलोड करें और इसे अपने PATH में रखें
    ```
2.  **ब्राउज़र इंटरैक्शन को स्वचालित करें:**
    ```python
    सेलेनियम से आयात करें वेबड्राइवर
    सेलेनियम.webdriver.chrome.service से सेवा आयात करें
    सेलेनियम.webdriver.common.by से द्वारा आयात करें
    सेलेनियम.webdriver.chrome.options से विकल्प आयात करें
    bs4 से ब्यूटीफुल सूप आयात करें
    समय आयात करें

    # अपने क्रोमड्राइवर निष्पादन योग्य का पथ
    क्रोमड्राइवर_पथ = "/usr/local/bin/chromedriver" # ज़रूरत के अनुसार इस पथ को समायोजित करें

    विकल्प = विकल्प()
    विकल्प.add_argument("--headless") # हेडलेस मोड में चलाएँ (कोई UI नहीं)
    विकल्प.add_argument("--no-sandbox") # कुछ वातावरणों के लिए आवश्यक
    विकल्प.add_argument("--disable-dev-shm-usage") # कुछ वातावरणों के लिए आवश्यक
    # वास्तविक ब्राउज़र की नकल करने के लिए एक सामान्य यूजर-एजेंट जोड़ें
    विकल्प.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, जैसे गेको) क्रोम/116.0.0.0 सफारी/537.36")

    सेवा = सेवा(क्रोमड्राइवर_पथ)
    ड्राइवर = वेबड्राइवर.Chrome(सेवा=सेवा, विकल्प=विकल्प)

    प्रश्न = "वेब स्क्रैपिंग सर्वोत्तम अभ्यास"
    url = f"https://www.google.com/search?q={query.replace(" ", "+")}"

    कोशिश करें:
        ड्राइवर.get(url)
        समय.sleep(5) # पृष्ठ के लोड होने और जावास्क्रिप्ट के निष्पादन के लिए प्रतीक्षा करें

        # CAPTCHA या सहमति पृष्ठ की जांच करें (Google अक्सर इन्हें दिखाता है)
        यदि "मैं रोबोट नहीं हूँ" ड्राइवर.page_source में या "आगे बढ़ने से पहले" ड्राइवर.page_source में है:
            प्रिंट("CAPTCHA या सहमति पृष्ठ का पता चला। मैनुअल हस्तक्षेप या उन्नत बाईपास की आवश्यकता है।")
            # आपको सहमति बटन पर क्लिक करने या CAPTCHA हल करने के लिए तर्क लागू करने की आवश्यकता हो सकती है
            # उदाहरण के लिए, सहमति पृष्ठ पर "मैं सहमत हूँ" बटन पर क्लिक करने के लिए:
            # कोशिश करें:
            #     सहमत_button = ड्राइवर.find_element(By.XPATH, "//button[contains(., 'मैं सहमत हूँ')]")
            #     सहमत_button.click()
            #     समय.sleep(3)
            # छोड़ें:
            #     पास
            ड्राइवर.save_screenshot("google_captcha_or_consent.png")
            प्रिंट("मैनुअल निरीक्षण के लिए स्क्रीनशॉट सहेजा गया।")
        
        # पृष्ठ लोड होने के बाद HTML निकालें
        सूप = ब्यूटीफुलसूप(ड्राइवर.page_source, 'html.parser')

        # उदाहरण: खोज परिणाम शीर्षक और लिंक निकालें
        # Google का SERP ढाँचा अक्सर बदलता है, इसलिए इन चयनकों को अपडेट करने की आवश्यकता हो सकती है
        खोज_परिणाम = सूप.find_all('div', class_='g') # जैविक परिणामों के लिए आम वर्ग
        यदि नहीं खोज_परिणाम:
            खोज_परिणाम = सूप.select('div.yuRUbf') # परिणाम लिंक के लिए दूसरा सामान्य चयनकर्ता

        प्रत्येक परिणाम के लिए खोज_परिणाम:
            शीर्षक_tag = परिणाम.find('h3')
            लिंक_tag = परिणाम.find('a')
            यदि शीर्षक_tag और लिंक_tag:
                प्रिंट(f"शीर्षक: {शीर्षक_tag.get_text()}")
                प्रिंट(f"लिंक: {लिंक_tag['href']}")
                प्रिंट("---")

    पकड़ें अपवाद के रूप में e:
        प्रिंट(f"एक त्रुटि हुई: {e}")
    अंततः:
        ड्राइवर.quit() # ब्राउज़र बंद करें
    ```
    सेलेनियम गतिशील सामग्री के लिए अधिक मजबूत है लेकिन धीमा और अधिक संसाधन-गहन है। यह CAPTCHA और सहमति पॉप-अप जैसे एंटी-बॉट उपायों के सावधानीपूर्वक प्रबंधन की भी आवश्यकता होती है।

### 3. आधुनिक ब्राउज़र स्वचालन के लिए प्लेरेाइट का उपयोग करना

प्लेयराइट ब्राउज़र स्वचालन के लिए सेलेनियम का एक नया, तेज़ और अधिक विश्वसनीय विकल्प है। यह क्रोमियम, फ़ायरफ़ॉक्स और वेबकिट का समर्थन करता है, और जावास्क्रिप्ट रेंडरिंग और गतिशील सामग्री को संभालने सहित वेब पृष्ठों के साथ इंटरैक्ट करने के लिए साफ़ एपीआई प्रदान करता है। प्लेयराइट में भी स्टेल्थ के साथ मदद कर सकते हैं [4].

**कोड संचालन चरण:**

1.  **प्लेयराइट स्थापित करें:**
    ```bash
    पिप स्थापित करें प्लेयराइट
    playwright install
    ```
2.  **प्लेयराइट के साथ ब्राउज़र इंटरैक्शन को स्वचालित करें:**
    ```python
    प्लेयराइट.sync_api से आयात करें sync_playwright
    समय आयात करें

    प्रश्न = "पायथन वेब स्क्रैपिंग ट्यूटोरियल"
    url = f"https://www.google.com/search?q={query.replace(" ", "+")}"

    के साथ sync_playwright() as p:
        ब्राउज़र = p.chromium.launch(headless=True) # हेडलेस मोड में चलाएँ
        संदर्भ = ब्राउज़र.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, जैसे गेको) क्रोम/116.0.0.0 सफारी/537.36"
        )
        पृष्ठ = संदर्भ.new_page()

        कोशिश करें:

page.goto(url, wait_until="domcontentloaded")
            time.sleep(5) # गतिशील सामग्री को लोड करने का समय दें

            # CAPTCHA या सहमति पृष्ठ की जांच करें
            यदि page.locator("text=मैं रोबोट नहीं हूँ").इस_visible() या page.locator("text=जारी रखने से पहले").इस_visible():
                print("CAPTCHA या सहमति पृष्ठ का पता चला। मैन्युअल हस्तक्षेप या उन्नत बाइपास की आवश्यकता है।")
                page.screenshot(path="google_playwright_captcha.png")
            और:
                # खोज परिणाम निकालें
                # चयनकर्ता Google SERPs पर बदलने के लिए अत्यधिक प्रवण होते हैं
                # यह उदाहरण जैविक परिणामों के लिए सामान्य तत्वों को खोजने का प्रयास करता है
                परिणाम = page.locator("div.g").all()
                यदि नहीं परिणाम:
                    परिणाम = page.locator("div.yuRUbf").all()

                के लिए i, परिणाम में enumerate(परिणाम):
                    शीर्षक_element = परिणाम.locator("h3")
                    लिंक_element = परिणाम.locator("a")
                    यदि शीर्षक_element और लिंक_element:
                        शीर्षक = शीर्षक_element.text_content()
                        लिंक = लिंक_element.get_attribute("href")
                        print(f"परिणाम {i+1}:")
                        print(f"  शीर्षक: {शीर्षक}")
                        print(f"  लिंक: {लिंक}")
                        print("---")

        except Exception as e:
            print(f"एक त्रुटि हुई: {e}")
        अंततः:
            browser.close()
    ```
    Playwright, Selenium की तुलना में बेहतर प्रदर्शन और एक अधिक आधुनिक API प्रदान करता है, जिससे यह गतिशील वेब स्क्रैपिंग के लिए एक मजबूत विकल्प है। हालांकि, यह अभी भी Google के एंटी-बॉट चुनौतियों का सामना करता है।

### 4. एक समर्पित SERP API का उपयोग करना (विश्वसनीयता के लिए अनुशंसित)

विशेष रूप से बड़े मात्रा के डेटा के लिए, विश्वसनीय, स्केलेबल, और बिना किसी परेशानी के Google SERP स्क्रैपिंग के लिए, एक समर्पित SERP API का उपयोग सबसे कुशल समाधान है। ये APIs (जैसे Scrapeless का Deep SERP API, SerpApi, या Oxylabs' Google Search API) एंटी-बॉट उपायों, प्रॉक्सी रोटेशन, CAPTCHA को हल करने, और पार्सिंग की सभी जटिलताओं को संभालते हैं, संरचित JSON डेटा सीधे प्रदान करते हैं [5]।

**कोड संचालन कदम (Scrapeless Deep SERP API के साथ अवधारणात्मक):**

1. **Scrapeless खाते के लिए साइन अप करें और अपनी API कुंजी प्राप्त करें।**
2. **Scrapeless Deep SERP API एंडपॉइंट पर HTTP अनुरोध करें:**
    ```python
    import requests
    import json

    API_KEY = "YOUR_SCRAPELESS_API_KEY" # अपनी वास्तविक API कुंजी से बदलें
    प्रश्न = "वेब स्क्रैपिंग उपकरण"
    देश = "us" # उदाहरण: संयुक्त राज्य अमेरिका
    भाषा = "en" # उदाहरण: अंग्रेज़ी

    # Scrapeless Deep SERP API एंडपॉइंट
    api_endpoint = "https://api.scrapeless.com/deep-serp"

    params = {
        "api_key": API_KEY,
        "q": प्रश्न,
        "country": देश,
        "lang": भाषा,
        "output": "json" # JSON आउटपुट का अनुरोध करें
    }

    try:
        response = requests.get(api_endpoint, params=params, timeout=30)
        response.raise_for_status() # HTTP त्रुटियों के लिए एक अपवाद उठाएं
        serp_data = response.json()

        यदि serp_data और serp_data.get("organic_results"):
            print(f"'{प्रश्न}' के लिए Google SERP सफलतापूर्वक स्क्रैप किया गया:")
            के लिए i, परिणाम में enumerate(serp_data["organic_results"]):
                print(f"परिणाम {i+1}:")
                print(f"  शीर्षक: {result.get('title')}")
                print(f"  लिंक: {result.get('link')}")
                print(f"  स्निपेट: {result.get('snippet')}")
                print("---")
        अन्यथा:
            print("कोई जैविक परिणाम नहीं मिला या API प्रतिक्रिया खाली थी।")

    except requests.exceptions.RequestException as e:
        print(f"API अनुरोध विफल: {e}")
    except json.JSONDecodeError:
        print("JSON प्रतिक्रिया को डिकोड करने में विफल।")
    except Exception as e:
        print(f"एक अप्रत्याशित त्रुटि हुई: {e}")
    ```
    समर्पित SERP APIs सभी जटिलताओं से दूर कर देती हैं, उच्च विश्वसनीयता और पैमाने पर साफ़, संरचित डेटा प्रदान करती हैं। यह गंभीर डेटा निष्कर्षण के लिए अक्सर सबसे किफायती समाधान होता है।

### 5. प्रॉक्सी रोटेशन लागू करना

Google आक्रामकता से उन IP पतों को ब्लॉक करता है जो बहुत अधिक अनुरोध भेजते हैं। कई IPs के बीच अपने अनुरोधों को वितरित करने के लिए एक रोटेटिंग प्रॉक्सी का पूल का उपयोग करना आवश्यक है, जिससे Google के लिए आपके स्क्रेपर को पहचानना और ब्लॉक करना कठिन हो जाता है [6]।

**कोड संचालन चरण:**

1. **प्रॉक्सियों की एक सूची प्राप्त करें (Google स्क्रैपिंग के लिए आवासीय प्रॉक्सी की सिफारिश की जाती है)।**
2. **अपने `requests` या हेडलेस ब्राउज़र सेटअप में प्रॉक्सी रोटेशन को एकीकृत करें:**
    ```python
    import requests
    import random
    import time

    proxies = [
        "http://user:pass@proxy1.example.com:8080",
        "http://user:pass@proxy2.example.com:8080",
        "http://user:pass@proxy3.example.com:8080",
    ]

    प्रश्न = "सर्वश्रेष्ठ वेब स्क्रैपिंग फ्रेमवर्क"
    url = f"https://www.google.com/search?q={query.replace(" ", "+")}"

    headers = {

"यूजर-एजेंट": "मोज़िला/5.0 (विंडोज NT 10.0; विन64; x64) एपलवेबकिट/537.36 (KHTML, जैसे Gecko) क्रोम/116.0.0.0 सफारी/537.36"
}

के लिए _ में रेंज(5): # विभिन्न प्रॉक्सी का उपयोग करके 5 अनुरोध करें
    प्रॉक्सी = यादृच्छिक.विकल्प(प्रॉक्सीस)
    प्रॉक्सी_डिक्ट = {
        "http": प्रॉक्सी,
        "https": प्रॉक्सी,
    }
    प्रिंट(f"प्रॉक्सी का उपयोग कर रहे हैं: {प्रॉक्सी}")
    प्रयास करें:
        प्रतिक्रियाएँ = अनुरोध.प्राप्त(url, हेडर्स=हेडर्स, प्रॉक्सी=प्रॉक्सी_डिक्ट, समय-सीमा=15)
        प्रतिक्रियाएँ.raise_for_status()
        प्रिंट(f"{प्रॉक्सी} के साथ अनुरोध सफल। स्थिति: {प्रतिक्रिया.status_code}")
        # यहां प्रतिक्रिया संसाधित करें
        # सूप = ब्यूटीफुलसूप(प्रतिक्रिया.text, 'html.parser')
        # ... डेटा निकाले ...
    कैच करें अनुरोध.exceptions.RequestException के रूप में e:
        प्रिंट(f"{प्रॉक्सी} के साथ अनुरोध विफल: {e}")
    समय.नींद(यादृच्छिक.एकीकृत(5, 10)) # अनुरोधों के बीच यादृच्छिक देरी जोड़ें

आयात अनुरोध
आयात यादृच्छिक
आयात समय

यूजर_एजेंट्स = [
    "मोज़िला/5.0 (विंडोज NT 10.0; विन64; x64) एपलवेबकिट/537.36 (KHTML, जैसे Gecko) क्रोम/116.0.0.0 सफारी/537.36",
    "मोज़िला/5.0 (मैकिंटॉश; इंटेल मैक ओएस एक्स 10_15_7) एपलवेबकिट/537.36 (KHTML, जैसे Gecko) क्रोम/116.0.0.0 सफारी/537.36",
    "मोज़िला/5.0 (विंडोज NT 10.0; विन64; x64; rv:109.0) गेको/20100101 फायरफॉक्स/117.0",
    "मोज़िला/5.0 (मैकिंटॉश; इंटेल मैक ओएस एक्स 10_15_7) एपलवेबकिट/605.1.15 (KHTML, जैसे Gecko) संस्करण/16.6 सफारी/605.1.15",
    "मोज़िला/5.0 (लिनक्स; एंड्रॉइड 10; SM-G973F) एपलवेबकिट/537.36 (KHTML, जैसे Gecko) क्रोम/116.0.0.0 मोबाइल सफारी/537.36"
]

क्वेरी = "पायथन वेब स्क्रैपिंग टूल"
url = f"https://www.google.com/search?q={क्वेरी.replace(" ", "+")}"

के लिए _ में रेंज(3): # विभिन्न यूजर-एजेंट के साथ कुछ अनुरोध करें
    हेडर्स = {
        "यूजर-एजेंट": यादृच्छिक.विकल्प(यूजर_एजेंट्स),
        "स्वीकृति": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "स्वीकृति-भाषा": "en-US,en;q=0.5",
        "संपर्क": "ज-mार-जीवित",
        "अपग्रेड-इनसेक्योर-अनुरोध": "1"
    }
    प्रिंट(f"यूजर-एजेंट का उपयोग कर रहे हैं: {हेडर्स['यूजर-एजेंट']}")
    प्रयास करें:
        प्रतिक्रियाएँ = अनुरोध.प्राप्त(url, हेडर्स=हेडर्स, समय-सीमा=15)
        प्रतिक्रियाएँ.raise_for_status()
        प्रिंट(f"अनुरोध सफल। स्थिति: {प्रतिक्रिया.status_code}")
        # प्रतिक्रिया संसाधित करें
    कैच करें अनुरोध.exceptions.RequestException के रूप में e:
        प्रिंट(f"अनुरोध विफल: {e}")
    समय.नींद(यादृच्छिक.एकीकृत(3, 7)) # यादृच्छिक देरी

सेलेनियम आयात webdriver
सेलेनियम.webdriver.common.by से आयात By
सेलेनियम.webdriver.support.ui से आयात WebDriverWait
सेलेनियम.webdriver.support.expected_conditions से आयात EC
आयात समय

# ... (संचालित कोड जैसा कि समाधान #2 में है) ...

ड्राइवर.प्राप्त("https://www.google.com")

# सहमति स्क्रीन को संभालें
कोशिश करें:
    # सहमति फॉर्म के दृश्य होने की प्रतीक्षा करें
    सहमति_फॉर्म = WebDriverWait(d्राइवर, 10).जब तक(
        EC.presence_of_element_located((By.XPATH, "//form[contains(@action, 'consent')]"))
    )
    # "मैं सहमत हूं" या समान बटन खोजें और क्लिक करें
    सहमति_बटन = सहमति_फॉर्म.find_element(By.XPATH, ".//button[contains(., 'मैं सहमत हूं') या contains(., 'सभी स्वीकार करें')]")
    सहमति_बटन.click()
    प्रिंट("सहमति बटन पर क्लिक किया गया।")
    समय.नींद(3)
कैच करें अपवाद के रूप में e:
    प्रिंट(f"सहमति बटन नहीं मिल सका या क्लिक नहीं किया जा सका: {e}")

# CAPTCHA को संभालें (सिद्धांतात्मक - CAPTCHA हल करने वाली सेवा की आवश्यकता होती है)
कोशिश करें:
    यदि चालक.find_element(By.ID, "recaptcha").प्रदर्शित होता है():
        प्रिंट("reCAPTCHA का पता चला। समाधान सेवा के साथ एकीकरण की आवश्यकता है।")
        # 1. reCAPTCHA तत्व से साइट कुंजी प्राप्त करें।
        # 2. साइट कुंजी और पृष्ठ URL को CAPTCHA हल करने वाली सेवा API को भेजें।
        # 3. सेवा से एक टोकन प्राप्त करें।

    # 5. फॉर्म सबमिट करें।

यह एक जटिल और अक्सर अविश्वसनीय प्रक्रिया है। विशेष SERP एपीआई जैसे Scrapeless इसे स्वचालित रूप से संभालते हैं।

### 8. Google खोज परिणामों के माध्यम से पृष्ठानुक्रमित करना

Google SERPs पृष्ठानुक्रमित होते हैं, और आपको अक्सर कई पृष्ठों को स्क्रैप करने की आवश्यकता होती है। इसमें "अगला" बटन पहचानना या आगे के पृष्ठों के लिए URL बनाना शामिल है [9]।

**कोड संचालन चरण (Selenium के साथ):**

```python
from selenium import webdriver
from selenium.webdriver.common.by import By
import time

# ... (Selenium सेटअप कोड) ...

query = "डेटा विज्ञान के लिए पायथन"
url = f"https://www.google.com/search?q={query.replace(' ', '+')}"
driver.get(url)

max_pages = 3
for page_num in range(max_pages):
    print(f"पृष्ठ {page_num + 1} को स्क्रैप कर रहे हैं...")
    # ... (वर्तमान पृष्ठ से डेटा स्क्रैप करें) ...

    try:
        # "अगला" बटन खोजें और क्लिक करें
        next_button = driver.find_element(By.ID, "pnnext")
        next_button.click()
        time.sleep(random.uniform(3, 6)) # अगला पृष्ठ लोड होने का इंतजार करें
    except Exception as e:
        print(f"'अगला' बटन नहीं मिला या क्लिक नहीं कर सके: {e}")
        break # यदि अधिक पृष्ठ नहीं हैं तो लूप से बाहर निकलें

driver.quit()

import requests
from bs4 import BeautifulSoup

# ... (मान लें कि आपने `soup` में HTML सामग्री प्राप्त की है) ...

# चयनकर्ताओं के उदाहरण (ये बदलने की उच्च संभावना हैं):
# जैविक परिणाम
organic_results = soup.select("div.g")

# विज्ञापन (अक्सर विशेष डेटा विशेषताओं के साथ होते हैं)
ads = soup.select("div[data-text-ad='1']")

# विशेष स्निपेट
featured_snippet = soup.select_one("div.kp-wholepage")

# "लोगों ने भी पूछें"
people_also_ask = soup.select("div[data-init-vis='true']")

print(f"पाए गए {len(organic_results)} जैविक परिणाम।")
print(f"पाए गए {len(ads)} विज्ञापन।")
if featured_snippet:
    print("एक विशेष स्निपेट मिला।")
if people_also_ask:
    print(" 'लोगों ने भी पूछें' भाग मिला।")