Com utilitzar Python 3.x per descarregar un URL de pàgines web habilitades per JavaScript

Superació dels reptes en la baixada de contingut de pàgines dependents de JavaScript

Quan utilitzeu Python per automatitzar les descàrregues de pàgines web, és possible que us trobeu amb situacions en què una pàgina web requereix que JavaScript estigui activat perquè funcioni correctament. Això pot ser frustrant, com els agrada a les biblioteques peticions no estan dissenyats per gestionar l'execució de JavaScript. Un d'aquests exemples és JFrog Artifactory, que requereix JavaScript per mostrar contingut o permetre les baixades.

En el raspat web tradicional, podeu utilitzar peticions o urllib per obtenir el contingut de la pàgina web. Tanmateix, per a les pàgines que depenen molt de JavaScript, aquestes biblioteques es queden curtes ja que no poden gestionar la representació de contingut dinàmic. Per tant, necessitareu eines més avançades per superar aquesta limitació.

Afortunadament, Python ofereix alternatives per gestionar pàgines habilitades per JavaScript. Eines com Seleni o Pipeter habiliteu l'emulació completa del navegador, la qual cosa us permet interactuar i descarregar contingut d'aquestes pàgines. Aquestes biblioteques poden simular un entorn de navegador real on JavaScript és totalment compatible.

En aquest article s'explorarà com canviar d'ús peticions a biblioteques més capaces per accedir i descarregar contingut de pàgines web habilitades per JavaScript, assegurant que les vostres tasques d'automatització funcionin sense problemes.

Ús de Python per descarregar des de pàgines habilitades per JavaScript

En el raspat web tradicional de Python, a les biblioteques els agrada peticions s'utilitzen sovint per descarregar contingut directament de pàgines web. Tanmateix, quan es tracta de llocs pesats en JavaScript, com ara JFrog Artifactory, aquestes biblioteques es queden curtes. El motiu principal és que la pàgina web requereix JavaScript per carregar contingut dinàmicament, cosa que peticions no pot manejar. Per superar-ho, hem introduït solucions com Seleni, Pipeter, i Sol·licituds-HTML, que permeten l'execució de JavaScript. Aquestes eines simulen un entorn de navegador, la qual cosa permet als scripts de Python accedir i baixar contingut de pàgines web dependents de JavaScript.

El primer enfocament que utilitza Selenium consisteix en llançar una instància del navegador que pugui renderitzar JavaScript. Ens permet esperar que la pàgina es carregui completament abans d'extreure el codi font de la pàgina. Això és especialment útil quan el contingut de la pàgina es genera dinàmicament. Per exemple, utilitzant el webdriver.Chrome() L'ordre inicialitza un navegador i després accedeix a l'URL de destinació. Mitjançant l'ús temps.dormir(), ens assegurem que hi ha prou temps perquè el JavaScript es carregui. Finalment, el contingut de la pàgina extret es desa en un fitxer, proporcionant-nos la pàgina web necessària en forma estàtica.

En el segon enfocament, hem emprat Pyppeteer, un embolcall de Python per a Titellaire. Pyppeteer és una altra eina potent dissenyada per gestionar l'execució de JavaScript. Igual que Selenium, Pyppeteer llança un navegador sense cap que navega a la pàgina web, espera que s'executi JavaScript i després recupera el contingut. Un avantatge clau d'utilitzar Pyppeteer és que proporciona més control sobre la sessió de navegació, com ara esperar que es carreguin elements específics mitjançant ordres com ara wait page.waitForSelector(). Això assegura que el contingut de la pàgina requerit es renderitza completament abans que l'script intenti descarregar-lo.

