पायथन रिक्वेस्ट्स में प्रॉक्सी सेटअप कैसे करें: पार्सिंग, एपीआई और ऑटोमेशन के लिए पूर्ण गाइड कोड उदाहरणों के साथ

यदि आपका Python स्क्रिप्ट 403 त्रुटि, CAPTCHA या IP द्वारा प्रतिबंध प्राप्त करता है — इसका मतलब है कि लक्षित वेबसाइट ने आपको पहले ही पहचान लिया है। requests पुस्तकालय में प्रॉक्सी कनेक्ट करना इस समस्या का समाधान करता है: आप IP पता बदलते हैं, भौगोलिक प्रतिबंधों को बायपास करते हैं और कई पते के बीच लोड वितरित करते हैं। इस गाइड में — बुनियादी कनेक्शन से लेकर उन्नत रोटेशन तक वास्तविक कोड उदाहरणों के साथ।

Python स्क्रिप्ट में प्रॉक्सी की आवश्यकता क्यों है

अधिकांश वेबसाइटें और API आने वाले अनुरोधों के IP पतों को ट्रैक करते हैं। यदि एक पता प्रति मिनट 100+ अनुरोध करता है — इसे ब्लॉक कर दिया जाता है। यह बॉट्स के खिलाफ मानक सुरक्षा है, जिसका उपयोग Wildberries, Ozon, Avito, Google, Instagram और सैकड़ों अन्य प्लेटफार्मों द्वारा किया जाता है। प्रॉक्सी एक मध्यवर्ती सर्वर के माध्यम से अनुरोध को एक अलग IP पते के साथ निर्देशित करने की अनुमति देती है, जिससे आप सुरक्षा प्रणालियों के लिए अदृश्य हो जाते हैं।

यहाँ कुछ मुख्य कार्य हैं जहाँ Python में प्रॉक्सी की आवश्यकता होती है:

• मार्केटप्लेस डेटा खींचना — Wildberries, Ozon, यांडेक्स.मार्केट से कीमतें बिना IP प्रतिबंध के एकत्र करना
• प्रतिस्पर्धियों की निगरानी — हर 5-15 मिनट में प्रतिस्पर्धियों की वेबसाइटों पर नियमित अनुरोध
• सीमाओं के साथ API के साथ काम करना — कई IP के बीच अनुरोधों का वितरण, ताकि दर सीमा को पार न करें
• भौगोलिक परीक्षण — यह जांचना कि विभिन्न देशों और क्षेत्रों से वेबसाइट कैसी दिखती है
• फार्म और पंजीकरण का स्वचालन — विभिन्न IP से खातों का निर्माण या फ़ॉर्म भरना
• SEO निगरानी — विभिन्न क्षेत्रों से रैंकिंग निकालना

बिना प्रॉक्सी के, यहां तक कि एक अच्छी तरह से लिखित पार्सर भी कुछ घंटों के काम के भीतर ब्लॉक में आ जाएगा। सही तरीके से सेट की गई IP रोटेशन के साथ, वही स्क्रिप्ट बिना रुके हफ्तों तक काम करती है।

अनुरोधों में प्रॉक्सी का बुनियादी सेटअप

requests पुस्तकालय प्रॉक्सी का मूल रूप से समर्थन करता है — कोई अतिरिक्त पैकेज की आवश्यकता नहीं है। प्रॉक्सी को अनुरोध के पैरामीटर में proxies शब्दकोश के माध्यम से पास किया जाता है।

सबसे सरल उदाहरण — एक अनुरोध के लिए HTTP प्रॉक्सी:

import requests

