Python中如何使用蜘蛛代理API获取高纯度、高可用的代理服务器列表？

import requests
import time
from typing import List, Dict
import random

class SpiderProxyAPI:
    def __init__(self, api_key: str, api_url: str = "https://api.spiderproxy.com/v1/proxies"):
        """
        初始化蜘蛛代理API客户端
        
        Args:
            api_key: 你的API密钥
            api_url: API端点URL
        """
        self.api_key = api_key
        self.api_url = api_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def get_proxy_list(self, 
                      limit: int = 50,
                      protocol: str = "http",
                      anonymity: str = "high",
                      country: str = None,
                      min_uptime: float = 0.95) -> List[Dict]:
        """
        获取代理服务器列表
        
        Args:
            limit: 返回代理数量
            protocol: 协议类型 (http, https, socks5)
            anonymity: 匿名级别 (high, medium, low)
            country: 国家代码 (如: US, CN, JP)
            min_uptime: 最低在线率 (0-1之间)
            
        Returns:
            代理服务器列表
        """
        params = {
            "limit": limit,
            "protocol": protocol,
            "anonymity": anonymity,
            "min_uptime": min_uptime
        }
        
        if country:
            params["country"] = country
        
        try:
            response = requests.get(
                self.api_url,
                headers=self.headers,
                params=params,
                timeout=10
            )
            response.raise_for_status()
            
            data = response.json()
            
            # 验证代理质量
            validated_proxies = []
            for proxy in data.get("proxies", []):
                if self._validate_proxy(proxy):
                    validated_proxies.append({
                        "ip": proxy["ip"],
                        "port": proxy["port"],
                        "protocol": proxy["protocol"],
                        "country": proxy.get("country", "Unknown"),
                        "uptime": proxy.get("uptime", 0),
                        "response_time": proxy.get("response_time", 9999),
                        "last_checked": proxy.get("last_checked", "")
                    })
            
            return validated_proxies
            
        except requests.exceptions.RequestException as e:
            print(f"API请求失败: {e}")
            return []
    
    def _validate_proxy(self, proxy: Dict) -> bool:
        """验证单个代理的可用性"""
        try:
            test_url = "http://httpbin.org/ip"
            proxy_url = f"{proxy['protocol']}://{proxy['ip']}:{proxy['port']}"
            
            response = requests.get(
                test_url,
                proxies={proxy['protocol']: proxy_url},
                timeout=5
            )
            
            # 检查返回的IP是否与代理IP一致
            if response.status_code == 200:
                return True
                
        except:
            pass
        
        return False
    
    def get_random_proxy(self, **kwargs) -> Dict:
        """随机获取一个可用的代理"""
        proxies = self.get_proxy_list(**kwargs)
        if proxies:
            return random.choice(proxies)
        return {}
    
    def get_proxy_pool(self, size: int = 10, **kwargs) -> List[Dict]:
        """获取代理池"""
        proxies = self.get_proxy_list(limit=size * 2, **kwargs)
        
        # 按响应时间排序，选择最快的
        sorted_proxies = sorted(
            proxies, 
            key=lambda x: x.get("response_time", 9999)
        )[:size]
        
        return sorted_proxies


# 使用示例
def main():
    # 替换为你的API密钥
    API_KEY = "your_api_key_here"
    
    # 创建API客户端
    proxy_api = SpiderProxyAPI(API_KEY)
    
    # 获取高纯度代理列表
    print("获取高可用代理列表...")
    proxies = proxy_api.get_proxy_list(
        limit=20,
        protocol="http",
        anonymity="high",
        min_uptime=0.98,
        country="US"
    )
    
    print(f"获取到 {len(proxies)} 个可用代理:")
    for i, proxy in enumerate(proxies[:5], 1):  # 只显示前5个
        print(f"{i}. {proxy['ip']}:{proxy['port']} "
              f"({proxy['country']}) - 响应时间: {proxy['response_time']}ms")
    
    # 获取随机代理
    print("\n获取随机代理:")
    random_proxy = proxy_api.get_random_proxy(limit=10)
    if random_proxy:
        print(f"随机代理: {random_proxy['ip']}:{random_proxy['port']}")
    
    # 创建代理池
    print("\n创建代理池:")
    proxy_pool = proxy_api.get_proxy_pool(size=5)
    print(f"代理池大小: {len(proxy_pool)}")


if __name__ == "__main__":
    main()

这个实现做了几件事：1）通过API获取代理列表；2）自动验证代理可用性；3）提供随机选择和代理池功能。关键点在于验证环节，确保获取的代理真正可用。记得替换your_api_key_here为实际API密钥。

用这个类就能稳定获取高质量代理了。