0 dní v řadě · 0 bodů

Užitečné knihovny · 25 min

BeautifulSoup: čtení webových stránek

Z HTML vytáhneš nadpisy, odkazy, ceny i celé tabulky a napíšeš scraper, který nespadne při první změně webu.

Hloubka
Úkoly
Lidsky řečeno

Webová stránka je pro počítač dlouhý text plný značek, něco jako noviny, které by někdo přepsal i s poznámkami sazeče. BeautifulSoup ty noviny rozloží zpátky na rubriky, titulky a odstavce. Pak už jen řekneš: „podej mi všechny ceny“.

Z textu udělej strom

HTML je jazyk, ve kterém se píšou webové stránky. Skládá se ze značek (anglicky tags): <h1> otevírá nadpis, </h1> ho zavírá a mezi nimi je obsah. Značky se do sebe vnořují, takže stránka tvoří strom, podobně jako složky a podsložky na disku.

html
<html>
  <body>
    <h1 class="nadpis">Dnešní nabídka</h1>
    <a href="/chleb">Chléb</a>
  </body>
</html>

Text class="nadpis" a href="/chleb" jsou atributy, tedy doplňující údaje o značce. Atribut href říká, kam odkaz vede.

BeautifulSoup je knihovna třetí strany. Na svém počítači si ji nainstaluješ jedním příkazem. Pozor na rozdíl: balík se jmenuje beautifulsoup4, ale v kódu se importuje bs4.

bash
pip install beautifulsoup4

V ukázkách tady na stránce už je připravená. Podej jí text a řekni, jakým parserem ho má číst. Parser je část programu, která z textu pozná, kde co začíná a končí. "html.parser" je součástí Pythonu, takže nic dalšího nepotřebuje.

from bs4 import BeautifulSoup

html = """
<html>
  <head><title>Pekárna U Rohlíku</title></head>
  <body>
    <h1>Dnešní nabídka</h1>
    <p class="info">Otevřeno od 6:00.</p>
    <p>Čerstvý chléb každé ráno.</p>
  </body>
</html>
"""

soup = BeautifulSoup(html, "html.parser")
print(soup.title.get_text())
print(soup.h1.get_text())
print(soup.p.get_text())
Výstup
Pekárna U Rohlíku
Dnešní nabídka
Otevřeno od 6:00.

soup je teď celý strom stránky. soup.h1 znamená „první značka h1“, proto soup.p vrátilo jen první odstavec. Metoda get_text() vrátí text uvnitř značky bez samotných značek.

find a find_all: hledání podle značky

Pro hledání máš dvě základní metody. find vrátí první shodu, find_all vrátí seznam všech shod. U obou můžeš upřesnit třídu nebo jiný atribut. Třída se píše class_ s podtržítkem, protože class je v Pythonu vyhrazené slovo.

from bs4 import BeautifulSoup

html = """
<ul id="menu">
  <li class="polozka akce"><a href="/chleb">Chléb</a></li>
  <li class="polozka"><a href="/rohlik">Rohlík</a></li>
  <li class="polozka"><a href="/kava" title="Káva s sebou">Káva</a></li>
</ul>
"""

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

print(len(soup.find_all("li")))
print(soup.find("li", class_="akce").get_text())
print(soup.find(id="menu").name)

for odkaz in soup.find_all("a"):
    print(odkaz.get_text(), "->", odkaz["href"])
Výstup
3
Chléb
ul
Chléb -> /chleb
Rohlík -> /rohlik
Káva -> /kava

Atributy čteš jako ze slovníku. Hranaté závorky skončí chybou KeyError, když atribut chybí. Metoda .get vrátí None a nic se nerozbije.

from bs4 import BeautifulSoup

soup = BeautifulSoup('<a href="/kava" class="odkaz velky">Káva</a>', "html.parser")
odkaz = soup.a

print(odkaz["href"])
print(odkaz.get("title"))
print(odkaz.get("title", "bez popisku"))
print(odkaz["class"])
print(odkaz.attrs)
Výstup
/kava
None
bez popisku
['odkaz', 'velky']
{'href': '/kava', 'class': ['odkaz', 'velky']}

