Hvordan laver man webscraping på Python med BeautifulSoup?

Har du lyst til at dykke ned i en verden af web scraping men uden at blive fanget i komplicerede koder?

Med Python og biblioteket SmukSuppe, kan du nemt udtrække og organisere data en hjemmeside på blot få linjer.

Forudsætninger for scraping på Python med BeautifulSoup

✅ Før du går i gang, er det vigtigt at have nogle Grundlæggende programmering. Det vil give dig en bedre forståelse af, hvordan koden fungerer. Du behøver ikke være ekspert, men det vil være en stor fordel at kunne læse og udføre et Python-script.

Her er, hvad du skal gøre først at lave scraping på Python med BeautifulSoup :

pip installer beautifulsoup4

pip installer anmodninger

Hvordan laver man webscraping med Python og BeautifulSoup?

Følg vores vejledning til et simpelt webscraping-projekt.

Projekt : hente titlen på en side og alle links, den indeholder.

Trin 1: Hent sideindhold med forespørgsler

At udføre en HTTP GET-anmodning til en URL, skal du bruge Forespørgsler.

📌 Når du sender en HTTP-anmodning med Requests, returnerer serveren altid en statuskode. Disse koder angiver, om anmodningen var vellykket eller ej.

200 succes.
301 / 302 omdirigering.
404 Siden blev ikke fundet.
500 intern serverfejl.

importanmodninger

# Mål-URL
url = "https://bonjour.com"

# Send en GET-anmodning
svar = requests.get(url)

# Tjek statuskode
hvis response.status_code == 200:
    print("Succes: siden er blevet hentet!")
    html = response.text # HTML-indhold på siden
    print("Uddrag af HTML-indhold:")
    print(html[:500]) # viser kun de første 500 tegn
else:
    print(f "Fejl: statuskode {response.status_code}")
  

Trin 2: Analyser HTML-koden med BeautifulSoup

fra bs4 import BeautifulSoup
import anmodninger

url = "https://bonjour.com"
svar = requests.get(url)
html = svar.tekst

# Det anbefales at angive parseren
soup = BeautifulSoup(html, "html.parser")

Trin 3: Find og udtræk elementer

# Hent titel <h1>
h1 = soup.find("h1")
print(h1.get_text())

# Hent alle links <a>
liens = soup.find_all("a")
for lien i liens:
    print(lien.get_text(), lien.get("href"))

# Hentning af en div med et bestemt id
container = soup.find("div", id="main")

# Hent alle links med en bestemt klasse
nav_links = soup.find_all("a", class_="nav-link")

# Alle links i artikeltitler
article_links = soup.select("article h2 a")

# Alle <a> hvis href-attribut begynder med "http".
links_http = soup.select('a[href^="http"]')

Det CSS-selektorer er meget effektive, hvis du vil målrette mod bestemte dele af en side uden at skulle gennemgå hele HTML-koden manuelt.

Hvordan udtrækker man data fra en HTML-tabel med BeautifulSoup?

Indtil nu har vi set, hvordan man henter titler, links eller tekst fra en webside.

⚠ Men ofte er de reelle anvendelsestilfælde mere komplekse: Udtræk af strukturerede data som tabeller eller lister, håndtering af paginering eller løsning af hyppige fejl i forbindelse med scraping. Det er netop det, vi skal se nærmere på sammen.

Udtræk af tabeller og lister