proxies = {
    "http": "http://123.45.67.89:8080",
    "https": "http://123.45.67.89:8080",
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
# {'origin': '123.45.67.89'}
  

ध्यान दें: proxies शब्दकोश में दोनों कुंजियों को निर्दिष्ट करना आवश्यक है — http और https। यदि केवल एक निर्दिष्ट किया गया है, तो दूसरे प्रोटोकॉल के लिए अनुरोध सीधे प्रॉक्सी के बिना जाएंगे। यह शुरुआती लोगों की एक सामान्य गलती है, जिसके कारण वास्तविक IP फिर भी लीक हो जाता है।

यह सुनिश्चित करने के लिए कि प्रॉक्सी काम कर रही है, httpbin.org/ip सेवा का उपयोग करें — यह उस IP पते को लौटाता है, जिससे अनुरोध आया है। यदि उत्तर में आप प्रॉक्सी सर्वर का IP देखते हैं, न कि अपना — सब कुछ सही ढंग से सेट किया गया है।

HTTP, HTTPS और SOCKS5 प्रॉक्सी: अंतर और उदाहरण कोड

प्रॉक्सी विभिन्न प्रकार की होती हैं, और प्रत्येक अपनी कार्यों के लिए उपयुक्त होती है। Python अनुरोधों के संदर्भ में, तीन मुख्य प्रोटोकॉल के बीच का अंतर समझना महत्वपूर्ण है:

SOCKS5 के साथ काम करने के लिए Python में एक अतिरिक्त पैकेज स्थापित करना आवश्यक है:

pip install requests[socks]
# या अलग से:
pip install PySocks
  

स्थापना के बाद, SOCKS5 प्रॉक्सी का कनेक्शन इस प्रकार है:

import requests

# SOCKS5 प्रॉक्सी
proxies = {
    "http": "socks5://123.45.67.89:1080",
    "https": "socks5://123.45.67.89:1080",
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
  

SOCKS5 — उन कार्यों के लिए पसंदीदा प्रोटोकॉल है जहाँ गुमनामी महत्वपूर्ण है। HTTP प्रॉक्सी के विपरीत, SOCKS5 X-Forwarded-For हेडर नहीं जोड़ता है, जो आपके वास्तविक IP को उजागर कर सकता है।

लॉगिन और पासवर्ड द्वारा प्रमाणीकरण के साथ प्रॉक्सी

अधिकांश भुगतान किए गए प्रॉक्सी सेवाएँ लॉगिन और पासवर्ड द्वारा प्रमाणीकरण का उपयोग करती हैं। यह एक मानक प्रथा है — बिना प्रमाणीकरण के प्रॉक्सी आपके अनुरोध को अनुमति नहीं देगा। requests पुस्तकालय में प्रमाणीकरण डेटा प्रॉक्सी के URL में सीधे पास किया जाता है।

import requests

# प्रारूप: प्रोटोकॉल://लॉगिन:पासवर्ड@होस्ट:पोर्ट
proxy_url = "http://myuser:[email protected]:8080"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.status_code)
print(response.json())
  

यदि पासवर्ड या लॉगिन में विशेष वर्ण हैं (जैसे @, #, %), तो उन्हें URL-कोडित करना आवश्यक है। इसके लिए urllib.parse मॉड्यूल का उपयोग करें:

import requests
from urllib.parse import quote

username = "myuser"
password = "p@ss#word!"  # विशेष वर्ण

# लॉगिन और पासवर्ड को URL-कोडित करें
encoded_user = quote(username, safe="")
encoded_pass = quote(password, safe="")

proxy_url = f"http://{encoded_user}:{encoded_pass}@123.45.67.89:8080"

proxies = {
    "http": proxy_url,
    "https": proxy_url,
}

response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
  

प्रॉक्सी रोटेशन: IP का स्वचालित परिवर्तन

एक प्रॉक्सी — यह अभी भी एक IP पता है, जिसे ब्लॉक किया जा सकता है। प्रतिबंधों से बचने के लिए वास्तविक सुरक्षा रोटेशन है: प्रत्येक अनुरोध (या हर N अनुरोध) एक नए IP के साथ जाता है। नीचे रोटेशन लागू करने के लिए कुछ दृष्टिकोण दिए गए हैं।

विधि 1: सूची से यादृच्छिक चयन

import requests
import random

# प्रॉक्सी की सूची
proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

def get_random_proxy():
    proxy = random.choice(proxy_list)
    return {"http": proxy, "https": proxy}

# IP रोटेशन के साथ 10 पृष्ठों को खींचना
urls = [f"https://example.com/page/{i}" for i in range(1, 11)]

for url in urls:
    proxies = get_random_proxy()
    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        print(f"URL: {url} | IP: {proxies['http'].split('@')[1]} | स्थिति: {response.status_code}")
    except requests.RequestException as e:
        print(f"त्रुटि: {e}")
  

विधि 2: itertools के माध्यम से चक्रीय रोटेशन

import requests
import itertools

proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

# प्रॉक्सी की सूची पर अनंत चक्र बनाना
proxy_cycle = itertools.cycle(proxy_list)

def get_next_proxy():
    proxy = next(proxy_cycle)
    return {"http": proxy, "https": proxy}

# प्रत्येक अनुरोध चक्र के अनुसार अगली प्रॉक्सी का उपयोग करता है
for i in range(9):
    proxies = get_next_proxy()
    response = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
    print(f"अनुरोध {i+1}: {response.json()['origin']}")
  

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

सत्र के माध्यम से प्रॉक्सी: स्थायी कनेक्शन और कुकीज़

जब एक ही सत्र के भीतर कई अनुरोध करने की आवश्यकता होती है (जैसे, लॉगिन करना और फिर अनुरोध करना), तो requests.Session() ऑब्जेक्ट का उपयोग करें। यह अनुरोधों के बीच कुकीज़, हेडर और प्रॉक्सी सेटिंग्स को सहेजता है — हर कॉल में प्रॉक्सी को अलग से पास करने की आवश्यकता नहीं है।

import requests

# प्रॉक्सी के साथ सत्र बनाना
session = requests.Session()
session.proxies = {
    "http": "http://user:[email protected]:8080",
    "https": "http://user:[email protected]:8080",
}

# ब्राउज़र का अनुकरण करने के लिए हेडर जोड़ें
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
    "Accept-Language": "ru-RU,ru;q=0.9",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
})

