वेब डेटा को स्क्रैप करते समय प्रॉक्सी को कैसे घुमाएं

डेटा एकत्र करने के लिए इस दृष्टिकोण के रूप में अच्छा लगता है, यह कई वेबसाइटों द्वारा डूब गया है, और हमारे आईपी पर प्रतिबंध की तरह स्क्रैपिंग के साथ निम्नलिखित परिणाम हैं।

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

इस गाइड के लिए लक्ष्य वेबसाइट (स्रोत) एक ऑनलाइन बुकस्टोर है। यह पुस्तकों के लिए एक ई-कॉमर्स वेबसाइट की नकल करता है। इस पर एक नाम, मूल्य और उपलब्धता वाली किताबें हैं। चूंकि यह गाइड वापस लौटे डेटा को व्यवस्थित करने पर ध्यान केंद्रित नहीं करता है, लेकिन परदे के पीछे घूमने पर, लौटाए गए डेटा को केवल कंसोल में प्रस्तुत किया जाएगा।

काम के माहौल को तैयार करना और प्रॉक्सी को एकीकृत करना

कुछ पायथन मॉड्यूल को हमारी फ़ाइल में स्थापित और आयात करने से पहले हम उन कार्यों को कोड करना शुरू कर सकते हैं जो प्रॉक्सी को घुमाने और वेबसाइट को स्क्रैप करने में सहायता करेंगे।

pip install requests beautifulSoup4 lxml

इस स्क्रैपिंग स्क्रिप्ट के लिए आवश्यक 5 पायथन मॉड्यूल में से 3 को ऊपर दिए गए कमांड का उपयोग करके स्थापित किया जा सकता है। अनुरोध हमें वेबसाइट पर HTTP अनुरोध भेजने की अनुमति देता है, BeautiveSoup4 हमें अनुरोधों द्वारा प्रदान किए गए पृष्ठ के HTML से जानकारी निकालने की अनुमति देता है, और LXML एक HTML पार्सर है।

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

import requests
import threading
from requests.auth import HTTPProxyAuth
import json
from bs4 import BeautifulSoup
import lxml
import time

url_to_scrape = "https://books.toscrape.com"
valid_proxies = []
book_names = []
book_price = []
book_availability = []
next_button_link = ""

चरण 1: प्रॉक्सी की सूची से प्रॉक्सी को सत्यापित करना

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

इसके लिए सबसे अच्छा तरीका यह है कि हमारी प्रॉक्सी जानकारी को एक अलग JSON फ़ाइल में नीचे की तरह आयोजित किया जाए:

[
  {
    "proxy_address": "XX.X.XX.X:XX",
    "proxy_username": "",
    "proxy_password": ""
  },

  {
    "proxy_address": "XX.X.XX.X:XX",
    "proxy_username": "",
    "proxy_password": ""
  },
  {
    "proxy_address": "XX.X.XX.X:XX",
    "proxy_username": "",
    "proxy_password": ""
  },
  {
    "proxy_address": "XX.X.XX.X:XX",
    "proxy_username": "",
    "proxy_password": ""
  }
]

"Proxy_address" फ़ील्ड में, एक बृहदान्त्र द्वारा अलग किए गए IP पता और पोर्ट दर्ज करें। "Proxy_username" और "Proxy_password" फ़ील्ड में, प्राधिकरण के लिए उपयोगकर्ता नाम और पासवर्ड प्रदान करते हैं।

ऊपर स्क्रिप्ट के लिए 4 प्रॉक्सी के साथ एक JSON फ़ाइल की सामग्री है। उपयोगकर्ता नाम और पासवर्ड खाली हो सकता है, एक प्रॉक्सी को इंगित करता है जिसे कोई प्रमाणीकरण की आवश्यकता नहीं है।

def verify_proxies(proxy:dict):
    try:
        if proxy['proxy_username'] != "" and  proxy['proxy_password'] != "":
            proxy_auth = HTTPProxyAuth(proxy['proxy_username'], proxy['proxy_password'])
            res = requests.get(
                url_to_scrape,
                auth = proxy_auth,
                proxies={
                "http" : proxy['proxy_address']
                }
            )
        else:
            res = requests.get(url_to_scrape, proxies={
                "http" : proxy['proxy_address'],
            })
        
        if res.status_code == 200:
            valid_proxies.append(proxy)
            print(f"Proxy Validated: {proxy['proxy_address']}")
            
    except:
        print("Proxy Invalidated, Moving on")

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

