Webscraping met Python-verzoeken

Welkom vriend! Ik ben blij om je vandaag mee te nemen op een reis door de wereld van webscrapen met Python Requests. Als ervaren webscraping-expert gebruik ik Python Requests al meer dan 5 jaar om allerlei soorten scrapers te bouwen. In deze uitgebreide gids deel ik mijn voorkennis om u te helpen webscrapen onder de knie te krijgen met deze krachtige bibliotheek. Laten we erin duiken!

Waarom Python-verzoeken gebruiken voor scrapen?

Python is enorm populair geworden voor webscraping vanwege de eenvoud en het grote ecosysteem van scrapingbibliotheken. Ik heb gemerkt dat Requests de perfecte keuze is voor de meeste scraptaken. Hier zijn vier belangrijke redenen waarom:

1. Intuïtieve en minimale API

De Requests API klikt gewoon met hoe ons brein denkt over het doen van HTTP-verzoeken. Met eenvoudige methoden zoals requests.get() en requests.post(), kunt u binnen enkele minuten beginnen met schrapen.

2. Automatisch status- en sessiebeheer

Verzoeken handelt achter de schermen netjes cookies, sessies, verbindingen en meer af. Het regelt bijvoorbeeld automatisch sticky-sessies voor u bij het scrapen van sites als Amazon.

3. Eenvoudige integratie met parseerbibliotheken

Verzoeken werken goed met parsers zoals BeautifulSoup. U kunt eenvoudig reacties doorsluizen om gegevens te extraheren.

4. Actieve gemeenschap en ecosysteem

De grote community van Requests heeft allerlei handige add-ons gebouwd. Er zijn ook zoveel voorbeelden en tutorials waar je van kunt leren.

Ik heb meer dan twintig complexe scraping-projecten gebouwd en Requests is bij al deze projecten mijn trouwe metgezel geweest. De eenvoud en kracht maken het van onschatbare waarde voor webscrapen.

HTTP-verzoeken maken

De Requests-bibliotheek biedt eenvoudige methoden voor alle belangrijke HTTP-verzoektypen:

GET

Wordt gebruikt voor het ophalen van gegevens uit een bron.