Všimni si, že class je seznam. Značka totiž může mít tříd víc najednou.

from bs4 import BeautifulSoup

soup = BeautifulSoup("<h1>Nabídka</h1>", "html.parser")
print("Hledám podnadpis...")
print(soup.find("h2").get_text())
Výstup
Hledám podnadpis...

Oprava je jednoduchá: nejdřív se zeptej, jestli se něco našlo.

from bs4 import BeautifulSoup

soup = BeautifulSoup("<h1>Nabídka</h1>", "html.parser")

podnadpis = soup.find("h2")
if podnadpis is None:
    print("Podnadpis na stránce není.")
else:
    print(podnadpis.get_text())
Výstup
Podnadpis na stránce není.
Kvíz

Stránka neobsahuje žádnou značku <h2>. Co vrátí soup.find("h2") a co soup.find_all("h2")?

CSS selektory: jeden řádek místo tří

CSS selektor je krátký zápis „kde na stránce to je“. Používají ho weby pro svůj vzhled, takže ho najdeš i v nástrojích prohlížeče. select vrátí seznam všech shod, select_one první shodu nebo None.

SelektorCo najde
pvšechny značky p
.cenaznačky s třídou cena
#menuznačku s id="menu"
div.kartadiv s třídou karta
.karta.akceznačky, které mají obě třídy
ul aodkazy kdekoli uvnitř ul
ul > lili přímo pod ul
a[href]odkazy, které mají atribut href
a[href^="https"]href začíná na https
a[href$=".pdf"]href končí na .pdf
li:nth-of-type(2)druhé li mezi sourozenci
from bs4 import BeautifulSoup

html = """
<div class="karta akce">
  <h2>Chléb</h2><span class="cena">68 Kč</span>
</div>
<div class="karta">
  <h2>Rohlík</h2><span class="cena">4 Kč</span>
</div>
<a href="https://example.com/letak.pdf">Leták</a>
<a href="/kontakt">Kontakt</a>
"""

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

for karta in soup.select("div.karta"):
    nazev = karta.select_one("h2").get_text()
    cena = karta.select_one(".cena").get_text()
    print(nazev, cena)

print(soup.select_one(".karta.akce h2").get_text())
print([a["href"] for a in soup.select('a[href$=".pdf"]')])
Výstup
Chléb 68 Kč
Rohlík 4 Kč
Chléb
['https://example.com/letak.pdf']

Důležitý zvyk je vidět uvnitř cyklu: nejdřív najdi kartu a další hledání spusť až z ní. Název a cena tak patří jistě ke stejnému produktu. Dva oddělené seznamy by se rozjely, jakmile by jedna karta cenu neměla.

Úkol

Všechna PDF

Doplň funkci pdf_odkazy(html). Vrátí seznam adres (hodnot href) všech odkazů, které končí na .pdf, v pořadí, v jakém jsou na stránce. Odkaz bez href ji nesmí shodit.

from bs4 import BeautifulSoup

def pdf_odkazy(html):
    soup = BeautifulSoup(html, "html.parser")
    # doplň
    return []
Výstup

Čistý text a pohyb po stromu

Text z webu bývá plný mezer a zalomení. get_text proto umí dvě užitečné věci: strip=True ořízne každý kousek textu a první argument určí, čím se kousky spojí.

from bs4 import BeautifulSoup

html = '<p class="cena">  Cena:\n   <b>1 290</b> Kč  </p>'
p = BeautifulSoup(html, "html.parser").p

print(repr(p.get_text()))
print(repr(p.get_text(strip=True)))
print(repr(p.get_text(" ", strip=True)))
print(p.b.string)
print(p.string)
Výstup
'  Cena:\n   1 290\xa0Kč  '
'Cena:1 290Kč'
'Cena: 1 290 Kč'
1 290
None