चरण 2: वेब स्क्रैपिंग अनुरोध भेजना

चूंकि BeautifulSoup को हमारे द्वारा आवश्यक डेटा निकालने के लिए वेबसाइट के HTML कोड की आवश्यकता होती है, इसलिए हमने अनुरोध_फंक्शन () बनाया है, जो पसंद के URL और प्रॉक्सी को लेता है और HTML कोड को पाठ के रूप में लौटाता है। प्रॉक्सी वैरिएबल हमें अलग -अलग प्रॉक्सी के माध्यम से अनुरोध को रूट करने में सक्षम बनाता है, इसलिए प्रॉक्सी को घुमाता है।

def request_function(url, proxy):
    try:
        if proxy['proxy_username'] != "" and  proxy['proxy_password'] != "":
            proxy_auth = HTTPProxyAuth(proxy['proxy_username'], proxy['proxy_password'])
            response = requests.get(
                url,
                auth = proxy_auth,
                proxies={
                "http" : proxy['proxy_address']
                }
            )
        else:
            response = requests.get(url, proxies={
                "http" : proxy['proxy_address']
            })
        
        if response.status_code == 200:
            return response.text

    except Exception as err:
        print(f"Switching Proxies, URL access was unsuccessful: {err}")
        return None

चरण 3: लक्ष्य वेबसाइट से डेटा निकालना

data_extract () प्रदान किए गए HTML कोड से हमें आवश्यक डेटा को निकालता है। यह HTML तत्व को पुस्तक नाम, मूल्य और उपलब्धता जैसी पुस्तक की जानकारी को इकट्ठा करता है। यह अगले पृष्ठ के लिए लिंक भी निकालता है।

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

def data_extract(response):
    soup = BeautifulSoup(response, "lxml")
    books = soup.find_all("li", class_="col-xs-6 col-sm-4 col-md-3 col-lg-3")
    next_button_link = soup.find("li", class_="next").find('a').get('href')
    next_button_link=f"{url_to_scrape}/{next_button_link}" if "catalogue" in next_button_link else f"{url_to_scrape}/catalogue/{next_button_link}"

    for each in books:
        book_names.append(each.find("img").get("alt"))
        book_price.append(each.find("p", class_="price_color").text)
        book_availability.append(each.find("p", class_="instock availability").text.strip())

    return next_button_link

चरण 4: सब कुछ एक साथ जोड़ना

सब कुछ एक साथ जोड़ने के लिए, हमें करना होगा:

1. JSON फ़ाइल से प्रॉक्सी विवरण लोड करें। थ्रेडिंग का उपयोग करके प्रत्येक प्रॉक्सी के लिए एक थ्रेड शुरू करें। थ्रेड ()। यह हमें एक समय में कई परदे के पीछे का परीक्षण करने में मदद करेगा। मान्य प्रॉक्सी को वैध_प्रॉक्सियों () में जोड़ा जाता है।
2. एक वैध प्रॉक्सी का उपयोग करके स्रोत के मुखपृष्ठ को लोड करें। यदि कोई प्रॉक्सी काम नहीं करता है, तो हम अगले एक का उपयोग करते हैं, यह सुनिश्चित करने के लिए कि होमपेज लोड या निष्पादन जारी रखने से पहले कोई भी वापस नहीं करता है।
3. तब हम सक्रिय प्रॉक्सी के माध्यम से साइकिल चलाते हैं, GET अनुरोध बनाने के लिए request_function () फ़ंक्शन का उपयोग करें। और अगर हमें एक GET अनुरोध मिला है, तो हम साइट से डेटा एकत्र करते हैं।
4. अंत में, हम कंसोल पर इकट्ठा किए गए डेटा को प्रिंट करते हैं।

with open("proxy-list.json") as json_file:
    proxies = json.load(json_file)
    for each in proxies:
        threading.Thread(target=verify_proxies, args=(each, )).start() 


