Kurs Python · Moduł 4: Dane, API i bazy danych
Web scraping - zbieranie danych z sieci
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:
- Pobranie HTML strony (jak przeglądarka)
- Parsowanie struktury HTML (DOM)
- Znalezienie interesujących elementów (tabele, listy, nagłówki)
- 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żoneSelektory CSS:
.species- klasa#lion- IDdiv.species- tag + klasadiv > p- bezpośrednie dzieckodiv 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 2Safari 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żejBest 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 zapytaniami2. 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 losowo3. 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 None5. 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 htmlCzę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. BeautifulSoup służy do:
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')