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>
<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.
pip install beautifulsoup4V 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())
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"])
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)
/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())
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())
Podnadpis na stránce není.
Stránka neobsahuje žádnou značku <h2>. Co vrátí soup.find("h2") a co soup.find_all("h2")?
find hledá jednu věc, takže nemá co vrátit. find_all vrací seznam, a ten může být prázdný. Cyklus přes něj proběhne nulakrát a nic nespadne.
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.
| Selektor | Co najde |
|---|---|
p | všechny značky p |
.cena | značky s třídou cena |
#menu | značku s id="menu" |
div.karta | div s třídou karta |
.karta.akce | značky, které mají obě třídy |
ul a | odkazy kdekoli uvnitř ul |
ul > li | li 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"]')])
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.
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 []
Č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)
' 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])
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.
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()
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"]))
{'Produkt': 'Mlýnek', 'Cena': 1290, 'Skladem': True}
{'Produkt': 'Konvice', 'Cena': 890, 'Skladem': False}
{'Produkt': 'Kávovar', 'Cena': 12490, 'Skladem': True}
13780Cení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
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))
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.
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 (ja@example.com)"
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 serverStahová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"))
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"])
'' 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")))
<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.
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")))
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.
Selektor zkopírovaný z nástrojů prohlížeče table > tbody > tr v BeautifulSoup nic nenajde. Co je nejpravděpodobnější příčina?
Prohlížeč HTML opravuje podle standardu a doplňuje chybějící části. html.parser čte text tak, jak přišel. Volnější table tr funguje v obou případech.
Značka vypadá takto: <p>Cena <b>90</b></p>. Co vrátí p.string?
Uvnitř p je víc potomků, text a značka b. .string odpovídá jen při jediném potomkovi. Celý text získáš přes get_text(" ", strip=True).
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__)
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.