Kurs Python · Moduł 4: Dane, API i bazy danych

Web scraping - zbieranie danych z sieci

10 min czytania ·
W tej lekcji12

Witaj ponownie! Darwin tutaj z fascynującą lekcją.

Nauczyłeś/aś się jak pobierać dane z REST API - eleganckich, strukturalnych interfejsów. Ale co gdy strona nie ma API? Co gdy dane o gatunkach są ukryte w HTML tabeli na stronie WWW?

Wtedy używamy web scrapingu - automatycznego pobierania i ekstrakcji danych ze stron internetowych!

Analogia Safari: REST API to jak oficjalny raport od parku narodowego w formacie JSON. Web scraping to jak czytanie broszury turystycznej i ręczne wyciąganie informacji: "Aha, tu pisze że jest 120 lwów, a tu że siedlisko to sawanna"!

Czym jest web scraping?

Web scraping to automatyczna ekstrakcja danych ze stron internetowych przez:

  1. Pobranie HTML strony (jak przeglądarka)
  2. Parsowanie struktury HTML (DOM)
  3. Znalezienie interesujących elementów (tabele, listy, nagłówki)
  4. Wyciągnięcie danych (tekst, linki, obrazy)

Kiedy używać web scrapingu?

Używaj gdy:

  • Strona nie ma API
  • API jest płatne, a dane publiczne
  • Potrzebujesz danych historycznych (archiwa)
  • Agregacja danych z wielu źródeł

Unikaj gdy:

  • Strona ma oficjalne API (użyj API!)
  • Regulamin zabrania scrapingu
  • Dane są chronione prawnie
  • Możesz naruszyć RODO/prywatność

Legalność i etyka