# चरण 1: प्रमाणीकरण
login_data = {"username": "myuser", "password": "mypass"}
session.post("https://example.com/login", data=login_data)

# चरण 2: अब कुकीज़ और प्रॉक्सी के साथ अनुरोध
response = session.get("https://example.com/dashboard")
print(response.status_code)

# चरण 3: सत्र बंद करें
session.close()
  

Session का उपयोग करना प्रदर्शन के दृष्टिकोण से भी अधिक प्रभावी है: TCP कनेक्शन को फिर से उपयोग किया जाता है, और प्रत्येक अनुरोध के लिए इसे फिर से नहीं खोला जाता है। 1000+ पृष्ठों को खींचने पर, यह गति में महत्वपूर्ण वृद्धि देता है।

त्रुटियों, टाइमआउट और स्वचालित पुनरावृत्तियों का प्रबंधन

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

import requests
import random
import time

proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

def fetch_with_retry(url, max_retries=3, timeout=10):
    """
    त्रुटि पर प्रॉक्सी को स्वचालित रूप से बदलकर अनुरोध करता है।
    Response ऑब्जेक्ट लौटाता है या प्रयास समाप्त होने पर None लौटाता है।
    """
    available_proxies = proxy_list.copy()
    random.shuffle(available_proxies)

    for attempt, proxy_url in enumerate(available_proxies[:max_retries], 1):
        proxies = {"http": proxy_url, "https": proxy_url}
        try:
            response = requests.get(
                url,
                proxies=proxies,
                timeout=timeout,
                headers={"User-Agent": "Mozilla/5.0"}
            )
            response.raise_for_status()  # 4xx/5xx पर अपवाद फेंकता है
            print(f"✓ प्रयास {attempt} में सफलता")
            return response

        except requests.exceptions.ProxyError:
            print(f"✗ प्रयास {attempt}: प्रॉक्सी अनुपलब्ध — {proxy_url}")
        except requests.exceptions.Timeout:
            print(f"✗ प्रयास {attempt}: टाइमआउट — {proxy_url}")
        except requests.exceptions.HTTPError as e:
            print(f"✗ प्रयास {attempt}: HTTP त्रुटि {e.response.status_code}")
            if e.response.status_code == 403:
                print("  → प्रतिबंध प्राप्त हुआ, अगली प्रॉक्सी का प्रयास करें...")
        except requests.exceptions.RequestException as e:
            print(f"✗ प्रयास {attempt}: सामान्य त्रुटि — {e}")

        time.sleep(1)  # प्रयासों के बीच विराम

    print(f"✗ {url} के लिए सभी {max_retries} प्रयास समाप्त हो गए")
    return None

# उपयोग
result = fetch_with_retry("https://httpbin.org/ip")
if result:
    print(result.json())
  

raise_for_status() पर ध्यान दें — यह विधि स्वचालित रूप से 4xx और 5xx HTTP स्थिति पर अपवाद फेंकती है। इसके बिना, स्क्रिप्ट 403 (प्रतिबंध) या 429 (अनुरोधों की सीमा पार) के साथ भी सफल उत्तर को सफल मान लेगी।

पर्यावरण चर के माध्यम से प्रॉक्सी: डेटा का सुरक्षित भंडारण

requests पुस्तकालय स्वचालित रूप से HTTP_PROXY और HTTPS_PROXY पर्यावरण चर पढ़ता है। यह कोड में क्रेडेंशियल्स को संग्रहीत किए बिना प्रॉक्सी के बीच स्विच करने की अनुमति देता है।