Bez oddělovače se slova slepí, proto je get_text(" ", strip=True) nejlepší výchozí volba. Vlastnost .string funguje jen tehdy, když je uvnitř značky jediný kousek textu. Jinak vrátí None, jako v posledním řádku.

Někdy nemá hledaná věc žádnou třídu a poznáš ji jen podle sousedů. Ze značky se dá chodit nahoru k rodičům i do stran k sourozencům.

from bs4 import BeautifulSoup

html = """
<article class="produkt">
  <h2>Kávovar Ranní ptáče</h2>
  <dl>
    <dt>Hmotnost</dt><dd>3,2 kg</dd>
    <dt>Příkon</dt><dd>1450 W</dd>
  </dl>
  <a class="koupit" href="/kosik/17">Do košíku</a>
</article>
"""

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

popisek = soup.find("dt", string="Příkon")
print(popisek.find_next_sibling("dd").get_text())

tlacitko = soup.select_one("a.koupit")
karta = tlacitko.find_parent("article")
print(karta.h2.get_text())

print([dite.name for dite in karta.children])
Výstup
1450 W
Kávovar Ranní ptáče
[None, 'h2', None, 'dl', None, 'a', None]

Hodnoty None v posledním seznamu jsou zalomení řádků mezi značkami. I ta jsou ve stromu, jako textové uzly. Proto je find_next_sibling("dd") lepší než holé .next_sibling, které by často vrátilo právě prázdný řádek.

Úkol

Text, nebo náhradní hodnota

Doplň funkci text_nebo(soup, selektor, vychozi). Vrátí očištěný text prvního prvku podle selektoru, slova oddělí jednou mezerou. Když prvek neexistuje, vrátí vychozi.

from bs4 import BeautifulSoup

def text_nebo(soup, selektor, vychozi):
    return soup.select_one(selektor).get_text()
Výstup

Z tabulky na stránce udělej data

Tady se scraping začíná vyplácet. Tabulka v HTML má řádky tr, v nich buňky td a v záhlaví th. Ceny ale přicházejí jako text, navíc často s nezlomitelnou mezerou (znak  ), která vypadá jako běžná, ale replace(" ", "") ji nechá být. Spolehlivější je zahodit všechno, co není číslice. Výraz \D znáš z lekce o regulárních výrazech.

import re
from bs4 import BeautifulSoup

html = """
<table id="cenik">
  <tr><th>Produkt</th><th>Cena</th><th>Skladem</th></tr>
  <tr><td>Mlýnek</td><td>1 290 Kč</td><td>ano</td></tr>
  <tr><td>Konvice</td><td>890 Kč</td><td>ne</td></tr>
  <tr><td>Kávovar</td><td>12 490 Kč</td><td>ano</td></tr>
</table>
"""

soup = BeautifulSoup(html, "html.parser")
radky = soup.select("#cenik tr")
hlavicka = [th.get_text(strip=True) for th in radky[0].find_all("th")]

produkty = []
for radek in radky[1:]:
    hodnoty = [td.get_text(strip=True) for td in radek.find_all("td")]
    produkt = dict(zip(hlavicka, hodnoty))
    produkt["Cena"] = int(re.sub(r"\D", "", produkt["Cena"]))
    produkt["Skladem"] = produkt["Skladem"] == "ano"
    produkty.append(produkt)

for produkt in produkty:
    print(produkt)

print(sum(p["Cena"] for p in produkty if p["Skladem"]))
Výstup
{'Produkt': 'Mlýnek', 'Cena': 1290, 'Skladem': True}
{'Produkt': 'Konvice', 'Cena': 890, 'Skladem': False}
{'Produkt': 'Kávovar', 'Cena': 12490, 'Skladem': True}
13780
Úkol

Ceník do slovníku

Doplň funkci nacti_cenik(html). Z tabulky vrátí slovník {název: cena}, kde cena je celé číslo. Název je v prvním td, cena ve druhém. Řádek záhlaví s th přeskoč. Počítej s mezerami i s nezlomitelnou mezerou uvnitř ceny.

