कैसे अजगर का उपयोग करके वास्तव में नौकरी लिस्टिंग को परिमार्जन करें

जॉब हंटर्स, नियोक्ता, या नौकरी के बाजार में रुझानों की निगरानी करने वाले किसी भी व्यक्ति के लिए, वास्तव में उपलब्ध नौकरियों की सूची को स्क्रैप करने से उपयोगी जानकारी मिल सकती है। इस विशेष ट्यूटोरियल में, हम अपने शीर्षक, भर्ती कंपनी का नाम, स्थान, नौकरी विवरण, नौकरी पोस्टिंग लिंक सहित नौकरी का विवरण एकत्र करने के लिए HTML सामग्री पार्सिंग के लिए वेब स्क्रैपिंग और LXML के लिए नाटककार और LXML को जोड़ेंगे। CSV फ़ाइल में जानकारी सहेजकर निष्कर्ष।

पूर्वापेक्षाएँ

स्क्रैपिंग को सफलतापूर्वक करने के लिए, निम्नलिखित पायथन पुस्तकालयों को स्थापित करने की आवश्यकता है।

ब्राउज़र स्वचालन के लिए नाटककार:

pip install playwright

HTML को पार्स करने के लिए LXML:

pip install lxml

एक CSV फ़ाइल में डेटा सहेजने के लिए पांडा:

pip install pandas

नाटककार ब्राउज़र स्थापित करें :

नाटककार स्थापित करने के बाद, आवश्यक ब्राउज़र बायनेरिज़ को स्थापित करने के लिए इस कमांड को चलाएं:

playwright install

चरण 1: वेब स्क्रैपिंग के लिए नाटककार की स्थापना

नाटककार आपको वेब ब्राउज़रों के साथ स्वचालित और बातचीत करने की अनुमति देता है। हम एक क्रोमियम ब्राउज़र लॉन्च करने, एक वेबपेज पर जाने और इसकी सामग्री निकालने के लिए नाटककार की स्थापना शुरू करते हैं। यहां हम नाटककार के माध्यम से परदे के पीछे भी पारित कर सकते हैं।

परदे के पीछे का उपयोग क्यों करें?

वेबसाइटों में अक्सर एक ही आईपी पते से बार-बार अनुरोधों को ब्लॉक करने के लिए रेट-लिमिटिंग या एंटी-स्क्रैपिंग उपाय होते हैं। प्रॉक्सी आपको अनुमति देता है:

• आईपी ब्लॉकिंग से बचें: पता लगाने से बचने के लिए विभिन्न IPS के माध्यम से अपने अनुरोधों को वितरित करें।
• जियोलोकेशन बायपासिंग: एक्सेस जॉब लिस्टिंग जो भौगोलिक स्थानों के आधार पर प्रतिबंधित हो सकती है।
• गुमनामी: अपने वास्तविक आईपी को छिपाएं और स्क्रैपिंग प्रक्रिया के दौरान गुमनाम रहें।

import asyncio
from playwright.async_api import async_playwright

async def get_page_content(url):
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=False,
            proxy = {
                'server': '',
                'username': '',
                'password': ''
            }
        )  # प्रमुख ब्राउज़र
        page = await browser.new_page()
        await page.goto(url)
        
        # पृष्ठ की सामग्री निकालें
        content = await page.content()
        
        await browser.close()  # एक बार ब्राउज़र को बंद करें
        return content

इस कोड में, ASYNC_PLAYWRIGHT एक प्रमुख ब्राउज़र लॉन्च करता है, निर्दिष्ट URL के लिए नेविगेट करता है, और पृष्ठ की सामग्री प्राप्त करता है।

LXML का उपयोग करके HTML सामग्री को पार्सिंग करें

अगला, हम सार्थक डेटा निकालने के लिए पृष्ठ सामग्री को पार्स करेंगे। LXML का उपयोग इस उद्देश्य के लिए किया जाता है क्योंकि यह XPATH का उपयोग करके HTML सामग्री को पार्सिंग और क्वेरी करने के लिए मजबूत समर्थन प्रदान करता है।

from lxml import html

