Kako uporabljati Python 3.x za prenos URL-jev s spletnih strani, ki podpirajo JavaScript

Premagovanje izzivov pri prenašanju vsebine s strani, odvisnih od JavaScripta

Ko uporabljate Python za avtomatizacijo prenosov s spletnih strani, lahko naletite na situacije, ko spletna stran zahteva, da je za pravilno delovanje omogočen JavaScript. To je lahko frustrirajoče, kot je všeč knjižnicam zahteve niso zasnovani za izvajanje JavaScripta. En tak primer je JFrog Artifactory, ki za prikaz vsebine ali dovoljenje prenosov potrebuje JavaScript.

Pri tradicionalnem spletnem strganju lahko uporabite zahteve oz urllib za pridobivanje vsebine spletne strani. Vendar pri straneh, ki so v veliki meri odvisne od JavaScripta, te knjižnice ne uspejo, saj ne morejo obravnavati dinamičnega upodabljanja vsebine. Zato boste za premagovanje te omejitve potrebovali naprednejša orodja.

Na srečo Python ponuja alternative za obdelavo strani, ki podpirajo JavaScript. Orodja kot Selen oz Pyppeteer omogočite popolno emulacijo brskalnika, kar vam omogoča interakcijo s takšnimi stranmi in prenos vsebine s teh strani. Te knjižnice lahko simulirajo resnično okolje brskalnika, kjer je JavaScript popolnoma podprt.

Ta članek bo raziskal, kako preklopiti z uporabe zahteve zmogljivejšim knjižnicam za dostop in prenos vsebine s spletnih strani, ki podpirajo JavaScript, kar zagotavlja nemoteno izvajanje vaših nalog avtomatizacije.

Uporaba Pythona za prenos s strani, ki podpirajo JavaScript

Pri tradicionalnem spletnem strganju v Pythonu so knjižnice podobne zahteve se pogosto uporabljajo za prenos vsebin neposredno s spletnih strani. Vendar pa pri delu s spletnimi mesti, ki vsebujejo veliko JavaScripta, kot je JFrog Artifactory, te knjižnice ne uspejo. Glavni razlog je, da spletna stran potrebuje JavaScript za dinamično nalaganje vsebine, kar zahteve ne zmore. Da bi to premagali, smo uvedli rešitve, kot je Selen, Pyppeteer, in Zahteve-HTML, ki omogočajo izvajanje JavaScripta. Ta orodja simulirajo okolje brskalnika in skriptom Python omogočajo dostop in prenos vsebine s spletnih strani, odvisnih od JavaScripta.

Prvi pristop z uporabo Seleniuma vključuje zagon primerka brskalnika, ki lahko upodablja JavaScript. Omogoča nam, da počakamo, da se stran v celoti naloži, preden ekstrahiramo izvorno kodo strani. To je še posebej uporabno, ko je vsebina strani dinamično ustvarjena. Na primer z uporabo webdriver.Chrome() ukaz inicializira brskalnik in nato dostopa do ciljnega URL-ja. Z uporabo time.sleep(), zagotovimo dovolj časa za nalaganje JavaScripta. Nazadnje se ekstrahirana vsebina strani shrani v datoteko, ki nam zagotovi zahtevano spletno stran v statični obliki.

Pri drugem pristopu smo uporabili Pyppeteer, Python ovoj za Puppeteer. Pyppeteer je še eno zmogljivo orodje, zasnovano za izvajanje JavaScripta. Tako kot Selenium tudi Pyppeteer zažene brezglavi brskalnik, ki se pomakne na spletno stran, počaka, da se JavaScript izvede, in nato pridobi vsebino. Ključna prednost uporabe Pyppeteerja je, da omogoča večji nadzor nad sejo brskanja, na primer čakanje na nalaganje določenih elementov z ukazi, kot je počakaj stran.waitForSelector(). To zagotavlja, da je zahtevana vsebina strani v celoti upodobljena, preden jo skript poskuša prenesti.

Tretja rešitev izkorišča knjižnico Requests-HTML, ki poenostavlja postopek upodabljanja JavaScripta, ne da bi potrebovali popoln brskalnik, kot sta Selenium ali Pyppeteer. Z Requests-HTML lahko sprožimo sejo HTTP z uporabo session.get() za pridobitev spletne strani, nato izvedite JavaScript z response.html.render() metoda. Ta rešitev je lažja v primerjavi s pristopi simulacije celotnega brskalnika in je pogosto primernejša, ko ne potrebujete dodatnih stroškov celotnega brskalnika. Še posebej je uporaben za enostavnejše operacije JavaScript, zaradi česar je optimalna izbira za posebne primere uporabe.

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")

Izboljšanje spletnega strganja Python za strani, ki podpirajo JavaScript

Pri strganju spletnih strani, ki vsebujejo veliko JavaScripta, je pogost izziv zaobiti omejitve ključa za preverjanje pristnosti ali API-ja, zlasti v aplikacijah, kot je JFrog Artifactory. Medtem ko smo prej raziskovali avtomatizacijo brskalnika z orodji, kot sta Selenium in Pyppeteer, obstajajo druge rešitve, ki se bolj osredotočajo na obdelavo odzivov HTTP. Na primer, integracija API-jev in izkoriščanje glav lahko pomaga obiti pozive za preverjanje pristnosti ali pridobiti bolj specifično vsebino, brez dodatnih stroškov simulacije celotnega brskalnika.

Drugi ključni vidik je, kako te knjižnice obravnavajo kompleksne obrazce, kot so tisti, ki so potrebni za prijavo ali vnos žetona API. Tipična rešitev vključuje posnemanje oddaje obrazcev z uporabo knjižnic Python, kot je npr zahteve. To omogoča brezhibno interakcijo s preverjanjem pristnosti na strani strežnika brez potrebe po izvajanju JavaScripta, kar prihrani vire. Poleg tega lahko za bolj varne strani dodajanje funkcij, kot sta upravljanje sej in preverjanje pristnosti na podlagi žetonov v vaš skript, znatno izboljša zmogljivost.

Pomembno je tudi, da se pogovorite o možnih težavah, kot so izzivi CAPTCHA, ki so lahko ovira pri strganju ali avtomatiziranju opravil. Za obravnavo CAPTCHA se nekateri razvijalci odločijo za storitve tretjih oseb, ki samodejno rešujejo CAPTCHA. Drugi integrirajo algoritme strojnega učenja, čeprav je to lahko bolj zapleteno. Razumevanje teh dodatnih varnostnih ukrepov vam pomaga pripraviti vaše skripte za obvladovanje širšega nabora izzivov, s čimer zagotovite, da vaš skript Python deluje učinkovito pri interakciji s platformami, ki temeljijo na JavaScriptu.