import re
from bs4 import BeautifulSoup

def nacti_cenik(html):
    soup = BeautifulSoup(html, "html.parser")
    cenik = {}
    # doplň
    return cenik
Výstup

Odkazy bývají relativní: ../kontakt nedává bez adresy stránky smysl. Nelep je k sobě ručně, na to je urljoin ze standardní knihovny.

from urllib.parse import urljoin

stranka = "https://example.com/obchod/kava/index.html"

for href in ["mlynky.html", "../caj.html", "/kontakt", "https://jinde.example/x", "#nahoru"]:
    print(urljoin(stranka, href))
Výstup
https://example.com/obchod/kava/mlynky.html
https://example.com/obchod/caj.html
https://example.com/kontakt
https://jinde.example/x
https://example.com/obchod/kava/index.html#nahoru

Skutečná stránka a slušné chování

Stažení stránky obstará knihovna requests. Tenhle kód si spusť až u sebe, v prohlížeči síť nepoužíváme. Adresu nahraď stránkou, kterou smíš číst.

python
import time
from urllib.parse import urljoin

import requests
from bs4 import BeautifulSoup

START = "https://example.com/katalog"

session = requests.Session()
session.headers["User-Agent"] = "muj-skript/1.0 ([email protected])"

odpoved = session.get(START, timeout=10)
odpoved.raise_for_status()

# .content = raw bytes: BeautifulSoup detects the encoding itself
soup = BeautifulSoup(odpoved.content, "html.parser")

for odkaz in soup.select("article a[href]"):
    adresa = urljoin(odpoved.url, odkaz["href"])
    detail = session.get(adresa, timeout=10)
    detail.raise_for_status()
    print(adresa, len(detail.content))
    time.sleep(2)  # do not hammer someone else's server

Stahování cizích stránek programem má pravidla. Pauzy mezi požadavky chrání cizí server. Podmínky webu, autorská práva a ochrana osobních údajů platí i pro skript. Když web nabízí API, použij ho. Strojová přání provozovatele najdeš v souboru /robots.txt a Python ho umí přečíst sám.

from urllib.robotparser import RobotFileParser

pravidla = """
User-agent: *
Disallow: /admin/
Crawl-delay: 2
""".splitlines()

robots = RobotFileParser()
robots.parse(pravidla)

print(robots.can_fetch("muj-skript", "https://example.com/katalog"))
print(robots.can_fetch("muj-skript", "https://example.com/admin/uzivatele"))
print(robots.crawl_delay("muj-skript"))
Výstup
True
False
2

Druhá častá překážka: otevřeš stránku v prohlížeči, data vidíš, ale v soup nejsou. Stránka si je totiž dotahuje JavaScriptem až po načtení a requests ani BeautifulSoup JavaScript nespouštějí. Zkontroluj to přes „Zobrazit zdrojový kód stránky“. Co tam není, to tvůj skript nedostane. Často ale stačí podívat se jinam, třeba do strukturovaných dat, která weby vkládají pro vyhledávače.

import json
from bs4 import BeautifulSoup

html = """
<html><head>
<script type="application/ld+json">
{"@type": "Product", "name": "Kávovar", "offers": {"price": "2490", "priceCurrency": "CZK"}}
</script>
</head><body><div id="app"></div></body></html>
"""

soup = BeautifulSoup(html, "html.parser")
print(repr(soup.select_one("#app").get_text()))

data = json.loads(soup.find("script", type="application/ld+json").string)
print(data["name"], data["offers"]["price"], data["offers"]["priceCurrency"])
Výstup
''
Kávovar 2490 CZK

Když HTML není v pořádku

Reálné HTML bývá nedbalé a prohlížeče ho tiše opravují. Různé parsery ho ale opraví různě, takže stejný text může dát různý strom. Tady chybí obě koncové značky </p>.

from bs4 import BeautifulSoup

soup = BeautifulSoup("<p>jedna<p>dva", "html.parser")