def parse_job_listings(content):
    # पार्स HTML सामग्री
    parser = html.fromstring(content)
    
    # XPath का उपयोग करके प्रत्येक नौकरी पोस्टिंग निकालें
    job_posting = parser.xpath('//ul[@class="css-zu9cdh eu4oa1w0"]/li')
    
    jobs_data = []
    for element in job_posting[:-1]:  # यदि यह एक विज्ञापन या अप्रासंगिक है तो अंतिम तत्व को छोड़ दें
        title = ''.join(element.xpath('.//h2/a/span/@title'))
        if title:
            link = ''.join(element.xpath('.//h2/a/@href'))
            location = ''.join(element.xpath('.//div[@data-testid="text-location"]/text()'))
            description = ', '.join(element.xpath('.//div[@class="css-9446fg eu4oa1w0"]/ul//li/text()'))
            company_name = ''.join(element.xpath('.//span[@data-testid="company-name"]/text()'))

            # Append Jobs_Data सूची में निकाले गए डेटा
            jobs_data.append({
                'Title': title,
                'Link': f"https://www.indeed.com{link}",
                'Location': location,
                'Description': description,
                'Company': company_name
            })
    
    return jobs_data

चरण 2: स्क्रैपिंग जॉब लिस्टिंग

अब जब हमारे पास ब्राउज़र ऑटोमेशन और पार्सिंग स्टेप दोनों हैं, तो उन्हें वास्तव में पेज से नौकरी की लिस्टिंग को स्क्रैप करने के लिए मिलाएं।

स्पष्टीकरण :

• get_page_content(url): नाटककार का उपयोग करके पृष्ठ सामग्री प्राप्त करता है।
• parse_job_listings(content): LXML का उपयोग करके सामग्री को पार्स करता है और नौकरी डेटा निकालता है।
• main(): ऑर्केस्ट्रेट स्क्रैपिंग प्रक्रिया, डेटा प्राप्त करना और इसे सीएसवी फ़ाइल में सहेजना।

import pandas as pd

async def scrape_indeed_jobs(url):
    # चरण 1: नाटककार का उपयोग करके पृष्ठ सामग्री प्राप्त करें
    content = await get_page_content(url)
    
    # चरण 2: HTML को पार्स करें और नौकरी का विवरण निकालें
    jobs_data = parse_job_listings(content)
    
    return jobs_data

# संकट के लिए url
url = 'https://www.indeed.com/q-usa-jobs.html'

# डेटा स्क्रैप करना और सहेजना
async def main():
    # निर्दिष्ट URL से नौकरी डेटा को परिमार्जन करें
    jobs = await scrape_indeed_jobs(url)
    
    # चरण 3: पंडों का उपयोग करके CSV को डेटा सहेजें
    df = pd.DataFrame(jobs)
    df.to_csv('indeed_jobs.csv', index=False)
    
    print("Data saved to indeed_jobs.csv")

# मुख्य कार्य चलाएं
asyncio.run(main())

चरण 3: पेजिनेशन सपोर्ट जोड़ना

वास्तव में अपनी नौकरी की लिस्टिंग की पगड़ी, और आप कई पृष्ठों को संभालने के लिए आसानी से खुरचनी का विस्तार कर सकते हैं। पृष्ठ URL को क्वेरी पैरामीटर स्टार्ट का उपयोग करके समायोजित किया जाता है, जो प्रत्येक नए पृष्ठ के लिए 10 तक बढ़ा देता है।

कई पृष्ठों से डेटा एकत्र करने के लिए अपने स्क्रैपर की कार्यक्षमता को बढ़ाने के लिए, आप एक फ़ंक्शन को लागू कर सकते हैं जिसे scrape_multiple_pages कहा जाता है। यह फ़ंक्शन स्टार्ट पैरामीटर को बढ़ाकर, बाद के पृष्ठों तक पहुंच को सक्षम करके आधार URL को संशोधित करेगा। प्रत्येक पृष्ठ के माध्यम से व्यवस्थित रूप से प्रगति करके, आप एकत्र किए गए डेटा की गुंजाइश और मात्रा का विस्तार कर सकते हैं, जैसे कि रिक्तियां, अधिक व्यापक डेटासेट सुनिश्चित करना।

async def scrape_multiple_pages(base_url, pages=3):
    all_jobs = []
    
    for page_num in range(pages):
        # पेजिनेशन के लिए URL अपडेट करें
        url = f"{base_url}&start={page_num * 10}"
        print(f"Scraping page: {url}")
        
        # प्रत्येक पृष्ठ से नौकरी डेटा को परिमार्जन करें
        jobs = await scrape_indeed_jobs(url)
        all_jobs.extend(jobs)
    
    # CSV को सभी नौकरियों को बचाएं
    df = pd.DataFrame(all_jobs)
    df.to_csv('indeed_jobs_all_pages.csv', index=False)
    print("Data saved to indeed_jobs_all_pages.csv")

# नौकरी लिस्टिंग के कई पृष्ठों को परिमार्जन करें
asyncio.run(scrape_multiple_pages('https://www.indeed.com/jobs?q=usa', pages=3))

चरण 4: कस्टमाइज़िंग जॉब सर्च क्वेरीज़