टर्मिनल में चर सेट करना (Linux/macOS):

export HTTP_PROXY="http://user:[email protected]:8080"
export HTTPS_PROXY="http://user:[email protected]:8080"
export NO_PROXY="localhost,127.0.0.1"
  

या .env फ़ाइल के माध्यम से, जिसमें python-dotenv पुस्तकालय है:

# .env फ़ाइल (इसमें .gitignore जोड़ें!)
HTTP_PROXY=http://user:[email protected]:8080
HTTPS_PROXY=http://user:[email protected]:8080
  

# Python स्क्रिप्ट
from dotenv import load_dotenv
import requests
import os

load_dotenv()  # .env से चर लोड करें

# requests स्वचालित रूप से HTTP_PROXY और HTTPS_PROXY का उपयोग करता है
response = requests.get("https://httpbin.org/ip")
print(response.json())

# या स्पष्ट रूप से पर्यावरण चर से:
proxies = {
    "http": os.getenv("HTTP_PROXY"),
    "https": os.getenv("HTTPS_PROXY"),
}
response = requests.get("https://httpbin.org/ip", proxies=proxies)
print(response.json())
  

वास्तविक परिदृश्य: मार्केटप्लेस डेटा खींचना, API के साथ काम करना और स्वचालन

आइए तीन व्यावहारिक परिदृश्यों पर विचार करें, जिनका सामना अक्सर डेवलपर्स करते हैं।

परिदृश्य 1: मार्केटप्लेस से कीमतें खींचना

Wildberries या Ozon पर कीमतों की निगरानी करते समय, वास्तविक उपयोगकर्ता के व्यवहार की नकल करना महत्वपूर्ण है: सही ब्राउज़र हेडर भेजना, अनुरोधों के बीच देरी जोड़ना और IP को रोटेट करना। इस कार्य के लिए डेटा सेंटर प्रॉक्सी उपयुक्त हैं — ये तेज और बड़े डेटा वॉल्यूम के साथ काम करने में सस्ते हैं।

import requests
import time
import random

HEADERS = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                  "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Accept": "application/json, text/plain, */*",
    "Accept-Language": "ru-RU,ru;q=0.9",
    "Referer": "https://www.wildberries.ru/",
}

PROXIES = [
    {"http": "http://user:[email protected]:8080",
     "https": "http://user:[email protected]:8080"},
    {"http": "http://user:[email protected]:8080",
     "https": "http://user:[email protected]:8080"},
]

def get_product_price(article_id: int) -> dict:
    """Wildberries पर आर्टिकल के माध्यम से उत्पाद की कीमत प्राप्त करता है।"""
    url = f"https://card.wb.ru/cards/v1/detail?appType=1&curr=rub&nm={article_id}"
    proxies = random.choice(PROXIES)

    try:
        resp = requests.get(url, headers=HEADERS, proxies=proxies, timeout=15)
        resp.raise_for_status()
        data = resp.json()
        product = data["data"]["products"][0]
        return {
            "id": product["id"],
            "name": product["name"],
            "price": product["salePriceU"] / 100,  # कीमत को कोपेक में
        }
    except (requests.RequestException, KeyError, IndexError) as e:
        return {"error": str(e)}

# कुछ आर्टिकल्स को देरी के साथ खींचना
articles = [12345678, 87654321, 11223344]
for article in articles:
    result = get_product_price(article)
    print(result)
    time.sleep(random.uniform(1.5, 3.0))  # 1.5-3 सेकंड की यादृच्छिक देरी
  

परिदृश्य 2: प्रॉक्सी के माध्यम से API के साथ काम करना

कुछ API एक IP से अनुरोधों की संख्या को सीमित करते हैं (दर सीमा)। कई प्रॉक्सी के बीच अनुरोधों का वितरण इस सीमा को बायपास करने की अनुमति देता है:

import requests
import itertools
from typing import Optional

class ProxyAPIClient:
    """प्रॉक्सी के माध्यम से API के साथ काम करने के लिए क्लाइंट।"""

    def __init__(self, api_key: str, proxy_list: list):
        self.api_key = api_key
        self.proxy_cycle = itertools.cycle(proxy_list)
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        })

    def _get_proxy(self) -> dict:
        proxy = next(self.proxy_cycle)
        return {"http": proxy, "https": proxy}

    def get(self, url: str, **kwargs) -> Optional[dict]:
        proxies = self._get_proxy()
        try:
            resp = self.session.get(url, proxies=proxies, timeout=10, **kwargs)
            resp.raise_for_status()
            return resp.json()
        except requests.RequestException as e:
            print(f"API अनुरोध विफल रहा: {e}")
            return None