WAŻNE: Web scraping jest legalny gdy:

  • Scrapisz publiczne dane (dostępne bez logowania)
  • Przestrzegasz robots.txt (https://example.com/robots.txt)
  • Nie przeciążasz serwera (rate limiting!)
  • Nie naruszasz praw autorskich

Złe praktyki:

  • Ignorowanie robots.txt
  • Tysiące zapytań na sekundę (DDoS)
  • Scraping danych osobowych
  • Łamanie logowania/paywall

Złota zasada: Zachowuj się jak człowiek - odwiedzaj stronę rozsądnie, nie przeciążaj serwera!

BeautifulSoup4 - parser HTML w Pythonie

BeautifulSoup4 (bs4) to najpopularniejsza biblioteka do parsowania HTML/XML w Pythonie.

Instalacja

pip install beautifulsoup4
pip install requests  # Do pobierania HTML
pip install lxml      # Szybki parser (opcjonalnie)

Podstawowe użycie

import requests
from bs4 import BeautifulSoup

# 1. Pobierz HTML
response = requests.get("https://example.com/species")
html_content = response.text

# 2. Sparsuj HTML
soup = BeautifulSoup(html_content, "html.parser")  # lub "lxml"

# 3. Znajdź elementy
title = soup.find("h1")
print(title.text)  # Tekst nagłówka

# 4. Znajdź wszystkie elementy
species_items = soup.find_all("div", class_="species-card")
for item in species_items:
    name = item.find("span", class_="name").text
    print(name)

Anatomia HTML - co parsujemy?

HTML to drzewo elementów (tagów):

<div class="species-card" id="lion" data-population="120">
    <h2>Lew</h2>
    <p class="description">Panthera leo</p>
    <img src="/images/lion.jpg" alt="Lew">
    <a href="/species/lion">Więcej informacji</a>
</div>

Elementy do ekstrakcji:

  • Tekst: <h2>Lew</h2> → "Lew"
  • Atrybuty: class="species-card", id="lion"
  • Linki: <a href="/species/lion">
  • Obrazy: <img src="/images/lion.jpg">
  • Dane: data-population="120"

Znajdowanie elementów - selektory

find() - pierwszy pasujący element

from bs4 import BeautifulSoup

html = """
<div class="container">
    <h1>Safari Data</h1>
    <div class="species">Lew</div>
    <div class="species">Słoń</div>
</div>
"""

soup = BeautifulSoup(html, "html.parser")

# Znajdź pierwszy element
title = soup.find("h1")
print(title.text)  # "Safari Data"

# Znajdź pierwszy element z klasą
species = soup.find("div", class_="species")
print(species.text)  # "Lew" (pierwszy!)

find_all() - wszystkie pasujące elementy

# Znajdź wszystkie elementy z klasą "species"
all_species = soup.find_all("div", class_="species")
print(len(all_species))  # 2

for species in all_species:
    print(species.text)
# Lew
# Słoń

# Limit wyników
first_two = soup.find_all("div", limit=2)

Selektor CSS - select()

# CSS selectors (jak w CSS!)
all_species = soup.select(".species")  # Klasa
title = soup.select_one("#main-title")  # ID
links = soup.select("div.container a")  # Zagnieżdżone

Selektory CSS:

  • .species - klasa
  • #lion - ID
  • div.species - tag + klasa
  • div > p - bezpośrednie dziecko
  • div p - dowolne zagnieżdżenie
  • [data-population] - atrybut

Ekstrakcja danych

Tekst elementu

html = '<div class="name">Lew <span>(Panthera leo)</span></div>'
soup = BeautifulSoup(html, "html.parser")

# .text - cały tekst (włącznie z zagnieżdżonymi tagami)
print(soup.find("div").text)  # "Lew (Panthera leo)"

# .get_text() - z separatorem
print(soup.find("div").get_text(strip=True))  # "Lew(Panthera leo)" (bez spacji)

# .string - tylko bezpośredni tekst (None jeśli zagnieżdżone)
print(soup.find("div").string)  # None (bo ma <span>)

Atrybuty elementu

html = '<img src="/lion.jpg" alt="Lew" data-population="120">'
soup = BeautifulSoup(html, "html.parser")
img = soup.find("img")

# Dostęp jak do słownika
print(img["src"])              # "/lion.jpg"
print(img["alt"])              # "Lew"
print(img["data-population"])  # "120"

# .get() - bezpieczny (zwraca None jeśli brak)
print(img.get("title"))        # None
print(img.get("src", "default.jpg"))  # "/lion.jpg"

# Wszystkie atrybuty
print(img.attrs)  # {'src': '/lion.jpg', 'alt': 'Lew', 'data-population': '120'}

Linki i URLe

html = '<a href="/species/lion" class="link">Zobacz lwa</a>'
soup = BeautifulSoup(html, "html.parser")
link = soup.find("a")

# URL
print(link["href"])  # "/species/lion"

# Tekst linku
print(link.text)     # "Zobacz lwa"

# Wszystkie linki na stronie
for link in soup.find_all("a"):
    print(f"{link.text}: {link.get('href')}")

Nawigacja po drzewie DOM

html = """
<div class="parent">
    <h2>Tytuł</h2>
    <p class="child1">Paragraph 1</p>
    <p class="child2">Paragraph 2</p>
</div>
"""
soup = BeautifulSoup(html, "html.parser")

# Dzieci (children)
parent = soup.find("div", class_="parent")
for child in parent.children:
    if child.name:  # Pomiń tekst
        print(child.name)  # h2, p, p

# Potomkowie (descendants) - wszystkie zagnieżdżone
for descendant in parent.descendants:
    if hasattr(descendant, 'name') and descendant.name:
        print(descendant.name)

# Rodzic (parent)
p = soup.find("p")
print(p.parent.name)  # "div"

# Rodzeństwo (siblings)
h2 = soup.find("h2")
for sibling in h2.next_siblings:
    if sibling.name:
        print(sibling.text)  # Paragraph 1, Paragraph 2

Safari przykład - scraping danych o gatunkach

import requests
from bs4 import BeautifulSoup
from typing import List, Dict
import time

class SafariWebScraper:
    """Scraper danych o gatunkach z witryny Safari"""

    def __init__(self, base_url: str):
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": "Safari-Research-Bot/1.0 (Educational purposes)"
        })

    def get_soup(self, url: str) -> BeautifulSoup:
        """Pobierz i sparsuj HTML"""
        response = self.session.get(url, timeout=10)
        response.raise_for_status()
        return BeautifulSoup(response.text, "html.parser")

    def scrape_species_list(self, url: str) -> List[Dict[str, str]]:
        """
        Scrapuj listę gatunków z tabeli HTML

        Przykładowa struktura:
        <table class="species-table">
            <tr>
                <td class="name">Lew</td>
                <td class="scientific">Panthera leo</td>
                <td class="population">120</td>
                <td class="habitat">Sawanna</td>
            </tr>
        </table>
        """
        soup = self.get_soup(url)
        species_list = []

        # Znajdź tabelę
        table = soup.find("table", class_="species-table")
        if not table:
            print("Nie znaleziono tabeli")
            return []

        # Iteruj po wierszach (pomijając nagłówek)
        rows = table.find_all("tr")[1:]  # [1:] pomija header

        for row in rows:
            cells = row.find_all("td")
            if len(cells) >= 4:
                species = {
                    "common_name": cells[0].text.strip(),
                    "scientific_name": cells[1].text.strip(),
                    "population": cells[2].text.strip(),
                    "habitat": cells[3].text.strip()
                }
                species_list.append(species)

        return species_list

    def scrape_species_cards(self, url: str) -> List[Dict[str, str]]:
        """
        Scrapuj gatunki z kart HTML

        <div class="species-card">
            <h3>Lew</h3>
            <p class="scientific">Panthera leo</p>
            <span class="population" data-count="120">120 osobników</span>
            <img src="/images/lion.jpg" alt="Lew">
            <a href="/species/lion">Więcej</a>
        </div>
        """
        soup = self.get_soup(url)
        species_list = []

        # Znajdź wszystkie karty
        cards = soup.find_all("div", class_="species-card")

        for card in cards:
            # Bezpieczna ekstrakcja (może brakować elementów)
            name_tag = card.find("h3")
            scientific_tag = card.find("p", class_="scientific")
            pop_tag = card.find("span", class_="population")
            img_tag = card.find("img")
            link_tag = card.find("a")

            species = {
                "common_name": name_tag.text.strip() if name_tag else "Unknown",
                "scientific_name": scientific_tag.text.strip() if scientific_tag else "Unknown",
                "population": pop_tag.get("data-count", "0") if pop_tag else "0",
                "image_url": img_tag["src"] if img_tag else None,
                "detail_url": link_tag["href"] if link_tag else None
            }
            species_list.append(species)

        return species_list

    def scrape_species_detail(self, url: str) -> Dict[str, any]:
        """
        Scrapuj szczegóły gatunku

        <div class="species-detail">
            <h1>Lew</h1>
            <div class="info">
                <dl>
                    <dt>Nazwa naukowa:</dt>
                    <dd>Panthera leo</dd>
                    <dt>Status:</dt>
                    <dd class="endangered">Zagrożony</dd>
                    <dt>Siedlisko:</dt>
                    <dd>Sawanna, step</dd>
                </dl>
            </div>
            <div class="description">
                <p>Lew to największy kot Afryki...</p>
            </div>
        </div>
        """
        soup = self.get_soup(url)

        # Nazwa
        title = soup.find("h1")
        common_name = title.text.strip() if title else "Unknown"

        # Definition list - pary dt/dd
        info = {}
        dl = soup.find("dl")
        if dl:
            terms = dl.find_all("dt")
            definitions = dl.find_all("dd")

            for term, definition in zip(terms, definitions):
                key = term.text.strip().replace(":", "").lower()
                value = definition.text.strip()
                info[key] = value

        # Opis
        description_div = soup.find("div", class_="description")
        description = description_div.get_text(strip=True) if description_div else ""

        return {
            "common_name": common_name,
            "scientific_name": info.get("nazwa naukowa", "Unknown"),
            "status": info.get("status", "Unknown"),
            "habitat": info.get("siedlisko", "Unknown"),
            "description": description
        }

    def scrape_with_pagination(self, base_url: str, max_pages: int = 5) -> List[Dict]:
        """
        Scrapuj wiele stron z paginacją

        URL pattern: /species?page=1, /species?page=2, ...
        """
        all_species = []

        for page_num in range(1, max_pages + 1):
            url = f"{base_url}?page={page_num}"
            print(f"Scrapuję stronę {page_num}: {url}")

            soup = self.get_soup(url)

            # Sprawdź czy jest następna strona
            next_button = soup.find("a", class_="next-page")
            if not next_button:
                print(f"Ostatnia strona: {page_num}")
                break

            # Scrapuj dane ze strony
            species = self.scrape_species_cards(url)
            all_species.extend(species)

            # Rate limiting - czekaj między zapytaniami!
            time.sleep(1)  # 1 sekunda między stronami

        return all_species