time.sleep(4)

for i in range(len(valid_proxies)):
    response = request_function(url_to_scrape, valid_proxies[i])
    if response != None:
        next_button_link = data_extract(response)
        break
    else:
        continue

for proxy in valid_proxies:
   print(f"Using Proxy: {proxy['proxy_address']}")
   response = request_function(next_button_link, proxy)
   if response is not None:
       next_button_link = data_extract(response)
   else:
       continue


for each in range(len(book_names)):
    print(f"No {each+1}: Book Name: {book_names[each]} Book Price: {book_price[each]} and Availability {book_availability[each]}")

पूर्ण कोड

import requests
import threading
from requests.auth import HTTPProxyAuth
import json
from bs4 import BeautifulSoup
import time

url_to_scrape = "https://books.toscrape.com"
valid_proxies = []
book_names = []
book_price = []
book_availability = []
next_button_link = ""


def verify_proxies(proxy: dict):
   try:
       if proxy['proxy_username'] != "" and proxy['proxy_password'] != "":
           proxy_auth = HTTPProxyAuth(proxy['proxy_username'], proxy['proxy_password'])
           res = requests.get(
               url_to_scrape,
               auth=proxy_auth,
               proxies={
                   "http": proxy['proxy_address'],
               }
           )
       else:
           res = requests.get(url_to_scrape, proxies={
               "http": proxy['proxy_address'],
           })

       if res.status_code == 200:
           valid_proxies.append(proxy)
           print(f"Proxy Validated: {proxy['proxy_address']}")

   except:
       print("Proxy Invalidated, Moving on")


# एक पृष्ठ के HTML तत्व को पुनः प्राप्त करता है
def request_function(url, proxy):
   try:
       if proxy['proxy_username'] != "" and proxy['proxy_password'] != "":
           proxy_auth = HTTPProxyAuth(proxy['proxy_username'], proxy['proxy_password'])
           response = requests.get(
               url,
               auth=proxy_auth,
               proxies={
                   "http": proxy['proxy_address'],
               }
           )
       else:
           response = requests.get(url, proxies={
               "http": proxy['proxy_address'],
           })

       if response.status_code == 200:
           return response.text

   except Exception as err:
       print(f"Switching Proxies, URL access was unsuccessful: {err}")
       return None


# स्क्रैपिंग
def data_extract(response):
   soup = BeautifulSoup(response, "lxml")
   books = soup.find_all("li", class_="col-xs-6 col-sm-4 col-md-3 col-lg-3")
   next_button_link = soup.find("li", class_="next").find('a').get('href')
   next_button_link = f"{url_to_scrape}/{next_button_link}" if "catalogue" in next_button_link else f"{url_to_scrape}/catalogue/{next_button_link}"

   for each in books:
       book_names.append(each.find("img").get("alt"))
       book_price.append(each.find("p", class_="price_color").text)
       book_availability.append(each.find("p", class_="instock availability").text.strip())

   return next_button_link


# JSON से प्रॉक्सी प्राप्त करें
with open("proxy-list.json") as json_file:
   proxies = json.load(json_file)
   for each in proxies:
       threading.Thread(target=verify_proxies, args=(each,)).start()

time.sleep(4)

for i in range(len(valid_proxies)):
   response = request_function(url_to_scrape, valid_proxies[i])
   if response is not None:
       next_button_link = data_extract(response)
       break
   else:
       continue

for proxy in valid_proxies:
   print(f"Using Proxy: {proxy['proxy_address']}")
   response = request_function(next_button_link, proxy)
   if response is not None:
       next_button_link = data_extract(response)
   else:
       continue

for each in range(len(book_names)):
   print(
       f"No {each + 1}: Book Name: {book_names[each]} Book Price: {book_price[each]} and Availability {book_availability[each]}")

अंतिम परिणाम

एक सफल निष्पादन के बाद, परिणाम नीचे की तरह दिखते हैं। यह प्रदान किए गए 2 प्रॉक्सी का उपयोग करके 100 से अधिक पुस्तकों पर जानकारी निकालने के लिए जाता है।

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