Python requests ve aiohttp'de proxy: 5 dakikada ayarlama

```html

Veri toplayıcıları geliştirirken, veri toplama otomasyonu yaparken veya Python'dan web hizmetlerini test ederken sıkça proxy sunucuları kullanmak gerekebilir. requests ve aiohttp proxy ile çalışma için esnek mekanizmalar sunar, ancak ayarları önemli nüanslar içerir. Bu kılavuzda senkron ve asenkron yaklaşımları inceleyecek, HTTP ve SOCKS5 proxy için örnekler gösterecek, IP döngüsünü ve hata işlemesini ele alacağız.

requests'de Proxy Temel Ayarı

requests kütüphanesi, Python'da HTTP istekleri için standarttır. Proxy ayarı, proxy sunucularının protokolleri ve adresleri ile bir sözlük alan proxies parametresi aracılığıyla yapılır.

HTTP Proxy ile En Basit Örnek:

import requests

# Proxy ayarı
proxies = {
    'http': 'http://123.45.67.89:8080',
    'https': 'http://123.45.67.89:8080'
}

# Proxy üzerinden istek yapma
response = requests.get('https://httpbin.org/ip', proxies=proxies)
print(response.json())  # {'origin': '123.45.67.89'}

Dikkat: HTTPS istekleri için proxy değerinde http:// protokolü belirtilmelidir (not https://). Bu, proxy sunucusuna HTTP üzerinden bağlantı kurulduğu ve ardından CONNECT yöntemi aracılığıyla HTTPS trafiği için bir tünel oluşturulduğu anlamına gelir.

Ortam Değişkenlerinin Kullanımı:

requests kütüphanesi, proxy'leri otomatik olarak HTTP_PROXY ve HTTPS_PROXY ortam değişkenlerinden okur:

import os
import requests

# Ortam değişkenleri aracılığıyla ayarlama
os.environ['HTTP_PROXY'] = 'http://123.45.67.89:8080'
os.environ['HTTPS_PROXY'] = 'http://123.45.67.89:8080'

# Proxy otomatik olarak uygulanır
response = requests.get('https://httpbin.org/ip')
print(response.json())

Bu yaklaşım, konteynerleştirme (Docker) için veya proxy'lerin sistem düzeyinde ayarlandığı durumlarda kullanışlıdır. Ancak esneklik için proxies parametresinin açıkça iletilmesi önerilir.

requests'de Kimlik Doğrulama ve SOCKS5

Çoğu ticari proxy hizmeti, kullanıcı adı ve şifre ile kimlik doğrulama gerektirir. requests'de bu, kimlik bilgileri ile URL formatı aracılığıyla gerçekleştirilir.

Kimlik Doğrulama ile HTTP Proxy:

import requests

# Format: http://kullanici_adi:sifre@host:port
proxies = {
    'http': 'http://user123:pass456@proxy.example.com:8080',
    'https': 'http://user123:pass456@proxy.example.com:8080'
}

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

SOCKS5 Proxy Ayarı:

SOCKS5 ile çalışmak için ek bir kütüphane olan requests[socks] veya PySocks gereklidir. Kurulum:

pip install requests[socks]

SOCKS5 kullanımı örneği:

import requests

# Kimlik doğrulama olmadan SOCKS5
proxies = {
    'http': 'socks5://123.45.67.89:1080',
    'https': 'socks5://123.45.67.89:1080'
}

# Kimlik doğrulama ile SOCKS5
proxies_auth = {
    'http': 'socks5://user:pass@123.45.67.89:1080',
    'https': 'socks5://user:pass@123.45.67.89:1080'
}

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

SOCKS5 proxy, rezidans proxy'leri ile çalışırken özellikle faydalıdır, çünkü bu protokol daha güvenilir bir trafik tünelleme sağlar ve UDP'yi destekler (bazı uygulamalar için gereklidir).

requests'de Proxy Döngüsü

Büyük veri setlerini işlerken tek bir IP adresi kullanmak engellemelere yol açar. Proxy döngüsü, yük dağılımı ve oran limitlerini aşmak için IP'lerin döngüsel olarak değiştirilmesidir.

Liste Üzerinden Basit Döngü:

import requests
import itertools

# Proxy sunucuları listesi
proxy_list = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
]

# Sonsuz bir iteratör oluşturma
proxy_pool = itertools.cycle(proxy_list)

# Döngü ile istek yapma
for i in range(10):
    proxy = next(proxy_pool)
    proxies = {'http': proxy, 'https': proxy}
    
    try:
        response = requests.get('https://httpbin.org/ip', proxies=proxies, timeout=5)
        print(f"İstek {i+1}: IP = {response.json()['origin']}")
    except Exception as e:
        print(f"Proxy ile hata {proxy}: {e}")

Cookies'i Koruyarak Döngü:

import requests
from itertools import cycle

class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxy_pool = cycle(proxy_list)
        self.session = requests.Session()
    
    def get(self, url, **kwargs):
        proxy = next(self.proxy_pool)
        self.session.proxies = {'http': proxy, 'https': proxy}
        return self.session.get(url, **kwargs)

# Kullanım
proxy_list = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
]

rotator = ProxyRotator(proxy_list)

for i in range(5):
    response = rotator.get('https://httpbin.org/ip', timeout=5)
    print(f"İstek {i+1}: {response.json()['origin']}")

Rastgele Döngü için Tahmin Edilemezlik:

import requests
import random

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

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

# Her istek için rastgele proxy
for i in range(5):
    response = requests.get('https://httpbin.org/ip', proxies=get_random_proxy(), timeout=5)
    print(f"İstek {i+1}: {response.json()['origin']}")

Rastgele döngü, istek kalıplarını izleyen sitelerle çalışırken daha etkilidir. Ardışık IP değişimi şüpheli görünebilirken, rastgele seçim farklı kullanıcıların davranışını taklit eder.

aiohttp'de Proxy Ayarı

aiohttp kütüphanesi, asenkron HTTP istekleri için tasarlanmıştır ve yüksek yük altındaki veri toplayıcıları için kritik öneme sahiptir. Proxy ayarı, requests'den farklı olarak proxy (tekil) parametresi kullanılarak yapılır.

HTTP Proxy ile Temel Örnek:

import aiohttp
import asyncio

async def fetch_with_proxy():
    proxy = 'http://123.45.67.89:8080'
    
    async with aiohttp.ClientSession() as session:
        async with session.get('https://httpbin.org/ip', proxy=proxy) as response:
            data = await response.json()
            print(data)

# Çalıştırma
asyncio.run(fetch_with_proxy())

Kimlik Doğrulama ile Proxy:

aiohttp'de kimlik doğrulama, aiohttp.BasicAuth nesnesi aracılığıyla veya doğrudan URL'de iletilir:

import aiohttp
import asyncio

async def fetch_with_auth_proxy():
    # Seçenek 1: Kimlik bilgileri URL'de
    proxy = 'http://user123:pass456@proxy.example.com:8080'
    
    async with aiohttp.ClientSession() as session:
        async with session.get('https://httpbin.org/ip', proxy=proxy) as response:
            print(await response.json())

# Seçenek 2: BasicAuth ile (bazı proxy'ler için)
async def fetch_with_basic_auth():
    proxy = 'http://proxy.example.com:8080'
    proxy_auth = aiohttp.BasicAuth('user123', 'pass456')
    
    async with aiohttp.ClientSession() as session:
        async with session.get('https://httpbin.org/ip', 
                                proxy=proxy, 
                                proxy_auth=proxy_auth) as response:
            print(await response.json())

asyncio.run(fetch_with_auth_proxy())

SOCKS5 için aiohttp:

SOCKS5 için aiohttp-socks kütüphanesi gereklidir:

pip install aiohttp-socks

import asyncio
from aiohttp_socks import ProxyConnector
import aiohttp

async def fetch_with_socks5():
    connector = ProxyConnector.from_url('socks5://user:pass@123.45.67.89:1080')
    
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get('https://httpbin.org/ip') as response:
            print(await response.json())

asyncio.run(fetch_with_socks5())

Mobil proxy'ler ile sosyal medya veya pazar yerlerini tararken aiohttp kullanılması önerilir — asenkronluk, yüzlerce isteği eşzamanlı olarak işleme imkanı sunar.

Asenkron Döngü ve Proxy Havuzu

Yüksek yük altındaki veri toplayıcıları için, hataları işleyerek ve çalışmayan IP'leri otomatik olarak değiştirerek etkili bir proxy döngüsü kritik öneme sahiptir. aiohttp için gelişmiş kalıpları inceleyelim.

Proxy Havuzunu Yönetmek için Sınıf:

import aiohttp
import asyncio
from itertools import cycle
from typing import List, Optional

class ProxyPool:
    def __init__(self, proxy_list: List[str]):
        self.proxy_list = proxy_list
        self.proxy_cycle = cycle(proxy_list)
        self.failed_proxies = set()
    
    def get_next_proxy(self) -> Optional[str]:
        """Sonraki çalışır proxy'yi al"""
        for _ in range(len(self.proxy_list)):
            proxy = next(self.proxy_cycle)
            if proxy not in self.failed_proxies:
                return proxy
        return None  # Tüm proxy'ler erişilemez
    
    def mark_failed(self, proxy: str):
        """Proxy'yi çalışmaz olarak işaretle"""
        self.failed_proxies.add(proxy)
        print(f"Proxy {proxy} erişilemez olarak işaretlendi")
    
    async def fetch(self, session: aiohttp.ClientSession, url: str, **kwargs):
        """Hata durumunda otomatik proxy değişimi ile istek yap"""
        max_retries = 3
        
        for attempt in range(max_retries):
            proxy = self.get_next_proxy()
            if not proxy:
                raise Exception("Tüm proxy'ler erişilemez")
            
            try:
                async with session.get(url, proxy=proxy, timeout=aiohttp.ClientTimeout(total=10), **kwargs) as response:
                    return await response.json()
            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                print(f"Proxy ile hata {proxy}: {e}")
                self.mark_failed(proxy)
                continue
        
        raise Exception(f"{max_retries} denemeden sonra isteği gerçekleştiremedim")

# Kullanım
async def main():
    proxy_list = [
        'http://user:pass@proxy1.example.com:8080',
        'http://user:pass@proxy2.example.com:8080',
        'http://user:pass@proxy3.example.com:8080',
    ]
    
    pool = ProxyPool(proxy_list)
    
    async with aiohttp.ClientSession() as session:
        # Otomatik döngü ile 10 istek yapma
        tasks = [pool.fetch(session, 'https://httpbin.org/ip') for _ in range(10)]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        for i, result in enumerate(results):
            if isinstance(result, Exception):
                print(f"İstek {i+1} hata ile sonuçlandı: {result}")
            else:
                print(f"İstek {i+1}: IP = {result.get('origin')}")

asyncio.run(main())

Eşzamanlılık Sınırlaması ile Paralel İşleme:

import aiohttp
import asyncio
from itertools import cycle

async def fetch_url(session, url, proxy, semaphore):
    async with semaphore:  # Eşzamanlı istek sınırlaması
        try:
            async with session.get(url, proxy=proxy, timeout=aiohttp.ClientTimeout(total=10)) as response:
                data = await response.json()
                return {'url': url, 'ip': data.get('origin'), 'status': response.status}
        except Exception as e:
            return {'url': url, 'error': str(e)}

async def main():
    urls = [f'https://httpbin.org/ip' for _ in range(50)]  # 50 istek
    proxy_list = [
        'http://user:pass@proxy1.example.com:8080',
        'http://user:pass@proxy2.example.com:8080',
    ]
    proxy_cycle = cycle(proxy_list)
    
    # Sınırlama: en fazla 10 eşzamanlı istek
    semaphore = asyncio.Semaphore(10)
    
    async with aiohttp.ClientSession() as session:
        tasks = [
            fetch_url(session, url, next(proxy_cycle), semaphore)
            for url in urls
        ]
        results = await asyncio.gather(*tasks)
        
        # Sonuçları analiz etme
        successful = [r for r in results if 'ip' in r]
        failed = [r for r in results if 'error' in r]
        
        print(f"Başarılı istekler: {len(successful)}")
        print(f"Başarısız istekler: {len(failed)}")

asyncio.run(main())

asyncio.Semaphore kullanımı, proxy ile çalışırken kritik öneme sahiptir — bir IP üzerinden çok sayıda eşzamanlı bağlantı, hedef site veya proxy sağlayıcısı tarafından engellenme riski taşır.

Hata İşleme ve Zaman Aşımı

Proxy ile çalışma, zaman aşımı, bağlantı kopmaları, proxy sunucularının reddi gibi artan hata sayısı ile ilişkilidir. Hataların doğru bir şekilde işlenmesi, veri toplayıcının kararlılığı için anahtardır.

Proxy ile Çalışırken Yaygın Hatalar:

Hata	Sebep	Çözüm
`ProxyError`	Proxy sunucusu erişilemez	Başka bir proxy'ye geçiş yap
`ConnectTimeout`	Proxy zamanında yanıt vermiyor	Zaman aşımını artır veya proxy'yi değiştir
`ProxyAuthenticationRequired`	Yanlış kullanıcı adı/şifre	Kimlik bilgilerini kontrol et
`SSLError`	SSL sertifikası ile ilgili sorunlar	SSL kontrolünü devre dışı bırak (tavsiye edilmez)
`TooManyRedirects`	Proxy yönlendirme döngüsü oluşturuyor	Proxy'yi değiştir veya yönlendirmeleri sınırla

requests'de Hata İşleme:

import requests
from requests.exceptions import ProxyError, ConnectTimeout, RequestException

def fetch_with_retry(url, proxies, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(
                url, 
                proxies=proxies, 
                timeout=(5, 10),  # (bağlantı zaman aşımı, okuma zaman aşımı)
                allow_redirects=True,
                verify=True  # SSL sertifikası kontrolü
            )
            response.raise_for_status()  # 4xx/5xx durumunda istisna oluşturur
            return response.json()
            
        except ProxyError as e:
            print(f"Deneme {attempt + 1}: Proxy erişilemez - {e}")
        except ConnectTimeout as e:
            print(f"Deneme {attempt + 1}: Bağlantı zaman aşımı - {e}")
        except requests.exceptions.HTTPError as e:
            print(f"Deneme {attempt + 1}: HTTP hatası {e.response.status_code}")
            if e.response.status_code == 407:  # Proxy Kimlik Doğrulama Gerekiyor
                print("Proxy kimlik doğrulama hatası!")
                break  # Kimlik doğrulama hatasında tekrar etme
        except RequestException as e:
            print(f"Deneme {attempt + 1}: Genel hata - {e}")
        
        if attempt < max_retries - 1:
            print(f"2 saniye sonra tekrar...")
            import time
            time.sleep(2)
    
    raise Exception(f"{max_retries} denemeden sonra isteği gerçekleştiremedim")

# Kullanım
proxies = {'http': 'http://user:pass@proxy.example.com:8080', 'https': 'http://user:pass@proxy.example.com:8080'}
try:
    data = fetch_with_retry('https://httpbin.org/ip', proxies)
    print(data)
except Exception as e:
    print(f"Kritik hata: {e}")

aiohttp'de Hata İşleme:

import aiohttp
import asyncio
from aiohttp import ClientError, ClientProxyConnectionError

async def fetch_with_retry(session, url, proxy, max_retries=3):
    for attempt in range(max_retries):
        try:
            timeout = aiohttp.ClientTimeout(total=10, connect=5)
            async with session.get(url, proxy=proxy, timeout=timeout) as response:
                response.raise_for_status()
                return await response.json()
                
        except ClientProxyConnectionError as e:
            print(f"Deneme {attempt + 1}: Proxy bağlantı hatası - {e}")
        except asyncio.TimeoutError:
            print(f"Deneme {attempt + 1}: Zaman aşımı")
        except aiohttp.ClientHttpProxyError as e:
            print(f"Deneme {attempt + 1}: Proxy HTTP hatası - {e}")
            if e.status == 407:
                print("Proxy kimlik doğrulama hatası!")
                break
        except ClientError as e:
            print(f"Deneme {attempt + 1}: Genel istemci hatası - {e}")
        
        if attempt < max_retries - 1:
            await asyncio.sleep(2)
    
    raise Exception(f"{max_retries} denemeden sonra isteği gerçekleştiremedim")

async def main():
    proxy = 'http://user:pass@proxy.example.com:8080'
    async with aiohttp.ClientSession() as session:
        try:
            data = await fetch_with_retry(session, 'https://httpbin.org/ip', proxy)
            print(data)
        except Exception as e:
            print(f"Kritik hata: {e}")

asyncio.run(main())

Zaman Aşımı Ayarlama:

Zaman aşımının doğru ayarlanması kararlılık için kritik öneme sahiptir. Önerilen değerler:

Bağlantı zaman aşımı: 5-10 saniye (proxy ile bağlantı kurma süresi)
Okuma zaman aşımı: 10-30 saniye (hedef siteden yanıt alma süresi)
Toplam zaman aşımı: 30-60 saniye (isteğin toplam süresi)

Yavaş rezidans proxy'leri için, bağlantı başına zaman aşımını 20-30 saniyeye kadar artırmak önerilir, çünkü gerçek sağlayıcılar üzerinden yönlendirme daha fazla zaman alabilir.

En İyi Uygulamalar ve Optimizasyon

Proxy ile etkili bir şekilde çalışmak, engellemeleri en aza indirmek ve performansı maksimize etmek için bir dizi kuralı takip etmeyi gerektirir.

1. Bağlantıları yeniden kullanmak için Session kullanımı:

# requests: Session TCP bağlantılarını yeniden kullanır
session = requests.Session()
session.proxies = {'http': proxy, 'https': proxy}

for url in urls:
    response = session.get(url)  # requests.get()'ten daha hızlıdır

# aiohttp: Asenkronluk için Session zorunludur
async with aiohttp.ClientSession() as session:
    tasks = [session.get(url, proxy=proxy) for url in urls]
    await asyncio.gather(*tasks)

2. Gerçekçi User-Agent ve başlıklar ayarlama:

import requests

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': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
    'Accept-Language': 'en-US,en;q=0.5',
    'Accept-Encoding': 'gzip, deflate, br',
    'DNT': '1',
    'Connection': 'keep-alive',
    'Upgrade-Insecure-Requests': '1'
}

proxies = {'http': proxy, 'https': proxy}
response = requests.get('https://example.com', headers=headers, proxies=proxies)

3. Oran limitini sınırlama (saniyedeki istek sayısı):

import time
import requests

class RateLimiter:
    def __init__(self, max_requests_per_second):
        self.max_requests = max_requests_per_second
        self.interval = 1.0 / max_requests_per_second
        self.last_request_time = 0
    
    def wait(self):
        elapsed = time.time() - self.last_request_time
        if elapsed < self.interval:
            time.sleep(self.interval - elapsed)
        self.last_request_time = time.time()

# Kullanım: saniyede en fazla 2 istek
limiter = RateLimiter(2)
proxies = {'http': proxy, 'https': proxy}

for url in urls:
    limiter.wait()
    response = requests.get(url, proxies=proxies)

4. Proxy'leri izleme ve günlükleme:

import logging
from collections import defaultdict

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ProxyMonitor:
    def __init__(self):
        self.stats = defaultdict(lambda: {'success': 0, 'failed': 0, 'total_time': 0})
    
    def log_request(self, proxy, success, response_time):
        stats = self.stats[proxy]
        if success:
            stats['success'] += 1
        else:
            stats['failed'] += 1
        stats['total_time'] += response_time
        
        # Her 10 istekte bir günlükleme
        total = stats['success'] + stats['failed']
        if total % 10 == 0:
            avg_time = stats['total_time'] / total
            success_rate = stats['success'] / total * 100
            logger.info(f"Proxy {proxy}: {total} istek, başarı {success_rate:.1f}%, ortalama {avg_time:.2f}s")

monitor = ProxyMonitor()

# İstek kodunda
import time
start = time.time()
try:
    response = requests.get(url, proxies=proxies, timeout=10)
    monitor.log_request(proxy, True, time.time() - start)
except Exception as e:
    monitor.log_request(proxy, False, time.time() - start)
    logger.error(f"Proxy ile hata {proxy}: {e}")

5. DNS önbellekleme ile hızlandırma:

# aiohttp ile DNS önbellekleme
import aiohttp
from aiohttp.resolver import AsyncResolver

resolver = AsyncResolver(nameservers=['8.8.8.8', '8.8.4.4'])
connector = aiohttp.TCPConnector(resolver=resolver, ttl_dns_cache=300)

async with aiohttp.ClientSession(connector=connector) as session:
    # İstekler 5 dakika boyunca DNS önbelleğini kullanacaktır
    async with session.get(url, proxy=proxy) as response:
        data = await response.json()

6. CAPTCHA ve engellemeleri işleme:

İpucu: 403, 429 veya CAPTCHA durumu alındığında önerilir:

Proxy'yi başka bir alt ağdan IP ile değiştirin
İstekler arasındaki gecikmeyi artırın (5-10 saniyeye kadar)
User-Agent ve diğer başlıkları değiştirin
Önceki başarılı oturumlardan çerezleri kullanın

requests ve aiohttp'nin Proxy İçin Karşılaştırması

requests ve aiohttp arasında seçim yapmak, göreve ve veri hacmine bağlıdır. Anahtar farklılıkları inceleyelim.

Kriter	requests	aiohttp
Senkronizasyon	Senkron (engelleyici)	Asenkron (engellemeyen)
Performans	~10-50 istek/saniye	~100-1000 istek/saniye
Kodun Basitliği	Yeni başlayanlar için daha basit	async/await bilgisi gerektirir
Proxy Ayarı	Sözlük `proxies`	Parametre `proxy`
SOCKS5 Desteği	`requests[socks]` aracılığıyla	`aiohttp-socks` aracılığıyla
Hafıza Kullanımı	Daha az (bir iplik)	Daha fazla (birçok görev)
Daha İyi için	Basit betikler, <100 istek	Veri toplayıcıları, >1000 istek

Ne zaman requests kullanmalı:

Tek seferlik görevler için basit betikler
Prototipleme ve test etme
Küçük miktarda istek (dakikada 100'e kadar)
Kodun basitliği ve okunabilirliği önemli olduğunda
Senkron kütüphanelerle entegrasyon

Ne zaman aiohttp kullanmalı:

Büyük veri setlerini taramak (binlerce sayfa)
Gerçek zamanlı birçok kaynağı izlemek
Yüksek yük altındaki API hizmetleri
İşleme hızının kritik olduğu durumlarda
Proxy üzerinden WebSocket ile çalışma

Performans Karşılaştırması:

# Test: Proxy üzerinden 100 istek

# requests (senkron) - ~50 saniye
import requests
import time

start = time.time()
proxies = {'http': proxy, 'https': proxy}
for i in range(100):
    response = requests.get('https://httpbin.org/ip', proxies=proxies)
print(f"requests: {time.time() - start:.2f} saniye")

# aiohttp (asenkron) - ~5 saniye
import aiohttp
import asyncio

async def fetch_all():
    async with aiohttp.ClientSession() as session:
        tasks = [
            session.get('https://httpbin.org/ip', proxy=proxy)
            for _ in range(100)
        ]
        await asyncio.gather(*tasks)

start = time.time()
asyncio.run(fetch_all())
print(f"aiohttp: {time.time() - start:.2f} saniye")

Veri merkezi proxy'leri kullanarak yüksek hızda tarama yaparken aiohttp, requests'e göre 10-20 kat avantaj sağlar, çünkü istekleri eşzamanlı olarak işler.

Sonuç

Python'da requests ve aiohttp kütüphaneleri aracılığıyla proxy ayarlamak, veri toplayıcıları geliştirmek, veri toplama otomasyonu yapmak ve coğrafi kısıtlamaları aşmak için temel bir beceridir. requests kütüphanesi, anlaşılır senkron API'si sayesinde basit betikler ve prototipleme için uygundur, oysa aiohttp, binlerce isteği asenkron mimari ile işleme konusunda yüksek performans sağlar.

Python'da proxy ile etkili bir şekilde çalışmak için anahtar noktalar: hata ve zaman aşımı işlemesinin doğru yapılması, yük dağılımı için IP adreslerinin döngüsel olarak değiştirilmesi, bağlantıların yeniden kullanılması için Session kullanımı, gerçekçi başlıklar ve User-Agent ayarları, proxy sunucularının performansının izlenmesi. SOCKS5 proxy'ler için ek kütüphaneler gereklidir — requests[socks] veya aiohttp-socks.

Tarama için proxy türünü seçerken görev spesifikasını dikkate alın: yüksek yük altındaki veri toplayıcıları için hızlı veri merkezi proxy'leri uygundur, sert anti-bot sistemlerini aşmak ve sosyal medya ile çalışmak için gerçek ev kullanıcılarının IP'leri ile rezidans proxy'leri önerilir, maksimum anonimlik ve mobil trafik taklidi gerektiren görevler için ise mobil proxy'ler, mobil operatörlerin IP'leri ile en uygunudur.

Yüksek performanslı veri toplayıcıları geliştirmeyi veya birçok kaynaktan veri toplamayı planlıyorsanız, rezidans proxy'lerini denemenizi öneririz — yüksek anonimlik, düşük engellenme riski ve çoğu korumalı web hizmeti ile kararlı çalışma sağlarlar. Yüksek hızda işleme gerektiren teknik görevler için de veri merkezi proxy'leri düşük gecikme ve yüksek bant genişliği ile uygundur.

```

Python requests ve aiohttp'de proxy ayarları: Kod örnekleriyle kapsamlı rehber