Comment gratter un site web qui nécessite une connexion en premier avec Python

aimerais ajouter ma solution côtés . cette réponse suit principalement le hacky / paresseux approche je suis toujours dans tout ce que je fais. sont allés sur principalement parce que j'étais trop paresseux pour gérer les cookies, les données de session etc .

cette solution est la plus utile si vous souhaitez gratter plusieurs pages d'un site web après vous être connecté avec des justificatifs d'accès à compte unique (par exemple toutes vos cartes pinterest) . pas si u veut automatiser l'authentification en utilisant plusieurs comptes

donc ma solution est le sélénium avec les profils firefox.

• Créer un nouveau profil firefox vous créez un nouveau profil firefox, notez l'endroit où il est stocké, ouvrez firefox dans le profil correspondant. et connectez-vous au site web manuellement . détails sur profils firefox
• maintenant utiliser le sélénium avec ce profil selenium session utilisera les cookies et les données de session du profil firefox afin que votre l'authentification reste.

j'ai conçu ce mécanisme quand je suis tombé sur le besoin de gratter quelques pages pinterest, j'ai ajouté quelques lignes de code de l'échantillon montrant comment utiliser le profil. adapter le code en fonction de vos besoins.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import Select
from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoAlertPresentException


#replace with your firefox profile
fp=webdriver.FirefoxProfile('C:/Users/SJ/AppData/Roaming/Mozilla/Firefox/Profiles/hlsfrs2o.scrape')
#enter your url here
url=""
driver = webdriver.Firefox(fp)
driver.get(url)

html_source = driver.page_source

la méthode La plus classique à l'approche de ce problème est:

1. lancez un navigateur, allez sur le site et recherchez la page de connexion
2. inspectez le code source de la page pour savoir: I. qui est le formulaire de connexion (une page peut avoir de nombreuses formes, mais généralement l'un d'eux est le formulaire de connexion) II. quels sont les noms de champ utilisés pour le nom d'utilisateur et le mot de passe (ceux-ci peuvent varier beaucoup) III. s'il y a d'autres champs qui doit être soumis (comme un jeton d'authentification)
3. Ecrire L'Araignée raclée pour répliquer la soumission du formulaire à L'aide de FormRequest

étant fans d'automatisation, nous avons pensé que nous pourrions écrire un code pour automatiser le point 2 (ce qui est en fait le plus long) et le résultat est le formulaire de connexion, une bibliothèque pour remplir automatiquement les formulaires de connexion étant donné la page de connexion, le nom d'utilisateur et le mot de passe. Voici le code d'une araignée simple qui utiliserait loginform pour se connecter aux sites automatiquement.

githubloginspider.py

from scrapy.spider import BaseSpider
from scrapy.http import FormRequest
from scrapy.http.request import Request
from loginform import fill_login_form
from scrapy import log
from scraping.articles import ArticleItem


class GitHubLogin(BaseSpider):

    name = 'GitHubLogin'
    allowed_domains = ['github.com']
    start_urls = ['http://github.com/login']
    login_user = 'ranvijay5686'
    login_pass = ''

    def parse(self, response):
        (args, url, method) = fill_login_form(response.url,
                response.body, self.login_user, self.login_pass)
        return FormRequest(url, method=method, formdata=args,
                           callback=self.after_login)

    def after_login(self, response):

        # for link in response.xpath("//*[@id='site-container']/div[2]/div[4]/p/a/@href").extract():

        item = ArticleItem()
        item['title'] = 'ranvijay'
        log.msg('***************    :   '
                + str(response.xpath("//form[@class='subnav-search left']/input/@value"
                ).extract()))
        item['url'] = \
            response.xpath("//*[@id='site-container']/div[1]/div/div/span/span/text()"
                           ).extract()
        yield item

items.py

from scrapy.item import Item, Field

class ArticleItem(Item):
    title = Field()
    url = Field()

loginform.py

import sys
from argparse import ArgumentParser
from collections import defaultdict
from lxml import html

__version__ = '1.0'  # also update setup.py


def _form_score(form):
    score = 0

    # In case of user/pass or user/pass/remember-me

    if len(form.inputs.keys()) in (2, 3):
        score += 10

    typecount = defaultdict(int)
    for x in form.inputs:
        type_ = (x.type if isinstance(x, html.InputElement) else 'other'
                 )
        typecount[type_] += 1

    if typecount['text'] > 1:
        score += 10
    if not typecount['text']:
        score -= 10

    if typecount['password'] == 1:
        score += 10
    if not typecount['password']:
        score -= 10

    if typecount['checkbox'] > 1:
        score -= 10
    if typecount['radio']:
        score -= 10

    return score


def _pick_form(forms):
    """Return the form most likely to be a login form"""

    return sorted(forms, key=_form_score, reverse=True)[0]


def _pick_fields(form):
    """Return the most likely field names for username and password"""

    userfield = passfield = emailfield = None
    for x in form.inputs:
        if not isinstance(x, html.InputElement):
            continue

        type_ = x.type
        if type_ == 'password' and passfield is None:
            passfield = x.name
        elif type_ == 'text' and userfield is None:
            userfield = x.name
        elif type_ == 'email' and emailfield is None:
            emailfield = x.name

    return (userfield or emailfield, passfield)


def submit_value(form):
    """Returns the value for the submit input, if any"""

    for x in form.inputs:
        if x.type == 'submit' and x.name:
            return [(x.name, x.value)]
    else:
        return []


def fill_login_form(
    url,
    body,
    username,
    password,
    ):
    doc = html.document_fromstring(body, base_url=url)
    form = _pick_form(doc.xpath('//form'))
    (userfield, passfield) = _pick_fields(form)
    form.fields[userfield] = username
    form.fields[passfield] = password
    form_values = form.form_values() + submit_value(form)
    return (form_values, form.action or form.base_url, form.method)


def main():
    ap = ArgumentParser()
    ap.add_argument('-u', '--username', default='username')
    ap.add_argument('-p', '--password', default='secret')
    ap.add_argument('url')
    args = ap.parse_args()

    try:
        import requests
    except ImportError:
        print 'requests library is required to use loginform as a tool'

    r = requests.get(args.url)
    (values, action, method) = fill_login_form(args.url, r.text,
            args.username, args.password)
    print '''url: {0}
method: {1}
payload:'''.format(action, method)
    for (k, v) in values:
        print '- {0}: {1}'.format(k, v)


if __name__ == '__main__':
    sys.exit(main())