La puissance de Scrapy : Comment reconnaître et traiter les codes de vérification ?

Scrapy est un framework Python puissant qui nous aide à explorer facilement les données sur les sites Web. Cependant, nous rencontrons des problèmes lorsque le site Web que nous souhaitons explorer possède un code de vérification. Le but des CAPTCHA est d’empêcher les robots d’exploration automatisés d’attaquer un site Web. Ils ont donc tendance à être très complexes et difficiles à déchiffrer. Dans cet article, nous expliquerons comment utiliser le framework Scrapy pour identifier et traiter les CAPTCHA afin de permettre à nos robots d'exploration de contourner ces défenses.

Qu'est-ce qu'un code de vérification ?

Un CAPTCHA est un test utilisé pour prouver que l'utilisateur est un véritable être humain et non une machine. Il s'agit généralement d'une chaîne de texte obscurcie ou d'une image illisible qui oblige l'utilisateur à saisir ou à sélectionner manuellement ce qui est affiché. Les CAPTCHA sont conçus pour détecter les robots et les scripts automatisés afin de protéger les sites Web contre les attaques malveillantes et les abus.

Il existe généralement trois types de CAPTCHA :

1. CAPTCHA textuel : les utilisateurs doivent copier et coller une chaîne de texte pour prouver qu'ils sont un utilisateur humain et non un robot.
2. Code de vérification du numéro : l'utilisateur doit saisir le numéro affiché dans la zone de saisie.
3. Code de vérification de l'image : l'utilisateur est invité à saisir les caractères ou les chiffres d'une image affichée dans la zone de saisie. Il s'agit généralement du type le plus difficile à déchiffrer car les caractères ou les chiffres de l'image peuvent être déformés, égarés ou avoir un autre visuel. bruit. .

Pourquoi devez-vous traiter les codes de vérification ?

Les robots d'exploration sont souvent automatisés à grande échelle, ils peuvent donc facilement être identifiés comme des robots et interdits aux sites Web d'obtenir des données. Des CAPTCHA ont été introduits pour éviter que cela ne se produise. Une fois qu'ep entre dans l'étape du code de vérification, le robot d'exploration Scrapy cessera d'attendre la saisie de l'utilisateur et ne pourra donc pas continuer à analyser les données, ce qui entraînera une diminution de l'efficacité et de l'intégrité du robot d'exploration.

Nous avons donc besoin d'un moyen de gérer le captcha afin que notre robot puisse le transmettre automatiquement et continuer sa tâche. Nous utilisons généralement des outils ou des API tiers pour compléter la reconnaissance des codes de vérification. Ces outils et API utilisent des algorithmes d'apprentissage automatique et de traitement d'images pour reconnaître les images et les caractères et renvoyer les résultats à notre programme.

Comment gérer les codes de vérification dans Scrapy ?

Ouvrez le fichier settings.py de Scrapy, nous devons modifier le champ DOWNLOADER_MIDDLEWARES et ajouter le proxy suivant :

DOWNLOADER_MIDDLEWARES = {'scrapy.downloadermiddlewares.downloadtimeout.DownloadTimeoutMiddleware' : 350,
'scrapy.contrib.downloadermiddleware.retry .Retry Intergiciel ': 350,'scrapy.contrib.downloadermiddleware.redirect.RedirectMiddleware': 400,
'scrapy.contrib.downloadermiddleware.cookies.CookiesMiddleware': 700,'scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware': 750,
'scrapy .contrib.downloadermiddleware.useragent.UserAgentMiddleware': 400,'scrapy.contrib.downloadermiddleware.defaultheaders.DefaultHeadersMiddleware': 550,
'scrapy.contrib.downloadermiddleware.ajaxcrawl.AjaxCrawlMiddleware': 900,'scrapy.contrib.download ermi logiciel de compression http. .HttpCompressionMiddleware' : 800,
'scrapy.contrib.downloadermiddleware.chunked.ChunkedTransferMiddleware' : 830,'scrapy.contrib.downloadermiddleware.stats.DownloaderStats' : 850,
'tutorial.middlewares.CaptchaMiddleware' : 999}

Dans Dans Dans cet exemple, nous utilisons CaptchaMiddleware pour gérer le code de vérification. CaptchMiddleware est une classe middleware personnalisée qui gérera la demande de téléchargement et appellera l'API pour identifier le code de vérification si nécessaire, puis remplira le code de vérification dans la demande et reviendra pour poursuivre l'exécution.

Exemple de code :

class CaptchaMiddleware(object) :

def __init__(self):
    self.client = CaptchaClient()
    self.max_attempts = 5

def process_request(self, request, spider):
    # 如果没有设置dont_filter则默认开启
    if not request.meta.get('dont_filter', False):
        request.meta['dont_filter'] = True

    if 'captcha' in request.meta:
        # 带有验证码信息
        captcha = request.meta['captcha']
        request.meta.pop('captcha')
    else:
        # 没有验证码则获取
        captcha = self.get_captcha(request.url, logger=spider.logger)

    if captcha:
        # 如果有验证码则添加到请求头
        request = request.replace(
            headers={
                'Captcha-Code': captcha,
                'Captcha-Type': 'math',
            }
        )
        spider.logger.debug(f'has captcha: {captcha}')

    return request

def process_response(self, request, response, spider):
    # 如果没有验证码或者验证码失败则不重试
    need_retry = 'Captcha-Code' in request.headers.keys()
    if not need_retry:
        return response

    # 如果已经尝试过，则不再重试
    retry_times = request.meta.get('retry_times', 0)
    if retry_times >= self.max_attempts:
        return response

    # 验证码校验失败则重试
    result = self.client.check(request.url, request.headers['Captcha-Code'])
    if not result:
        spider.logger.warning(f'Captcha check fail: {request.url}')
        return request.replace(
            meta={
                'captcha': self.get_captcha(request.url, logger=spider.logger),
                'retry_times': retry_times + 1,
            },
            dont_filter=True,
        )

    # 验证码校验成功则继续执行
    spider.logger.debug(f'Captcha check success: {request.url}')
    return response

def get_captcha(self, url, logger=None):
    captcha = self.client.solve(url)
    if captcha:
        if logger:
            logger.debug(f'get captcha [0:4]: {captcha[0:4]}')
        return captcha

    return None

Dans ce middleware, nous avons utilisé l'objet CaptchaClient comme middleware de solution captcha, nous pouvons utiliser plusieurs middleware de solution captcha.

Remarques

Lors de la mise en œuvre de ce middleware, veuillez prêter attention aux points suivants :

1. L'identification et le traitement des codes de vérification nécessitent l'utilisation d'outils ou d'API tiers, et nous devons nous assurer que nous disposons d'une licence légale. et suivez les exigences du fabricant. Utilisez-les.
2. Après l'ajout d'un tel middleware, le processus de demande deviendra plus complexe et les développeurs devront tester et déboguer soigneusement pour s'assurer que le programme peut fonctionner correctement.

Conclusion

En utilisant le framework Scrapy et le middleware pour la reconnaissance et le traitement du code de vérification, nous pouvons contourner efficacement la stratégie de défense du code de vérification et réaliser une exploration efficace du site Web cible. Cette méthode permet généralement d'économiser du temps et des efforts par rapport à la saisie manuelle des codes de vérification et est plus efficace et plus précise. Cependant, il est important de noter que vous lisez et respectez les accords de licence et les exigences des outils et API tiers avant de les utiliser.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!