# === DEMONSTRACJA ===

print("=== SAFARI WEB SCRAPER ===\n")

scraper = SafariWebScraper(base_url="https://example-safari.com")

# 1. Scrapuj listę z tabeli
print("1. Scrapowanie tabeli gatunków...")
species_table = scraper.scrape_species_list("https://example-safari.com/species-table")
print(f"   Znaleziono {len(species_table)} gatunków")
for species in species_table[:3]:
    print(f"   - {species['common_name']} ({species['scientific_name']})")

# 2. Scrapuj karty
print("\n2. Scrapowanie kart gatunków...")
species_cards = scraper.scrape_species_cards("https://example-safari.com/species")
print(f"   Znaleziono {len(species_cards)} kart")

# 3. Scrapuj szczegóły
print("\n3. Scrapowanie szczegółów lwa...")
lion_detail = scraper.scrape_species_detail("https://example-safari.com/species/lion")
print(f"   Nazwa: {lion_detail['common_name']}")
print(f"   Status: {lion_detail['status']}")
print(f"   Siedlisko: {lion_detail['habitat']}")

# 4. Scrapuj z paginacją
print("\n4. Scrapowanie z paginacją...")
all_species = scraper.scrape_with_pagination("https://example-safari.com/species", max_pages=3)
print(f"   Łącznie: {len(all_species)} gatunków z 3 stron")