La tercera solució aprofita la biblioteca Requests-HTML, que simplifica el procés de renderització de JavaScript sense necessitat d'un navegador complet com Selenium o Pyppeteer. Amb Requests-HTML, podem iniciar una sessió HTTP utilitzant session.get() per obtenir la pàgina web i, a continuació, executeu el JavaScript amb el response.html.render() mètode. Aquesta solució és més lleugera en comparació amb els enfocaments de simulació del navegador complet i sovint és més adequada quan no necessiteu la sobrecàrrega d'un navegador complet. És especialment útil per a operacions JavaScript més senzilles, la qual cosa la converteix en una opció òptima per a casos d'ús específics.

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
import time
def download_using_selenium(url, username, apikey):
    # Setup Selenium WebDriver
    options = webdriver.ChromeOptions()
    options.add_argument('--headless')
    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
    driver.get(url)
    time.sleep(3)  # Wait for JavaScript to load
    
    # Assuming basic authentication via URL for this example
    auth_url = f'{url}?username={username}&password={apikey}'
    driver.get(auth_url)
    
    # Extract content
    page_content = driver.page_source
    
    # Save to file
    with open("download_selenium.html", "w") as file:
        file.write(page_content)
    
    driver.quit()
    print("Download complete using Selenium.")

import asyncio
from pyppeteer import launch
async def download_using_pyppeteer(url, username, apikey):
    # Launch headless browser
    browser = await launch(headless=True)
    page = await browser.newPage()
    
    # Basic auth and URL loading
    auth_url = f'{url}?username={username}&password={apikey}'
    await page.goto(auth_url)
    
    # Wait for the JavaScript to load
    await page.waitForSelector('body')
    
    # Extract page content
    content = await page.content()
    
    # Save to file
    with open("download_pyppeteer.html", "w") as file:
        file.write(content)
    
    await browser.close()
    print("Download complete using Pyppeteer.")
# Run the async function
asyncio.get_event_loop().run_until_complete(download_using_pyppeteer("https://example.com", "user", "key"))

from requests_html import HTMLSession
def download_using_requests_html(url, username, apikey):
    session = HTMLSession()
    
    # Make the request
    auth_url = f'{url}?username={username}&password={apikey}'
    response = session.get(auth_url)
    
    # Render the JavaScript
    response.html.render()
    
    # Save the page content
    with open("download_requests_html.html", "w") as file:
        file.write(response.html.html)
    
    print("Download complete using Requests-HTML.")
download_using_requests_html("https://example.com", "user", "key")

Millora de Python Web Scraping per a pàgines habilitades per JavaScript

Quan s'esborra pàgines web pesades en JavaScript, un repte comú és eludir les restriccions d'autenticació o de clau de l'API, especialment en aplicacions com JFrog Artifactory. Tot i que abans vam explorar l'automatització del navegador amb eines com Selenium i Pyppeteer, hi ha altres solucions que se centren més en la gestió de les respostes HTTP. Per exemple, la integració d'API i l'aprofitament de les capçaleres pot ajudar a evitar les sol·licituds d'autenticació o recuperar contingut més específic, sense la sobrecàrrega d'una simulació completa del navegador.

Un altre aspecte clau és com aquestes biblioteques gestionen formularis complexos, com els necessaris per a l'inici de sessió o l'entrada de testimoni de l'API. Una solució típica consisteix a imitar els enviaments de formularis mitjançant biblioteques Python com ara peticions. Això permet una interacció perfecta amb l'autenticació del costat del servidor sense requerir l'execució de JavaScript, estalviant recursos. A més, per a pàgines més segures, afegir funcions com la gestió de sessions i l'autenticació basada en testimonis al vostre script pot millorar significativament el rendiment.

També és important parlar de possibles qüestions com els reptes CAPTCHA, que poden ser un obstacle a l'hora de raspar o automatitzar tasques. Per fer front als CAPTCHA, alguns desenvolupadors opten per serveis de tercers que resolen CAPTCHA automàticament. Altres integren algorismes d'aprenentatge automàtic, tot i que això pot ser més complex. Entendre aquestes mesures de seguretat addicionals us ajuda a preparar els vostres scripts per fer front a una gamma més àmplia de reptes, assegurant-vos que el vostre script Python s'executa de manera eficient quan interactueu amb plataformes basades en JavaScript.