अपने स्क्रैपिंग प्रयासों में विशिष्ट नौकरी के शीर्षक या कीवर्ड को लक्षित करने के लिए, आपको वास्तव में उपयोग किए गए URL में क्वेरी खोज पैरामीटर को कॉन्फ़िगर करना होगा। यह अनुकूलन स्क्रैपर को विशेष नौकरियों या क्षेत्रों के लिए विशिष्ट डेटा एकत्र करने की अनुमति देता है। उदाहरण के लिए, यदि आप http://www.indeed.com पर पायथन डेवलपर पदों की खोज कर रहे हैं, तो आप "पायथन+डेवलपर" या प्रासंगिक कीवर्ड को शामिल करने के लिए क्वेरी पैरामीटर को समायोजित करेंगे।

query = "python+developer"
base_url = f"https://www.indeed.com/jobs?q={query}"
asyncio.run(scrape_multiple_pages(base_url, pages=3))

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

पूर्ण कोड

import asyncio
from playwright.async_api import async_playwright
from lxml import html
import pandas as pd

# चरण 1: नाटककार का उपयोग करके पृष्ठ सामग्री प्राप्त करें
async def get_page_content(url):
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=False
            proxy = {
                'server': '',
                'username': '',
                'password': ''
            }
        )  # हेड मोड में ब्राउज़र चलाएं
        page = await browser.new_page()
        await page.goto(url, wait_until='networkidle')
        
        # पृष्ठ सामग्री निकालें
        content = await page.content()
        await browser.close()  # उपयोग के बाद ब्राउज़र बंद करें
        return content

# चरण 2: LXML का उपयोग करके HTML सामग्री को पार्स करें
def parse_job_listings(content):
    # LXML का उपयोग करके HTML को पार्स करें
    parser = html.fromstring(content)
    
    # XPath का उपयोग करके व्यक्तिगत नौकरी पोस्टिंग का चयन करें
    job_posting = parser.xpath('//ul[@class="css-zu9cdh eu4oa1w0"]/li')
    
    # नौकरी डेटा निकालें
    jobs_data = []
    for element in job_posting[:-1]:
        title = ''.join(element.xpath('.//h2/a/span/@title'))
        if title:
            link = ''.join(element.xpath('.//h2/a/@href'))
            location = ''.join(element.xpath('.//div[@data-testid="text-location"]/text()'))
            description = ', '.join(element.xpath('.//div[@class="css-9446fg eu4oa1w0"]/ul//li/text()'))
            company_name = ''.join(element.xpath('.//span[@data-testid="company-name"]/text()'))

            # Append Jobs_Data सूची में निकाले गए डेटा
            jobs_data.append({
                'Title': title,
                'Link': f"https://www.indeed.com{link}",
                'Location': location,
                'Description': description,
                'Company': company_name
            })
    
    return jobs_data

# चरण 3: एक ही पृष्ठ के लिए वास्तव में नौकरियां
async def scrape_indeed_jobs(url):
    # नाटककार का उपयोग करके पृष्ठ सामग्री प्राप्त करें
    content = await get_page_content(url)
    
    # HTML को पार्स करें और नौकरी डेटा निकालें
    jobs_data = parse_job_listings(content)
    
    return jobs_data

# चरण 4: पेजिनेशन को संभालें और कई पृष्ठों को खुरचें
async def scrape_multiple_pages(base_url, query, pages=3):
    all_jobs = []
    
    for page_num in range(pages):
        # पेजिनेशन को संभालने के लिए URL को अपडेट करें और खोज क्वेरी जोड़ें
        url = f"{base_url}?q={query}&start={page_num * 10}"
        print(f"Scraping page: {url}")
        
        # वर्तमान पृष्ठ के लिए नौकरियां
        jobs = await scrape_indeed_jobs(url)
        all_jobs.extend(jobs)
    
    # सभी नौकरियों को एक CSV फ़ाइल में सहेजें
    df = pd.DataFrame(all_jobs)
    df.to_csv(f'indeed_jobs_{query}.csv', index=False)
    print(f"Data saved to indeed_jobs_{query}.csv")

# डायनेमिक क्वेरी इनपुट के साथ स्क्रैपर को चलाने के लिए कार्य करें
async def run_scraper():
    # चरण 5: उपयोगकर्ता से इनपुट क्वेरी और पेजों की संख्या के लिए पूछें
    query = input("Enter the job title or keywords to search (e.g., python+developer): ")
    pages = int(input("Enter the number of pages to scrape: "))
    
    # क्वेरी के आधार पर कई पृष्ठों पर नौकरियां
    base_url = 'https://www.indeed.com/jobs'
    await scrape_multiple_pages(base_url, query, pages)

# खुरचना
asyncio.run(run_scraper())

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