print("\nScraping zakończony")

Selenium - scraping dynamicznych stron

Problem: Niektóre strony ładują dane przez JavaScript - BeautifulSoup widzi pusty HTML!

Rozwiązanie: Selenium - automatyzuje prawdziwą przeglądarkę!

Instalacja

pip install selenium
# Pobierz ChromeDriver: https://chromedriver.chromium.org/

Podstawy Selenium

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time

# Uruchom przeglądarkę
driver = webdriver.Chrome()  # Wymaga ChromeDriver

try:
    # Otwórz stronę
    driver.get("https://example.com/species")

    # Czekaj aż element się załaduje (JavaScript!)
    wait = WebDriverWait(driver, 10)
    species_cards = wait.until(
        EC.presence_of_all_elements_located((By.CLASS_NAME, "species-card"))
    )

    # Ekstrakcja danych
    for card in species_cards:
        name = card.find_element(By.TAG_NAME, "h3").text
        population = card.find_element(By.CLASS_NAME, "population").text
        print(f"{name}: {population}")

    # Kliknij przycisk "Load More"
    load_more = driver.find_element(By.ID, "load-more-btn")
    load_more.click()
    time.sleep(2)  # Czekaj na załadowanie

    # Przewiń w dół (infinite scroll)
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
    time.sleep(2)

finally:
    # Zawsze zamknij przeglądarkę!
    driver.quit()

Headless mode - bez GUI

from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument("--headless")  # Bez okna przeglądarki
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")

driver = webdriver.Chrome(options=options)
# Reszta jak wyżej

Best Practices Web Scrapingu

1. Sprawdź robots.txt

import requests

response = requests.get("https://example.com/robots.txt")
print(response.text)

# Sprawdź czy Twój scraper może:
# User-agent: *
# Disallow: /admin/
# Crawl-delay: 10  # Czekaj 10s między zapytaniami

2. Rate Limiting - nie przeciążaj serwera!

import time
import random

for url in urls:
    scrape_page(url)

    # Czekaj między zapytaniami
    time.sleep(random.uniform(1, 3))  # 1-3 sekundy losowo