Hjemmesider præsenterer ofte deres data i HTML-tabeller (<table>, <tr>, <th>, <td>) eller lister (

/
,
1. ). For at omdanne disse strukturer til brugbare data skal du lære at gå igennem dem linje for linje eller element for element.

   Når som helst du vil udtræk en HTML-tabelPrincippet er enkelt:

   • ✅ Gendan overskrifter (<th>) for at identificere kolonneoverskrifter.
   • ✅ Gennemse hver linje (<tr>) og søge efter celler (<td>), som indeholder de rigtige data.
   • ✅ Gem oplysninger på en liste eller i en ordbog.

   For en HTML-liste (

   eller
   med
   1. ) :
      • ✅ Find alle tags
      • . med find_all.
      • ✅ Hent deres indhold (tekst eller link), og tilføj det til en Python-liste.

      Sammenfattende:

      Mærkerne <table>, <tr>, <th>, <td> bruges til at rekonstruere en tabel.
      Mærkerne

      ./
      .,
      1. . bruges til at omdanne en HTML-liste til en Python-liste.

         Her er et eksempel med en tabel:

         html = """
         <table>
           <tr>
             <th>Efternavn</th>
             <th>Alder</th>
             <th>By</th>
           </tr>
           <tr>
             <td>Alice</td>
             <td>25</td>
             <td>Paris</td>
           </tr>
           <tr>
             <td>Bob</td>
             <td>30</td>
             <td>Lyon</td>
           </tr>
         </table>
         """
         
         # Opret BeautifulSoup-objektet
         soup = BeautifulSoup(html, "html.parser")
         
         # Træk overskrifterne ud af arrayet
         headers = [th.get_text(strip=True) for th in soup.find_all("th")]
         print("Headers:", headers)
         
         # Udtræk rækkerne med data (spring den første række over, da det er overskrifterne)
         rækker = []
         for tr in soup.find_all("tr")[1:]:
             cells = [td.get_text(strip=True) for td in tr.find_all("td")]
             if celler:
                 rækker.tilføj(celler)
         
         print("Linjer :", rækker)
         

         Her, find_all("th") henter overskrifter og find_all("td") henter cellerne i hver række. Vi laver en løkke over <tr> for at genopbygge tabellen række for række.

         Her er et eksempel baseret på en liste:

         fra bs4 import BeautifulSoup
         
         html_list = """
         
           
         Æble
           
         Banan
           
         Orange
         
         """
         
         soup = BeautifulSoup(html_list, "html.parser")
         
         # Hent elementer fra listen
         items = [li.get_text(strip=True) for li in soup.find_all("li")]
         print("Uddraget liste:", items) # ["Apple", "Banana", "Orange"]
         

         Her er hver eneste

      2. . omdannes direkte til et Python-listeelement, hvilket giver resultatet ["Æble", "Banan", "Appelsin"]..

         Håndtering af paginering og links

         Ofte kan dataene ikke være på en enkelt side. De er spredt over flere sider ved hjælp af “næste side” eller a Nummereret paginering (?side=1, ?side=2, ...).

         📌 I begge tilfælde skal du krølle (gennemse i en løkke) for at hente alle siderne og flette dataene.

         Eksempel med en sideparameter :

         Importtidspunkt
         import anmodninger
         fra bs4 import BeautifulSoup
         
         # Eksempel på URL med paginering
         BASE_URL = "https://bonjour.com/articles?page={}"
         HEADERS = {"User-Agent": "Mozilla/5.0"}
         
         alle_artikler = []
         
         # Antag, at der er 5 sider at gennemse
         for page in range(1, 6):
             url = BASE_URL.format(side)
             r = requests.get(url, headers=HEADERS, timeout=20)
             hvis r.status_code == 200:
                 soup = BeautifulSoup(r.text, "html.parser")
                 # Udtræk af artikeltitler
                 articles = [h2.get_text(strip=True) for h2 in soup.find_all("h2", class_="title")]
                 all_articles.extend(artikler)
             else:
                 print(f "Fejl på side {side} (kode: {r.status_code})")
             time.sleep(1.0) # høflighed
         
         print("Artikler hentet:", all_articles)

         En kort forklaring:

         • Forbered URL'en med en placering {} til at indsætte sidetallet.

         BASE_URL = "https://bonjour.com/articles?page={}

         • Nogle websteder blokerer forespørgsler uden "browseridentitet". Ved at tilføje en User-Agent undgår du at blive opfattet som en bot.

         headers = {"User-Agent": "Mozilla/5.0"}
         requests.get(url, headers=headers) 

         • Loop fra side 1 til 5.

         for side i interval(1, 6):

         • Hent HTML fra siden.

         requests.get(url)

         • Begræns ventetiden, hvis webstedet ikke svarer.

         requests.get(url, timeout=20)

         • Parser la side.

         BeautifulSoup(response.text, "html.parser")

         • Hent alle artikeltitler.

         find_all("h2", class_="title")

         • Føj fundne elementer til en global liste.

         all_articles.extend(artikler)

         • Indfør en pause mellem hver anmodning for ikke at overbelaste serveren og undgå at blive udelukket.

         time.sleep(1.0)

         • Efter loopet, alle_artikler indeholder alle 5 sidetitler.

         Almindelige fejl og udfordringer

         ❗ Scraping er ikke altid bare at trykke på en knap, og så er alt i orden. Du kan ofte støde på forhindringer som:

         • HTTP-fejl

         404 Siden blev ikke fundet
         403 ingen adgang
         500 Fejl på serversiden

         Eksempel:

         response = requests.get(url)
         hvis response.status_code == 200:
             # Side OK
             print("Siden blev hentet med succes")
         elif response.status_code == 404:
             print("Fejl: siden blev ikke fundet")
         else:
             print("Kode returneret:", response.status_code)
         

         • Websteder, der blokerer for scraping

         Nogle registrerer automatiske forespørgsler og blokerer adgangen.

         • Dynamiske sider (JavaScript)

         BeautifulSoup læser kun statisk HTML. Hvis siden indlæser sin indhold med JavaScriptDu vil ikke se noget.

         ✅ I dette tilfælde skal du bruge værktøjer som Selen Hvor Dramatiker.

         Men hvis du vil scrape effektivt uden at blive blokeret eller skade webstedet, er her de bedste fremgangsmåder:

         • ✔ Respekter den robots.txt-filen en hjemmeside.
         • ✔ Sæt op Deadlines mellem anmodninger for ikke at overbelaste serveren (ved hjælp af time.sleep()).
         • ✔ Brug fuldmagter og dreje dem.
         • ✔ Skift regelmæssigt din Brugeragent.

         Hvordan kan jeg scrape nettet med Selenium og BeautifulSoup?

         

         ⚠ En påmindelse : BeautifulSoup er en fremragende HTML-analysator, men den kan ikke køre JavaScript fra en webside. Det er her, Selenium bliver din allierede!

         I bund og grund er selen Styr en rigtig browserDen afvikler JavaScript og viser siden, som om det var et menneske, der kiggede på den. BeautifulSoup analyserer derefter HTML-koden, når siden er fuldt gengivet. Så du kan udtrække, hvad du vil.

         Trin 1: Installer Selenium og BeautifulSoup

         Her vil vi i stedet for at bruge biblioteket Request bruge Selen. For at installere det skal du gå via pip.

         pip install selenium beautifulsoup4 

         Dernæst skal du downloade og installere en WebDriver som svarer til versionen af din browser (f.eks. ChromeDrive til Google Chrome).

         ✅ Du kan enten placere den i samme mappe som dit Python-script ellertilføj til miljøvariablen PATH af dit system.

         Trin 2: Konfiguration af Selenium

         Først og fremmest skal du importere webdriver fra Selenium til at styre en browser.

         fra selenium import webdriver
         fra selenium.webdriver.common.by import By 

         Derefter starter man en browser. Det er browseren, der åbner websiden og vil udføre JavaScript (Eksempel: Chrome).

         driver = webdriver.Chrome() 

         Du fortæller browseren, hvilken side den skal besøge.

         driver.get("https://www.exemple.com") 

         Hvis siden tager lang tid at vise visse elementer, kan du bede Selenium om at vente lidt.

         driver.implicitly_wait(10) 

         Trin 3: Hentning af sideindhold

         Når siden er indlæst, kan du hente Fuld DOM (HTML-kildekode efter JS-eksekvering).

         html_content = driver.page_source 

         Trin 4: HTML-analyse med BeautifulSoup

         Overfør nu denne kildekode til BeautifulSoup, så du kan bruge den:

         from bs4 import BeautifulSoup # Opret et BeautifulSoup-objekt soup = BeautifulSoup(html_content, 'html.parser') # Eksempel: hent alle titlerne på siden titles = soup.find_all('h2') for title in titles: print(title.get_text()) 

         👉 BeautifulSoup tilbyder kraftfulde metoder som find(), find_all() og CSS-selektorer til mål og udtrække elementer HTML-kode.

         Trin 5: Lukning af browseren

         Meget vigtigt: Luk altid din browser efter kørsel for at frigøre ressourcer!

         driver.quit() 

         ✅ Og der har du det! Du kan nu kombinere kraften i Selenium til at Simulere menneskelig navigation (klik, rulning osv.) med BeautifulSoups effektivitet til analyse af HTML-kode.

         Ofte stillede spørgsmål

         Hvad er det bedste værktøj til webscraping i Python?

         Der findes ikke rigtig noget universelt værktøj, der er bedst, men snarere løsninger, der er tilpasset dit projekt.

         🔥 SmukSuppe HTML-parser: enkel og effektiv til at analysere HTML og udtrække indhold hurtigt. Den er ideel, hvis du lige er begyndt, eller hvis du har små projekter.

         🔥 Skrot : Det er et komplet framework, der er udviklet til at håndtere store datamængder med avancerede funktioner.

         🔥 Dramatiker : perfekt til komplekse JavaScript-genererede websteder, da det simulerer en rigtig browser og gør det muligt at interagere med siden som et menneske.

         Sådan bruger du BeautifulSoup til at udtrække indhold fra et tag <div> ?

         Med BeautifulSoup kan du målrette en bestemt beacon ved hjælp af en CSS-vælger. For at udtrække indhold fra en <div>Her er trinnene:

         1. Hent siden med Requests, og analyser derefter med BeautifulSoup

         fra bs4 import BeautifulSoup
         import anmodninger
         
         url = "URL_OF YOUR_SITE" # Erstat med den rigtige URL
         svar = requests.get(url)
         html_content = svar.tekst
         
         soup = BeautifulSoup(html_content, "html.parser")

         2. Brug den vælg() tag ved at give det din CSS-selektor til at målrette mod <div>

         For at hente det første element skal du bruge soup.select_one
