crawler_reseni.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1960c34d",
   "metadata": {},
   "source": [
    "# Web crawler\n",
    "\n",
    "V tomto notebooku si vyzkoušíte, jak naprogramovat jednoduchý web crawler, tj. program, který sám prochází internetové stránky a do vhodného formátu ukládá jejich obsah. K vytvoření takového programu použijete standardní funkce Pythonu, soubor modulů urllib pro otvírání internetových stránek a knihovnu BeautifulSoup, díky které jednoduše získáte text z HTML kódu. \n",
    "\n",
    "Termín web scraping označuje získávání dat z internetových stránek. Ačkoliv proces stahování dat může probíhat manuálně, většinou se označení web scrapingu vztahuje na automatizovaný proces. Extrahování dat sestává z několika kroků. Nejprve je nutné určit, jaké internetové stránky bude vhodné použít. Poté dojde ke stažení těchto stránek a dalšímu zpracování. V některých aplikacích stačí získat pouze holý text, pro lingvistické bádání může být důležité text např. morfologicky analyzovat. Postup se tedy liší podle konkrétní aplikace.\n",
    "\n",
    "Existuje mnoho sofistikovaných aplikací pro web scraping volně dostupných k použití, mezi oblíbené patří ku příkladu [Web Scraper](https://webscraper.io/). \n",
    "\n",
    "Více o web scrapingu [zde](https://en.wikipedia.org/wiki/Web_scraping). Obecně o fungování web crawlerů pak [zde](https://en.wikipedia.org/wiki/Web_crawler).\n",
    "\n",
    "\n",
    "## 1 S čím budete pracovat\n",
    "\n",
    "### 1.1 HTML\n",
    "\n",
    "HTML (HyperText Markup Language, česky hypertextový značkovací jazyk) je základním stavebním kamenem internetových stránek. Tento jazyk definuje základní strukturu stránek. Vedle HTML se při tvorbě stránek používají ještě CSS (Cascading Style Sheets, česky kaskádové styly) pro vzhled a programovací jazyk JavaScript např. pro ovládání interaktivních prvků.\n",
    "\n",
    "Pro tento úkol je důležité seznámit se se strukturou HTML, abyste byli schopní ze stránek stáhnout holý text. Ten je v HTML uzavřen ve značkách, např. `<p>Ukázkový text</p>` značí jeden odstavec obsahující text _Ukázkový text_.\n",
    "\n",
    "HTML kód jednotlivých stránek si můžete prohlédnout přímo v prohlížeči. Po kliknutí pravým tlačítkem myši do prostoru stránky se zobrazí menu, ze kterého vyberte Zobrazit zdrojový kód stránky nebo Prozkoumat prvek. V prvním případě se otevře nové okno se zdrojovým kódem. V druhém případě se přímo na stránce otevře nástroj pro vývojáře, ve kterém je možné prozkoumávat jednotlivé prvky stránky.\n",
    "\n",
    "![Inspect](https://raw.githubusercontent.com/AiKuroyake/PLIN-programming/main/pictures/Web%20crawler%20%E2%80%93%20Wikipedie%20%E2%80%94%20Mozilla%20Firefox_001.jpg)\n",
    "\n",
    "Pro stahování dat bude důležité, abyste věděli, v jakých HTML značkách je uzavřen text, který chcete stáhnout. To zjistíte právě ve zdrojovém kódu.\n",
    "\n",
    "Více o HTML a značkách například [zde](https://www.w3schools.com/html/html_intro.asp) nebo [zde](https://developer.mozilla.org/en-US/docs/Web/HTML).\n",
    "\n",
    "### 1.2 urllib\n",
    "\n",
    "urllib je soubor modulů umožňující pracovat s internetovými adresami (URL). Z tohoto souboru je pro tento notebook nejdůležitější modul request, který otevře požadované URL.\n",
    "\n",
    "### 1.3 BeautifulSoup\n",
    "\n",
    "BeautifulSoup je knihovna pro stahování dat z HTML a XML souborů. V tomto úkolu ji použijete pro získání holého textu z HTML značek.\n",
    "\n",
    "Více informací v [dokumentaci](https://beautiful-soup-4.readthedocs.io/en/latest/).\n",
    "\n",
    "## 2 Instalace\n",
    "\n",
    "### 2.1 urllib\n",
    "\n",
    "urllib je součástí tzv. The Python Standard Library (standardní knihovny Pythonu), není tedy nutné nic instalovat.\n",
    "\n",
    "Více informací na [The Python Standard Library](https://docs.python.org/3/library/).\n",
    "\n",
    "### 2.2 BeautifulSoup\n",
    "\n",
    "Instalaci BeautifulSoup provedete přímo v tomto notebooku. \n",
    "\n",
    "Následující buňku pouze spusťte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c27c063",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip3 install bs4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b226e8b8",
   "metadata": {},
   "source": [
    "## 3 Import knihoven a modulů \n",
    "\n",
    "Než bude možné začít s psaním programu, je nutné importovat všechny knihovny a moduly, které budete potřebovat. Patří mezi ně:\n",
    "\n",
    "- funkce urlopen z modulu urllib.request,\n",
    "- knihovna BeautifulSoup z modulu bs4.\n",
    "\n",
    "Spusťte následující buňku, knihovny se importují.\n",
    "\n",
    "**Poznámka:** Po každém otevření notebooku je nutné všechen kód (tj. i importování) spustit znovu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3649a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.request import urlopen #importuj funkci urlopen\n",
    "from bs4 import BeautifulSoup #importuj knihovnu BeautifulSoup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7b09521",
   "metadata": {},
   "source": [
    "## 4 Otevření URL\n",
    "\n",
    "Abyste mohli stáhnout textová data z internetových stránek, musíte je nejdřív v Pythonu otevřít. K tomu slouží funkce `urlopen`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4906bac",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = urlopen('https://cs.wikipedia.org/wiki/Web_crawler') #otevři url"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a5ba6c0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(f) #vypiš proměnnou f"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2cd02a9",
   "metadata": {},
   "source": [
    "Jak si můžete všimnout výše, při vypsání proměnné se nevypíše její obsah, ale informace o vytvořeném objektu. Pokud budete chtít obsah stránky vypsat, musíte nejprve použít metodu `read`, která přečte celý soubor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37d21e36",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = f.read() #přečti proměnnou f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "149d3b0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f) #vypiš proměnnou f"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0dd6ca4",
   "metadata": {},
   "source": [
    "Vypsaný text je sice nepřehledný, ale přesto si můžete všimnout, že nepodporuje písmena s diakritikou. Např. slovo _vyhledávače_ je v textu reprezentováno jako _vyhled\\xc3\\xa1va\\xc4\\x8de_. To souvisí s kódováním, tj. reprezentací znaků na počítači. Aby se vám text zobrazil i s písmeny s diakritikou, použijte metodu `decode` s parametrem UTF-8.\n",
    "\n",
    "Více o kódování [zde](https://cs.wikipedia.org/wiki/K%C3%B3dov%C3%A1n%C3%AD_znak%C5%AF) a o standardu UTF-8 [zde](https://cs.wikipedia.org/wiki/UTF-8)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ca23b80",
   "metadata": {},
   "outputs": [],
   "source": [
    "f_decoded = f.decode('UTF-8') #změň kódování na UTF-8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b49e6bb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f_decoded) #vypiš proměnnou f_decoded"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f687b4a",
   "metadata": {},
   "source": [
    "## 5 BeautifulSoup\n",
    "\n",
    "Pro získání holého textu bez HTML značek použijte knihovnu BeautifulSoup. Nejprve zavolejte BeautifulSoup konstruktor, který požaduje dva parametry:\n",
    "\n",
    "1. HTML dokument (v tomto případě uložený v proměnné `f` z předchozí kapitoly),\n",
    "2. typ parseru, v tomto případě `html.parser`, jelikož pracujete s dokumentem psaným v HTML.\n",
    "\n",
    "Do proměnné `soup` uložte výsledek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5013a51a",
   "metadata": {},
   "outputs": [],
   "source": [
    "soup = BeautifulSoup(f, 'html.parser') #ulož BeautifulSoup objekt do proměnné soup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2aacef20",
   "metadata": {},
   "source": [
    "Po vypsání proměnné `soup` si na první pohled nevšimnete větších změn od výpisů v minulé sekci. Díky použití konstruktoru můžete však použít metody z knihovny BeautifulSoup pro práci s HTML dokumenty, jelikož se nejedná o obyčejný textový řetězec, ale objekt BeautifulSoup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b22675a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup) #vypiš proměnnou soup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc384293",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(soup) #vypiš datový typ proměnné soup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e7e403b",
   "metadata": {},
   "source": [
    "### 5.1 prettify\n",
    "\n",
    "První užitečnou metodou je `prettify`, která text formátuje do přehledného řetězce. Díky tomu si HTML kód můžete přehledně prohlédnout a nemusíte využívat zdrojový kód stránky."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7380a17b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup.prettify()) #formátuj dokument pomocí metody prettify"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d513a00",
   "metadata": {},
   "source": [
    "### 5.2 get_text\n",
    "\n",
    "Metoda `get_text` vám umožní získat holý text bez HTML značek. Můžete ji použít na celý text nebo jen na text v určitých značkách."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb924517",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = soup.get_text() #získej text z proměnné soup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e862be01",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(txt) #vypiš text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8486a2cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "heading = soup.h1.get_text() #získej text z nadpisu první úrovně v proměnné soup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "799221c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(heading) #vypiš proměnnou heading"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec0773e0",
   "metadata": {},
   "source": [
    "### 5.3 find"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52b8191a",
   "metadata": {},
   "source": [
    "Pro vyhledání značky slouží metoda `find`. Tato metoda (na rozdíl od metody `find_all` uvedené níže) najde a vrátí pouze první výskyt značky. Do parametru metody se uvádí HTML značka, kterou chcete nalézt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "296026fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = soup.find('b') #vyhledej první instanci značky tučného textu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e2cbeeff",
   "metadata": {},
   "outputs": [],
   "source": [
    "b #vypiš proměnnou b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6cf2f2a",
   "metadata": {},
   "source": [
    "### 5.4 find_all\n",
    "\n",
    "Pro vyhledání všech instancí jedné značky slouží metoda `find_all`. Do parametru této metody opět uveďte HTML značku, kterou chcete nalézt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32e512a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "b2 = soup.find_all('b') #vyhledej všechny instance značky tučného textu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "beca668d",
   "metadata": {},
   "outputs": [],
   "source": [
    "b2 #vypiš proměnnou b2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16d5167c",
   "metadata": {},
   "source": [
    "Všimněte si, že výstupem `find_all` je seznam. Všechny odstavce jsou ponechány s HTML značkami. Pro přehledné vypsání obsahu proměnné tedy nestačí proměnnou pouze vypsat, musíte přes její prvky iterovat a vypsat je postupně pomocí metody `get_text`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da1fd05c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in b2: #pro každý element v seznamu b2\n",
    "    print(t.get_text()) #vypiš element"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f935fb7",
   "metadata": {},
   "source": [
    "### 5.5 Hledání tříd a identifikátorů\n",
    "\n",
    "Pokud vám nebude stačit vyhledání pouze samostatné značky, ale budete potřebovat nalézt značku s konkrétní třídou nebo indentifikátorem, použijte ve funkci `find` nebo `find_all` ještě druhý parametr, do kterého zadáte název třídy nebo identifikátoru. Do parametru musíte zadat datový typ slovník, kde klíč je označení třída/identifikátor a hodnota je název třídy/identifikátoru.\n",
    "\n",
    "Pro vyhledání všech instancí značky `<span class=\"toctext\">` slouží následující kód. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18cb833f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tt = soup.find_all('span', {'class': 'toctext'}) #vyhledej všechny instance značky "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16d5da83",
   "metadata": {},
   "outputs": [],
   "source": [
    "tt #vypiš proměnnou tt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a5182cf",
   "metadata": {},
   "source": [
    "**Poznámka:** Tento kód bude fungovat pouze, kdy daná HTML značka má jenom jednu třídu. Pokud je značek víc, musí se postupovat jinak, viz [Stack Overflow](https://stackoverflow.com/a/22284921/2318602).\n",
    "\n",
    "Další informace ke knihovně BeautifulSoup naleznete [v dokumentaci](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#beautiful-soup-documentation).\n",
    "\n",
    "\n",
    "## 6 Web crawler\n",
    "\n",
    "V této sekci budete mít za úkol naprogramovat vlastní web crawler. V několika krocích vytvoříte program, který z hlavní stránky Root.cz stáhne nadpisy článků, jejich perexy a dobu čtení.\n",
    "\n",
    "Nejprve si prohlédněte strukturu [stránek](https://www.root.cz/).\n",
    "\n",
    "Než začnete psát první funkci, do proměnné `url` uložte url stránky Root.cz\n",
    "\n",
    "Následující buňku pouze spusťte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96588d13",
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'https://www.root.cz/' #do proměnné url ulož stránku Root.cz"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "641add23",
   "metadata": {},
   "source": [
    "**Úkol 1:** Napište funkci `read_url`, která otevře stránku uloženou v proměnné `url`, přečte ji, změní kódování na UTF-8 a poté vrátí na výstup."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b498e619",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_url(url):\n",
    "    \"\"\" Otevři a přečti stránku, zmeň kódování na UTF-8 \"\"\"\n",
    "    \n",
    "    u = urlopen(url) #otevři url\n",
    "    u = u.read() #přečti stránku\n",
    "    u = u.decode('UTF-8') #změň kódování na UTF-8\n",
    "    \n",
    "    return u #vrať řetězec"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "444b712f",
   "metadata": {},
   "source": [
    "**Úkol 2:** Zavolejte funkci `read_url` a její výstup uložte do proměnné `doc`. Proměnnou `doc` pak vypište."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "040b202c",
   "metadata": {},
   "outputs": [],
   "source": [
    "doc = read_url(url) #zavolej funkci read_url a výsledek ulož do proměnné doc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8386d19",
   "metadata": {},
   "outputs": [],
   "source": [
    "doc #vypiš proměnnou doc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c50a78b",
   "metadata": {},
   "source": [
    "Aby bylo možné s HTML dokumentem dále pracovat a vyhledávat v něm, je nutné použít BeautifulSoup konstruktor. Následující buňka zavolá BeautifulSoup konstruktor a do proměnné `soup` uloží BeautifulSoup objekt.\n",
    "\n",
    "Následující buňku pouze spusťte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53d6a90b",
   "metadata": {},
   "outputs": [],
   "source": [
    "soup = BeautifulSoup(doc, 'html.parser') #zavolej BeautifulSoup konstruktor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a55c64c",
   "metadata": {},
   "source": [
    "**Úkol 3:** Zjistěte, jakého typu je proměnná `soup`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6494cb99",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(soup) #vypiš typ proměnné soup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac10cb5f",
   "metadata": {},
   "source": [
    "**Úkol 4:** Pro přehlednější orientaci v HTML dokumentu použijte metodu `prettify`.\n",
    "\n",
    "**Poznámka:** V tomto případě _musíte_ použít standardní výpis v proměnných v Pythonu, tj. funkci `print`, aby se výpis zobrazil správně s řádkováním a odsazením jednotlivých značek. Pokud použijete výpis bez funkce `print`, zobrazí se v něm netisknutelné řídící znaky (např. `\\n` pro nový řádek), výpis tak nebude přehledný."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6bba10e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(soup.prettify()) #formátuj dokument pomocí metody prettify"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c111365a",
   "metadata": {},
   "source": [
    "**Úkol 5:** \n",
    "\n",
    "1. Ve zdrojovém kódu stránky najděte, v jakých značkách jsou uloženy boxy obsahující články.\n",
    "\n",
    "![Články](https://raw.githubusercontent.com/AiKuroyake/PLIN-programming/main/pictures/Root.cz%20-%20informace%20nejen%20ze%20sv%C4%9Bta%20Linuxu%20%E2%80%94%20Mozilla%20Firefox_006.jpg)\n",
    "\n",
    "Takto si budete jistí, že výsledek bude obsahovat pouze články z této sekce.\n",
    "\n",
    "2. Najděte všechny instance těchto boxů pomocí značek a do proměnné `content` uložte výsledek. \n",
    "3. Proměnnou pak vypište."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95f9a363",
   "metadata": {},
   "source": [
    "<details> \n",
    "    <summary>Klikněte na tento text pro zobrazení <b>nápovědy:</b></summary>\n",
    "    <p>Lze použít celkem 2 různé značky, se kterými výsledný kód bude fungovat.</p>\n",
    "    <p>Obě značky mají v názvu box.</p>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb27ce89",
   "metadata": {},
   "outputs": [],
   "source": [
    "#najdi všechny instance značky div s třídou design-box__content\n",
    "content = soup.find_all(\"div\", {\"class\": \"design-box__content\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90403b9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "content #vypiš proměnnou content"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ff60475",
   "metadata": {},
   "source": [
    "**Úkol 6:** \n",
    "\n",
    "1. Ve zdrojovém kódu stránky najděte, v jakých značkách jsou uloženy jednotlivé články.\n",
    "2. Dále nalezněte značky pro nadpis článku, perex a dobu čtení.\n",
    "\n",
    "Nadpis:\n",
    "\n",
    "![Nadpis](https://raw.githubusercontent.com/AiKuroyake/PLIN-programming/main/pictures/Root.cz%20-%20informace%20nejen%20ze%20sv%C4%9Bta%20Linuxu%20%E2%80%94%20Mozilla%20Firefox_004.jpg)\n",
    "\n",
    "Perex:\n",
    "\n",
    "![Perex](https://raw.githubusercontent.com/AiKuroyake/PLIN-programming/main/pictures/Root.cz%20-%20informace%20nejen%20ze%20sv%C4%9Bta%20Linuxu%20%E2%80%94%20Mozilla%20Firefox_002.jpg)\n",
    "\n",
    "Doba čtení:\n",
    "\n",
    "![Doba čtení](https://raw.githubusercontent.com/AiKuroyake/PLIN-programming/main/pictures/Root.cz%20-%20informace%20nejen%20ze%20sv%C4%9Bta%20Linuxu%20%E2%80%94%20Mozilla%20Firefox_005.jpg)\n",
    "\n",
    "Názvy značek si napište do následující buňky, budete je potřebovat v dalším úkolu."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "049215c8",
   "metadata": {},
   "source": [
    "_značka pro články:_\n",
    "\n",
    "_značka pro nadpisy:_\n",
    "\n",
    "_značka pro perexy:_\n",
    "\n",
    "_značka pro doby čtení:_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d69a5fde",
   "metadata": {},
   "source": [
    "**Úkol 7:** Napište funkci `get_articles`, která:\n",
    "\n",
    "1. postupně projde elementy v proměnné `content` a nalezne v ní všechny značky pro články,\n",
    "2. články jednotlivě projde,\n",
    "3. v každém článku vyhledá nadpis, perex a odhadovanou dobu čtení článku,\n",
    "4. nadpis, perex a dobu čtení převede na holý text,\n",
    "5. tyto tři holé texty spojí do jednoho řetězce,\n",
    "6. řetězec připojí do seznamu `all_articles`,\n",
    "7. na výstup vrátí seznam `all_articles`, který obsahuje jednotlivé texty.\n",
    "\n",
    "**Poznámka:** Všimněte si, že ne všechny články mají uvedenou dobu čtení. Může se tedy stát, že vám v určité chvíli program spadne s chybovou hláškou. Pro vyřešení tohoto problému určitě budete potřebovat podmínku, která řekne, co se má stát, pokud doba čtení (ne)chybí."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73a70501",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_articles(content):\n",
    "    \"\"\" Stáhni nadpis, perex a dobu čtení článků. Články ulož do seznamu. \"\"\"\n",
    "    \n",
    "    all_articles = [] #vytvoř prázdný seznam\n",
    "    \n",
    "    for c in content: #pro každý box s články\n",
    "        #najdi oddíl, ve kterém se nachází článek\n",
    "        item = c.find_all('div', \n",
    "                          {'class': 'design-article--with-image design-article design-tile'})\n",
    "       \n",
    "        for i in item: #pro všechny tagy v oddíle s článkem\n",
    "            article = '' #vytvoř prázdný řetězec\n",
    "            \n",
    "            #najdi nadpis a holý text ulož do proměnné head\n",
    "            head = i.find('h3', {'class': 'element-heading-reset'}).get_text()\n",
    "            #najdi perex a holý text ulož do proměnné perex\n",
    "            perex = i.find('div', {'class': 'design-article__perex-content'}).get_text()\n",
    "            \n",
    "            #pokud je v oddíle doba čtení\n",
    "            if i.find('div', {'class': 'design-impressum__item'}):\n",
    "                #ulož holý text do proměnné time\n",
    "                time = i.find('div', {'class': 'design-impressum__item'}).get_text()\n",
    "            else: #pokud v oddíle doba čtení chybí\n",
    "                time = '\\nDoba čtení: nespecifikováno\\n' #ulož do proměnné text\n",
    "            \n",
    "            article = head + perex + time #spoj nadpis, perex a dobu čtení článku do jednoho řetězce\n",
    "            all_articles.append(article) #řetězec (článek) přidej do seznamu\n",
    "            \n",
    "    return all_articles #vrať seznam článků\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ff32833",
   "metadata": {},
   "source": [
    "Zavolejte funkci `get_articles` a její výstup uložte do proměnné `articles`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9255532",
   "metadata": {},
   "outputs": [],
   "source": [
    "articles = get_articles(content) #zavolej funkci get_articles a výsledek ulož do proměnné articles"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8f9981c",
   "metadata": {},
   "source": [
    "Iterujte přes seznam `articles` a jednotlivé články vypište."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10e25efe",
   "metadata": {},
   "outputs": [],
   "source": [
    "for a in articles: #pro každý článek v seznamu articles\n",
    "    print(a) #vypiš článek"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}