3. User-Agent - identyfikuj się

headers = {
    "User-Agent": "MyResearchBot/1.0 (+https://mysite.com/bot-info; contact@mysite.com)"
}
response = requests.get(url, headers=headers)

4. Obsługa błędów

from requests.exceptions import RequestException

def safe_scrape(url):
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        soup = BeautifulSoup(response.text, "html.parser")
        return soup

    except RequestException as e:
        print(f"Błąd: {e}")
        return None

5. Cache - nie pobieraj dwa razy tego samego

import pickle
from pathlib import Path

def get_cached_html(url, cache_dir="cache"):
    Path(cache_dir).mkdir(exist_ok=True)
    cache_file = Path(cache_dir) / f"{hash(url)}.pkl"

    # Sprawdź cache
    if cache_file.exists():
        with open(cache_file, "rb") as f:
            return pickle.load(f)

    # Pobierz i zapisz
    response = requests.get(url)
    html = response.text

    with open(cache_file, "wb") as f:
        pickle.dump(html, f)

    return html

Częste pułapki

1. Zmiana struktury HTML

Strony zmieniają layout - Twój scraper przestaje działać!

Rozwiązanie: Używaj wielu selektorów, obsługa błędów

# Kilka prób znalezienia elementu
name = (
    soup.find("h3", class_="species-name") or
    soup.find("span", class_="name") or
    soup.find("div", attrs={"data-type": "name"})
)

2. Dynamiczny JavaScript

BeautifulSoup widzi tylko HTML wyjściowy, nie wynik JS!

Rozwiązanie: Selenium, lub analiza API (sprawdź Network w DevTools)

3. Anti-scraping mechanizmy

  • CAPTCHA
  • Rate limiting (429 Too Many Requests)
  • IP ban
  • Wymagane ciasteczka/sesje

Rozwiązanie: Przestrzegaj zasad, nie atakuj, rozważ API

Podsumowanie

W tej lekcji nauczyłeś/aś się:

  • Czym jest web scraping i kiedy go używać
  • Legalność i etyka scrapingu (robots.txt, rate limiting)
  • BeautifulSoup4: find(), find_all(), select()
  • Ekstrakcja: tekst, atrybuty, linki
  • Nawigacja DOM: children, parent, siblings
  • Selenium dla dynamicznych stron (JavaScript)
  • Best practices: User-Agent, rate limiting, cache, błędy
  • Częste pułapki i jak ich unikać

Checkpoint

Przed przejściem dalej:

  • Potrafisz sparsować HTML przez BeautifulSoup
  • Wiesz jak znaleźć element: find(), select()
  • Potrafisz wyciągnąć tekst i atrybuty
  • Rozumiesz różnicę BeautifulSoup vs Selenium
  • Znasz etykę web scrapingu

Analogia Safari: Web scraping to jak czytanie broszur turystycznych o parkach narodowych i ręczne zbieranie danych do arkusza - czasochłonne, ale skuteczne gdy nie ma oficjalnych raportów (API)!

W następnej lekcji Darwin nauczy Cię baz danych SQL - jak przechowywać i zarządzać dużymi zbiorami danych w sposób strukturalny!

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. BeautifulSoup służy do:

  2. 2. Metoda soup.find_all('a') zwraca:

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy w prawidłowej kolejności:

  • Edytor kodu

    Pobierz stronę i znajdź wszystkie elementy <h1>

  • Edytor kodu

    Znajdź wszystkie linki (atrybut href) na stronie

  • Układanie w pionie

    Uporządkuj kroki web scrapingu:

  • Klikanie w kolejności

    Kliknij w kolejności: soup = BeautifulSoup(html, 'html.parser')

  1. PytanieBeautifulSoup
  2. Pytaniefind_all()
  3. Ułóż w kolejnościImport CSV i JSON
  4. Zadanie z kodemScraping
  5. Zadanie z kodemEkstrakcja linków
  6. Ułóż w kolejnościWeb scraping flow
  7. Kliknij w kolejnościBeautifulSoup

Przydatne artykuły