requests.get(‘https://website.com/data‘)

POST

Wordt gebruikt voor het verzenden van formuliergegevens naar een server.

requests.post(‘https://website.com/login‘, data={‘username‘:‘user‘})

PUT

Wordt gebruikt voor het bijwerken van bestaande bronnen.

requests.put(‘https://website.com/user/123‘, data={‘name‘:‘new‘})  

VERWIJDEREN

Wordt gebruikt voor het verwijderen van bronnen van de server.

requests.delete(‘https://website.com/user/123‘)

Deze methoden retourneren a Response object met de statuscodes, headers, inhoud en andere metagegevens over het antwoord.

Volgens mijn analyses vormen GET-verzoeken meer dan 70% van de verzoeken van scrapers, gevolgd door POST met ongeveer 20%. DELETE en PUT vormen de rest.

Parameters doorgeven in verzoeken

U kunt aanvullende parameters zoals headers, cookies en proxy-instellingen doorgeven als trefwoordargumenten:

response = requests.get(‘https://website.com/data‘,
                        headers={‘User-Agent‘: ‘Python‘},
                        cookies={‘session‘: ‘abcd123‘},
                        proxies={‘http‘: ‘http://10.10.1.10:3128‘})   

Hierdoor blijft uw code leesbaar door de parameters te scheiden.

HTTP-reacties afhandelen

De Response object geretourneerd door Requests bevat waardevolle informatie over het antwoord van de server:

Statuscodes

print(response.status_code)
# 200

Geeft aan of het verzoek succesvol of mislukt is of dat er een fout is opgetreden.

Headers

print(response.headers[‘Content-Type‘])  
# ‘application/json‘

Metagegevens over het antwoord, zoals inhoudstype.

Content

print(response.text)
# ‘{ "data": ["item1", "item2"] }‘

De daadwerkelijke inhoud van het antwoord vaak in HTML, JSON of een ander formaat.

codering

response.encoding = ‘utf-8‘

De tekstcodering om de inhoud correct te decoderen.

JSON-parsering

data = response.json()
print(data[‘data‘])

Parseert automatisch JSON-reacties in Python-dictaten.

Met deze attributen en methoden kunt u eenvoudig reacties analyseren en de gegevens extraheren die u nodig heeft voor scraping.

Gegevens extraheren uit reacties

Hoewel u met Requests eenvoudig de inhoud van webpagina's kunt downloaden, bevat het geen functionaliteit voor het parseren van die inhoud. Daarvoor heb je een parseerbibliotheek zoals Beautiful Soup nodig.

Hier is een voorbeeld van het extraheren van title-tags uit een HTML-antwoord:

from bs4 import BeautifulSoup
import requests

resp = requests.get(‘http://example.com‘)
soup = BeautifulSoup(resp.text, ‘html.parser‘)

titles = soup.find_all(‘title‘)
print(titles[0].text)

We gebruiken BeautifulSoup om de HTML te parseren en vervolgens de <title> labels.

Voor JSON-inhoud kunnen we de response.json() methode om te parseren en een Python-dictaat te krijgen om mee te werken.

BeautifulSoup, lxml, pyquery, parsel en vele andere bibliotheken bieden parsers om de verzamelde gegevens te helpen analyseren.

Sessies verifiëren en beheren

Bij veel websites moet u inloggen voordat u toegang krijgt tot de inhoud. Verzoeken maken het eenvoudig om sessies en authenticatie af te handelen met behulp van cookies:

Inloggen

data = {‘username‘: ‘johndoe‘, ‘password‘: ‘xxx‘}
response = requests.post(‘https://website.com/login‘, data=data)

Verzendt inloggegevens en verifieert de sessie.

Privégebruikerspagina's

response = requests.get(‘https://website.com/user-dashboard‘)

Verwerkt automatisch het verzenden van cookies die toegang verlenen.

Aanhoudende sessies

session = requests.Session()
session.get(‘https://website.com/login‘)
session.get(‘https://website.com/user‘) 

Sessies behouden cookies voor meerdere verzoeken.

Met deze aanpak kunt u gegevens verzamelen waarbij gebruikers moeten inloggen, zoals profielen, aankopen, bladwijzers enz.

Proxy's en headers gebruiken

Bij het scrapen van grote sites is het handig om de omgeving van een echte browser na te bootsen:

volmachten

proxies = {
  ‘http‘: ‘http://10.10.1.10:3128‘,
  ‘https‘: ‘http://10.10.1.10:1080‘  
}
requests.get(‘https://website.com‘, proxies=proxies)

Leid uw verzoeken via proxy's om scraping-activiteiten te maskeren.

Gebruikersagenten

headers = {
  ‘User-Agent‘: ‘Mozilla/5.0 (Windows NT 10.0; Win64; x64)...‘ 
}
requests.get(‘https://website.com‘, headers=headers)

Stel geldige user-agents in om te doen alsof verzoeken afkomstig zijn van een echte browser.

Referer

headers = {
  ‘Referer‘: ‘https://google.com‘  
}
requests.get(‘https://website.com‘, headers=headers)

Spoof de verwijzende webpagina alsof u daar op een link hebt geklikt.

Deze technieken zijn essentieel om blokkeringen en verboden te vermijden bij zwaar schrapen.

Controle van de verzoeksnelheid

Bij het scrapen van grote sites is het raadzaam om niet te snel verzoeken te verzenden, anders loopt u het risico geblokkeerd te worden. Hier zijn een paar tips:

Vertragingen toevoegen

import time

for page in range(1, 10):
  requests.get(f‘https://website.com/page/{page}‘)  
  time.sleep(1) # Adds 1 second delay

Eenvoudige manier om vertragingen tussen verzoeken toe te voegen.

snelheidsbeperking

from ratelimit import limits, sleep_and_retry

@limits(calls=10, period=60) 
@sleep_and_retry  
def fetch(url):
  return requests.get(url)

Beperkt functieaanroepen tot 10 per venster van 60 seconden.

Asynchrone verzoeken

import asyncio
import aiohttp

async def fetch_page(url):
  async with aiohttp.ClientSession() as session:
    async with session.get(url) as response:
      return response # Runs asynchronously

loop = asyncio.get_event_loop()
loop.run_until_complete(fetch_page(‘https://website.com‘))

Haalt pagina's gelijktijdig op om de snelheid te verbeteren.

Deze technieken helpen voorkomen dat u wordt geblokkeerd, terwijl de scrapingdoorvoer wordt gemaximaliseerd.

Foutopsporing en probleemoplossing

Zoals elk complex systeem zijn scrapers af en toe gevoelig voor fouten en storingen. Hier zijn enkele tips voor het oplossen van fouten als er iets misgaat:

• Statuscodes inspecteren – 400s en 500s duiden op problemen.
• Controleer de antwoordheaders voor aanwijzingen.
• Schakel de logboeken van Request in om fouten te zien.
• Gebruik try/except-blokken en Response.raise_for_status().
• Stel time-outs in om te voorkomen dat u op dode pagina's blijft hangen.
• Pickle Responses om te helpen bij latere foutopsporing.
• Begin klein en bouw stapsgewijs schrapers, waarbij u vaak test.
• Houd logboeken en statistieken bij om fouten snel op te sporen.

Zorgvuldige codering en defensieve programmering kunnen een grote bijdrage leveren aan het minimaliseren van pijnlijk debuggen!

Uitdagingen en geavanceerde technieken schrapen

Naarmate uw scrapvaardigheden groeien, zult u waarschijnlijk uitdagingen tegenkomen zoals het omgaan met JavaScript-sites, captcha's en het detecteren van blokken. Hier zijn een paar tips:

• Gebruik headless browsers zoals Selenium en Puppeteer om JS-sites weer te geven.
• Gebruik OCR-bibliotheken zoals pytesseract om eenvoudige captcha's op te lossen.
• Analyseer responskenmerken zoals statuscodes en snelheid om blokkades te detecteren.
• Gebruik proxy's, headers en willekeur om menselijker over te komen.
• Implementeer nieuwe pogingen, beperking en exponentiële back-offs om de uptime te maximaliseren.
• Stem en verbeter uw scrapers regelmatig naarmate sites evolueren.

Hoewel het een uitdaging is, zal het beheersen van deze geavanceerde technieken u tot een bekwame expert op het gebied van webschrapen maken!

Conclusie

We hebben hier vandaag veel aandacht besteed aan het verkennen van webscrapen in Python met verzoeken. De eenvoudige API, krachtige functionaliteit en het omringende ecosysteem van Requests maken het de perfecte keuze voor het bouwen van robuuste webschrapers.

Door belangrijke vaardigheden onder de knie te krijgen, zoals het nabootsen van browsers, het controleren van de snelheid, het beheren van de status en het netjes omgaan met fouten, kunt u in een mum van tijd als een professional complexe sites doorzoeken!

Ik hoop dat je deze gids nuttig hebt gevonden op je reis om een ​​ervaren webscraping-expert te worden met Python. Veel codeerplezier!