# उपयोग
proxy_list = [
    "http://user:[email protected]:8080",
    "http://user:[email protected]:8080",
]

client = ProxyAPIClient(api_key="your_api_key", proxy_list=proxy_list)
data = client.get("https://api.example.com/products")
  

परिदृश्य 3: भौगोलिक परीक्षण

मार्केटर्स और SEO विशेषज्ञ अक्सर यह जांचते हैं कि विभिन्न क्षेत्रों से वेबसाइट कैसी दिखती है। आवश्यक स्थानों से प्रॉक्सी के माध्यम से इस प्रक्रिया को स्वचालित किया जा सकता है:

import requests

# विभिन्न क्षेत्रों से प्रॉक्सी
regional_proxies = {
    "मॉस्को":        "http://user:[email protected]:8080",
    "सेंट पीटर्सबर्ग": "http://user:[email protected]:8080",
    "नोवोसिबिर्स्क":   "http://user:[email protected]:8080",
    "यूएसए":           "http://user:[email protected]:8080",
}

url = "https://example.com/prices"

for region, proxy_url in regional_proxies.items():
    proxies = {"http": proxy_url, "https": proxy_url}
    try:
        resp = requests.get(url, proxies=proxies, timeout=15)
        print(f"[{region}] स्थिति: {resp.status_code} | "
              f"आकार: {len(resp.content)} बाइट्स")
    except requests.RequestException as e:
        print(f"[{region}] त्रुटि: {e}")
  

अपने कार्य के लिए किस प्रकार की प्रॉक्सी चुनें

प्रॉक्सी के प्रकार का चयन आपके प्रोजेक्ट की सफलता पर सीधा प्रभाव डालता है। सस्ती डेटा सेंटर प्रॉक्सी कुछ कार्यों के लिए उत्कृष्ट काम कर सकती है और अन्य के लिए पूरी तरह से विफल हो सकती है। यहाँ चयन के लिए एक व्यावहारिक गाइड है:

उन कार्यों के लिए जहाँ अधिकतम विश्वसनीयता और सुरक्षित वेबसाइटों के साथ काम करते समय ब्लॉक होने का न्यूनतम जोखिम महत्वपूर्ण है, डेवलपर्स अक्सर मोबाइल प्रॉक्सी का चयन करते हैं — ये वास्तविक मोबाइल ऑपरेटरों (MTS, Beeline, MegaFon) के IP पतों का उपयोग करते हैं, जो बहुत कम ब्लॉक लिस्ट में आते हैं।

प्रॉक्सी का उपयोग करने से पहले जांचने के लिए चेकलिस्ट

• ✅ httpbin.org/ip के माध्यम से IP की जांच करें — क्या आपका असली पता दिखाई दे रहा है?
• ✅ गति की जांच करें — प्रतिक्रिया का समय 2-3 सेकंड से अधिक नहीं होना चाहिए
• ✅ सुनिश्चित करें कि प्रॉक्सी ब्लॉक लिस्ट में नहीं है blocklist.de या ipqualityscore.com के माध्यम से
• ✅ ipinfo.io के माध्यम से भौगोलिक स्थान की जांच करें — क्या यह अपेक्षित क्षेत्र से मेल खाता है?
• ✅ पूर्ण स्क्रिप्ट चलाने से पहले एक अनुरोध पर लक्षित वेबसाइट पर परीक्षण करें
• ✅ सुनिश्चित करें कि HTTPS ट्रैफ़िक भी प्रॉक्सी के माध्यम से जा रहा है (शब्दकोश में दोनों कुंजियाँ)

निष्कर्ष

Python अनुरोधों में प्रॉक्सी सेट करना मुश्किल नहीं है, लेकिन विवरण पर ध्यान देने की आवश्यकता है। याद रखने के लिए मुख्य सिद्धांत: प्रॉक्सी शब्दकोश में हमेशा दोनों कुंजियाँ (http और https) निर्दिष्ट करें, बहु-चरण परिदृश्यों के लिए Session का उपयोग करें, त्रुटियों और टाइमआउट को संभालना सुनिश्चित करें, और क्रेडेंशियल्स को कोड में नहीं, बल्कि पर्यावरण चर में संग्रहीत करें।

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