For at hente alle emnerne skal du bruge suppe.vælg

         HTML-eksempel:

         <div class="article">
           <h2>Titel på artikel</h2>
           <p>Her er, hvad der står i afsnittet.</p>
         </div>

         Eksempel med CSS :

         # Hent den første div med klassen "article"
         div_article = soup.select_one("div.article")
         
         # Vis dens tekstindhold
         if div_article:
         print(div_article.get_text(strip=True))

         Her er CSS-selektoren div.artikel.

         3. Uddrage elementer inde i <div>

         # Henter titlen inde i div'en
         title = soup.select_one("div.article h2").get_text()
         
         # Hent afsnittet inde fra div'en
         paragraph = soup.select_one("div.item p").get_text()
         
         print("Titel:", titel)
         print("Paragraph:", paragraph)

         Hvordan kan Requests og BeautifulSoup bruges sammen?

         Disse to biblioteker supplerer hinanden.

         1. Requests henter indholdet af en webside med en HTTP-forespørgsel.

         Den sender en HTTP-anmodning til målwebstedet og downloader sidens rå HTML-kode.

         importanmodninger
         
         url = "https://sitecible.com"
         response = requests.get(url) # HTTP-anmodning
         print(response.text) # viser den rå HTML

         På dette tidspunkt er alt, hvad du har, en stor tekst fuld af tags (<html>,<div><p>osv.).

         2. BeautifulSoup analyserer dette HTML-indhold for at finde ud af, hvad der interesserer dig.

         Den tager rå HTML og omdanner den til en organiseret struktur. Takket være dette kan du nemt navigere inden for HTML: finde, udtrække og hente data.

         fra bs4 import BeautifulSoup
         
         soup = BeautifulSoup(response.text, "html.parser") # analyserer HTML'en
         title = soup.find("h1").get_text() # udtrækker indholdet af en <h1>
         print(titel)

         Hvorfor virker min webscraping-kode ikke på nogle sider?

         Dit script henter måske ikke noget, fordi nogle websteder ikke leverer alt indholdet direkte i HTML.

         Disse websteder bruger JavaScript til at indlæse data dynamisk. BeautifulSoup tillader dog ikkeanalysere data gengivet af JavaScript.

         I dette tilfælde bør du bruge værktøjer som f.eks. Dramatiker Hvor Selen.

         Hvilken rolle spiller BeautifulSoup i webscraping?

         BeautifulSoup fungerer somHTML-parser.

         Den tager kildekoden fra en side i form af rå tekst og omdanner den til et struktureret objekt, som du nemt kan gennemse.

         Uden dette bibliotek vil du se en stor blok af ulæselig tekst. Kort sagt er BeautifulSoup oversætteren mellem Almindelig HTML og din Python-kode.

         Webscraping: BeautifulSoup vs. Scrapy?

         SmukSuppe og Skrot er meget forskellige, selv om de begge bruges til webscraping.

         SmukSuppe	Skrot
         Et simpelt bibliotek, der udelukkende bruges til at analysere HTML og udtrække data.	En komplet ramme, der styrer hele scraping-processen (forespørgsler, linksporing, paginering, dataeksport, fejlhåndtering).

         Kort sagt gør BeautifulSoup det lettere atUdtræk af HTML-data i Python. Dette bibliotek er perfekt til begyndere, fordi det gør scraping hurtigt og nemt.

         Ellers, hvis du ikke vil have ingen kodning, det komplette værktøj Lyse data er også en fremragende løsning til webscraping.

         👉 Fortæl os nu i kommentarerne, hvad det lykkedes dig at skrabe!