print(soup)
print("odstavce vedle sebe:", len(soup.select("p + p")))
print("odstavec v odstavci:", len(soup.select("p p")))
Výstup
<p>jedna<p>dva</p></p>
odstavce vedle sebe: 0
odstavec v odstavci: 1

Vestavěný parser nechal druhý odstavec uvnitř prvního. Prohlížeč by je dal vedle sebe a stejně to udělá lxml, rychlejší parser, který se doinstalovává zvlášť (pip install lxml). Navíc doplní chybějící html a body.

python
soup = BeautifulSoup("<p>jedna<p>dva", "lxml")
print(soup)
# <html><body><p>jedna</p><p>dva</p></body></html>

Selektor, který funguje s jedním parserem, tak s druhým nemusí. Vyber si proto jeden a drž se ho.

A teď klasika. V nástrojích prohlížeče zkopíruješ cestu k řádku tabulky, dáš ji do skriptu a nenajde nic.

from bs4 import BeautifulSoup

html = "<table><tr><td>Chléb</td></tr></table>"
soup = BeautifulSoup(html, "html.parser")

print(len(soup.select("table > tbody > tr")))
print(len(soup.select("table > tr")))
print(len(soup.select("table tr")))
Výstup
0
1
1

Prohlížeč do stromu sám doplnil tbody, ve zdrojovém HTML ale není. Nástroje prohlížeče ukazují strom po opravě a po práci JavaScriptu, tvůj skript vidí původní text.

Kvíz

Selektor zkopírovaný z nástrojů prohlížeče table > tbody > tr v BeautifulSoup nic nenajde. Co je nejpravděpodobnější příčina?

Kvíz

Značka vypadá takto: <p>Cena <b>90</b></p>. Co vrátí p.string?

Pod kapotou · parsery, kódování a paměť

Parsery. html.parser je bez závislostí a chová se předvídatelně napříč instalacemi. lxml je postavený na libxml2, je výrazně rychlejší a doplní html a body. html5lib staví strom podle algoritmu ze standardu HTML5, tedy nejblíž prohlížeči, ale je nejpomalejší. Parser vždy uváděj explicitně. Bez něj si BeautifulSoup vybere nejlepší nainstalovaný, vypíše varování a kód se může na jiném stroji chovat jinak. Parsery se registrují při prvním importu bs4, takže lxml doinstalovaný do běžícího notebooku uvidíš až po restartu jádra, do té doby dostaneš FeatureNotFound.

Kódování. Předávej response.content (bajty), ne response.text. requests u text/* bez uvedeného charsetu sáhne po ISO-8859-1, zatímco BeautifulSoup se přes UnicodeDammit podívá na BOM a na <meta charset>. Výsledek uvidíš v soup.original_encoding.

Třídy. class_="a b" porovnává celý řetězec atributu včetně pořadí. Na „má obě třídy“ použij selektor .a.b.

Paměť. NavigableString drží odkaz na svého rodiče, a tím na celý strom. Když si z milionu stránek uložíš tag.string, necháš v paměti milion stromů. Ukládej str(tag.string) nebo výsledek get_text(). U velkých dokumentů omez parsování přes SoupStrainer (s html5lib nefunguje).

Bezpečnost. BeautifulSoup není sanitizér. str(soup) zachová onclick i <script>, takže cizí HTML takhle na svůj web nedávej. Na to je knihovna s povolovacím seznamem značek, třeba nh3.

from bs4 import BeautifulSoup

data = "<meta charset='windows-1250'><p>Příliš žluťoučký kůň</p>".encode("cp1250")
soup = BeautifulSoup(data, "html.parser")

print(soup.original_encoding)
print(soup.p.get_text())
print(type(soup.p.string).__name__, type(str(soup.p.string)).__name__)
Výstup
windows-1250
Příliš žluťoučký kůň
NavigableString str

Vyzkoušej si: HTML jako strom

Napiš selektor CSS a uvidíš, které uzly dokumentu najde, spolu s odpovídajícím voláním BeautifulSoup.