tokenizace_reseni.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "12fb326a",
   "metadata": {},
   "source": [
    "# Tokenizace\n",
    "\n",
    "V tomto notebooku si v několika krocích vytvoříte program pro tokenizaci textu. Budete k tomu potřebovat pouze základní metody Pythonu a modul re pro regulární výrazy.\n",
    "\n",
    "Tokenizace je jedním z běžných problémů zpracování přirozeného jazyka. S tokenizací se setkáte v korpusech, v syntéze řeči, během strojového učení apod. Jedná se o rozdělení textu na menší části, přičemž tyto části, kterým se říká tokeny, mohou být věty, slova, či jinak definované řetězce. Jelikož se jedná o běžnou součást NLP (zpracování přirozeného jazyka; z anglického Natural Language Processing), mohli byste předpokládat, že tokenizace patří mezi dobře popsané problémy, který není třeba řešit. Jak ale uvidíte dále, s tokenizací to není tak jednoduché a záleží na tom, pro co data zpracováváte a jak definujete samotné tokeny.\n",
    "\n",
    "Pro češtinu existuje např. nástroj [unitok](http://corpus.tools/wiki/Unitok).\n",
    "\n",
    "## 1 Problémy tokenizace\n",
    "\n",
    "Pokud se zaměříte na tokenizaci slov, musíte se rozhodnout, jak budete ke slovům přistupovat. Pokud narazíte na slovní spojení „Jižní Amerika“, budete jej tokenizovat jako dvě různá slova „Jižní“ a „Amerika“, nebo zvolíte variantu „Jižní Amerika“, jelikož tato dvě slova tvoří pojmenovanou entitu? Jak v anglickém textu budete tokenizovat „don't“? Přikloníte se k variantě „don't“, „do“ a „n't“, „do“ a „not“, nebo k úplně jiné variantě? Pokud narazíte na slovo „překladatel-tlumočník“, rozhodnete se ho ponechat se spojovníkem nebo rozdělit do slov „překladatel“ a „tlumočník“?  A co slovo „dvou-“ ve spojení „dvou‑ až třílůžkový pokoj“? Jak budete nakládat s daty, čísly, zkratkami, internetovými adresami, interpunkcí apod.?\n",
    "\n",
    "Seznam by mohl dále pokračovat. Z předchozích příkladů můžete vidět, že problémů definice tokenu je spousta, přičemž žádý z uvedených příkladů nemá jedno správné řešení, všechna uvedená řešení by byla vhodná v různých kontextech.\n",
    "\n",
    "V tomto notebooku nebude důležité vyřešit všechny tyto problémy. Zaměřte se pouze na ty, které lze jednoduše podchytit a které se vyskytují v textu, jenž budete tokenizovat.\n",
    "\n",
    "## 2 S čím budete pracovat\n",
    "\n",
    "### 2.1 re\n",
    "\n",
    "V tomto notebooku použijete modul re, který slouží pro práci s regulárními výrazy.\n",
    "\n",
    "Více informací na [re](https://docs.python.org/3/library/re.html) nebo [Programiz](https://www.programiz.com/python-programming/regex).\n",
    "\n",
    "Pro připomenutí regulárních výrazů vám může pomoct tento [cheatsheet](https://cheatography.com/davechild/cheat-sheets/regular-expressions/). Než výrazy implementujete do svého kódu, můžete si jejich funkčnost vyzkoušet např. na [regex101](https://regex101.com/) (nezapomeňte si v levém boxu přepnout flavor na Python).\n",
    "\n",
    "## 3 Instalace\n",
    "\n",
    "Modul re 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",
    "## 4 Import knihoven a modulů\n",
    "\n",
    "Než budete moct začít s psaním programu, musíte importovat všechny knihovny a moduly, které budete potřebovat. Patří mezi ně:\n",
    "\n",
    "- modul re.\n",
    "\n",
    "Spusťte následující buňku, modul re se importuje.\n",
    "\n",
    "**Poznámka:** Po každém zavření a otevření notebooku je nutné všechen kód (tj. i importování) spustit znovu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e316e380",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re #importuj modul re"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87fffb90",
   "metadata": {},
   "source": [
    "## 5 Jednoduchý tokenizátor\n",
    "\n",
    "Jednoduchý tokenizátor v Pythonu lze naprogramovat na třech řádcích díky metodě `split`. Text se poté rozdělí na slova pomocí mezer.\n",
    "\n",
    "Nejprve je nutné vyzvat uživatele k zadání textu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb852ece",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "text = input('Zadejte text pro tokenizaci: ') #vyzvi uživatele k zadání textu"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5f497c8",
   "metadata": {},
   "source": [
    "Text se poté tokenizuje pomocí metody `split`. Pokud této metodě není specifikováno, podle čeho má text rozdělit, použije k rozdělení slov mezeru. V tomto případě je toto chování vhodné, parametry metody tedy zůstanou prázdné."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3127f4c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = text.split() #rozděl text pomocí mezer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7efaa69a",
   "metadata": {},
   "source": [
    "Tokenizovaný text následně lze vypsat.\n",
    "\n",
    "**Poznámka:** Následujícím způsobem můžete text vypsat v prostředí Jupyter Notebook nebo v terminálu. Pokud budete programovat v jiných prostředích a tento způsob vám nebude fungovat, použijte standardní `print(text)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "153dbc60",
   "metadata": {},
   "outputs": [],
   "source": [
    "text #vypiš proměnnou text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ecdc849",
   "metadata": {},
   "source": [
    "Jak si můžete všimnout, text se tokenizoval, dokonce metoda `split` zbavila text počátečních mezer. Hlavní problém je ale s interpunkcí. Ve vašem tokenizátoru určitě nebudete chtít interpunkci jako součást předchozího slova, samotná metoda `split` vám tedy nebude stačit.\n",
    "\n",
    "V případě tokenizace není ideální ani uložení textu do proměnné přes metodu `input`. Zejména v případě, kdy budete tokenizovat dlouhé texty, se vám bude hodit jiný přístup, abyste text nemuseli kopírovat a následně jej vkládat.\n",
    "\n",
    "To stejné platí o přístupu k výslednému tokenizovanému textu. Může být výhodné jej nechat v proměnné a dále ho zpracovávat, měli byste ale také být schopni výstup uložit do souboru.\n",
    "\n",
    "Než budete upravovat váš tokenizátor, naučíte se, jak pomocí Pythonu pracovat se soubory. Uvidíte přepsání obsahu souboru a přidání dalších řádků textu. Zjistíte, jak vytvořit úplně nový soubor. V další sekci si v krátkosti zopakujete práci se seznamy. Následuje sekce o regulárních výrazech. V poslední sekci určené k opakování zjistíte, co jsou řezy.\n",
    "\n",
    "## 6 Práce se soubory\n",
    "\n",
    "### 6.1 Otevření souboru\n",
    "\n",
    "K otevření souboru v Pythonu slouží metoda `open`. Požaduje dva parametry:\n",
    "\n",
    "1. název souboru (pokud se soubor nachází ve stejné složce jako program, stačí pouze název s formátem, pokud se soubor nachází jinde, je nutné specifikovat celou cestu),\n",
    "2. mód, v jakém se soubor otevře (ve vašem případě `r`= read = ke čtení).\n",
    "\n",
    "Pokud si budete chtít otevření souboru vyzkoušet, zkontrolujte, že do příkazu níže zadáváte existující soubor s platnou cestou."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "190afda4",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = open('uryvek.txt', 'r') #otevři soubor ke čtení"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6cec7c9",
   "metadata": {},
   "source": [
    "Všimněte si, že metoda `open` sice otevře daný soubor a uloží jej do proměnné, nevypíše ale obsah souboru."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59cb42d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt #vypiš proměnnou txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ccfafae",
   "metadata": {},
   "source": [
    "### 6.2 Přečtení souboru\n",
    "\n",
    "K výpisu obsahu proměnné musíte použít metodu `read`, která přečte celý soubor (případně metodu `readlines`, která čte po jednom řádku)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "856d4797",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt2 = txt.read() #přečti obsah proměnné txt2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd63ca1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt2 #vypiš proměnnou txt2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e2e251f",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt3 = txt.readlines(1) #přečti jeden řádek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1986016",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt3 #vypiš proměnnou txt3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "302e1858",
   "metadata": {},
   "source": [
    "#### 6.2.1 Iterace přes řádky\n",
    "\n",
    "Díky metodě `readlines` je navíc možné přes řádky v textu iterovat ve for cyklu postupně a dále s nimi pracovat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15d6346f",
   "metadata": {},
   "outputs": [],
   "source": [
    "line_num = 0 #vytvoř novou proměnnou pro počítání řádků\n",
    "\n",
    "for line in txt.readlines(): #iteruj přes každý řádek v textu\n",
    "    line_num += 1 #zvyš číslo řádku o jedna\n",
    "    print(line_num, line) #vypiš číslo řádku a celý řádek"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5840743b",
   "metadata": {},
   "source": [
    "### 6.3 Zavření souboru\n",
    "\n",
    "K zavření souboru slouží metoda `close`. Zavírání souborů je dobrou praxí, která vám zaručí, že si nepoškodíte soubory, se kterými pracujete. Více na [Stack Overflow](https://stackoverflow.com/questions/7395542/is-explicitly-closing-files-important).\n",
    "\n",
    "**Poznámka:** Pokud proměnnou přepíšete, tj. proměnná již neobsahuje samotný soubor, ale např. text uložený v řetězci, zavřít soubor vám nepůjde."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "611e9d7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt.close() #zavři soubor uložený v proměnné txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "513bbc91",
   "metadata": {},
   "source": [
    "#### 6.3.1 With open\n",
    "\n",
    "Metoda `with open` se o zavření souboru postará automaticky. Více třeba ve vláknu na [Stack Overflow](https://stackoverflow.com/questions/9282967/how-to-open-a-file-using-the-open-with-statement).\n",
    "\n",
    "### 6.4 Zápis do již existujícího souboru\n",
    "\n",
    "Pokud chcete do souboru i zapisovat, musíte změnit mód, ve kterém soubor otevřete. V sekci 6.1 byl použit mód `r` (ke čtení). Pro zápis si můžete vybrat ze dvou módů:\n",
    "\n",
    "1. `a` = append = další text připojí na konec souboru\n",
    "2. `w` = write = přepíše existující obsah souboru"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c6acb00",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = open('uryvek.txt', 'a') #otevři soubor v módu append"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5161b030",
   "metadata": {},
   "source": [
    "Po použití těchto dvou módů můžete použít metodu `write` k zápisu dalších řetězců do souboru."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62e78f5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt.write('Nový text') #zapiš do souboru txt řetězec Nový text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e574e72a",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt.read() #přečti obsah proměnné txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c6e9d84",
   "metadata": {},
   "source": [
    "### 6.5 Vytvoření nového souboru\n",
    "\n",
    "K vytvoření nového souboru neexistuje specifická funkce, použijte metodu `open` s některým ze třech módů: `x`, `a`, `w`. \n",
    "\n",
    "S `a` a `w` jste se setkali v předchozí podkapitole. Jejich použití od nového módu `x` = create se liší v chybových hláškách. Módy `a` a `w` vytvoří nový soubor pouze, pokud ještě neexistuje. Pokud soubor se stejným jménem existuje, nestane se nic, ale nedostanete ani chybovou hlášku. Oproti tomu mód `x` vytvoří nový soubor pouze pokud soubor se stejným jménem ještě neexistuje. Ale pokud takový soubor existuje, dostanete chybovou hlášku."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a73bb9ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = open('uryvek2.txt', 'w') #vytvoř nový soubor pomocí módu write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ae3fb73",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = open('uryvek2.txt', 'a') #vytvoř nový soubor pomocí módu append (soubor již existuje, nic se nestane a\n",
    "                               #a ani nedostaneme chybovou hlášku)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3a0e1d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = open('uryvek2.txt', 'x') #vytvoř nový soubor pomocí módu create (soubor již existuje, dostaneme chybovou\n",
    "                               #hlášku)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1279197a",
   "metadata": {},
   "source": [
    "Přehled všech metod a módů práce se souboru naleznete např. na [Geeks for Geeks](https://www.geeksforgeeks.org/writing-to-file-in-python/).\n",
    "\n",
    "## 7 Seznamy\n",
    "\n",
    "V tomto úkolu využijete datový typ seznam, do kterého je možné uložit několik položek. Python umožňuje, aby tyto položky nebyly stejného datového typu (do jednoho seznamu tedy můžete uložit jak celé číslo, řetězec, tak slovník), ale je silně doporučováno, aby se datové typy uvnitř seznamu nemíchaly. Seznamy jsou uspořádané, měnitelné, umožňují ukládat duplicity a jsou indexované. Pozor, první položka má index 0.\n",
    "\n",
    "Prázdný seznam vytvoříte pomocí hranatých závorek nebo konstruktoru."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47881dab",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [] #vytvoř nový seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78fb68b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst2 = list() #vytvoř nový seznam"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79b87bac",
   "metadata": {},
   "source": [
    "Položky do seznamu přidáte pomocí metody `append`. Nová položka se přidá vždy na konec seznamu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a3993cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append(1) #přidej do seznamu jedničku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f35a3af4",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst #vypiš proměnnou lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d77f0431",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append(2) #přidej do seznamu dvojku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1fbccce",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst #vypiš proměnnou lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eb0c99e",
   "metadata": {},
   "source": [
    "Pokud byste potřebovali novou položku přidat na konkrétní místo, použijte metodu `insert`. Ta požaduje dva parametry:\n",
    "1. index, kam se má položka v seznamu umístit,\n",
    "2. položku."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12af8475",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.insert(1, 8) #přidej do seznamu osmičku na index 1 (tj. druhé místo v seznamu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e59986ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst #vypiš proměnnou lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48ad92da",
   "metadata": {},
   "source": [
    "Index zjistíte pomocí metody `index`. Do parametru metody zadejte položku, jejíž index chcete vyhledat. Pokud se v seznamu položka vyskytuje, funkce vám vrátí číslo indexu. Pokud se v seznamu položka nevyskytuje, metoda skončí chybovou hláškou `ValueError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06164927",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.index(8) #vypiš, na kterém indexu se nachází osmička"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e27de562",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.index(3) #vypiš, na kterém indexu se nachází trojka"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a74e84d2",
   "metadata": {},
   "source": [
    "Pro odstranění položky slouží metoda `remove`. Pokud se v seznamu vyskytuje více stejných položek, odstraní se vždy pouze první položka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6815dde2",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.remove(8) #odstraň ze seznamu osmičku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eca057db",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst #vypiš proměnnou lst"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2957ac2b",
   "metadata": {},
   "source": [
    "Další informace k datovému typu seznam, užitečné metody a jejich detailní popis naleznete v [dokumentaci](https://docs.python.org/3/tutorial/datastructures.html).\n",
    "\n",
    "## 8 Regulární výrazy\n",
    "\n",
    "Regulární výrazy slouží jako vzor pro vyhledávání v textu. V Pythonu díky knihovně re a různým funkcím můžete textové řetězce nejen vyhledávat, ale i modifikovat nebo je nahrazovat za jiné řetězce. V tokenizátoru využijete hlavně vyhledávání, pokud budete chtít nalézt např. interpunkci.\n",
    "\n",
    "K vyhledávání slouží v Pythonu funkce `search`. Tato funkce požaduje dva parametry, regulární výraz a text, ve kterém se má vyhledávat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a595d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "sent = 'Jasno nebo skoro jasno.' #ulož tetxový řetězec do proměnné\n",
    "sent2 = 'Maximální teploty 10 až 14 °C. ' #ulož textový řetězec do proměnné"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bed41a8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "reg = re.search(r'\\d', sent) #vyhledej první číslici v textu sent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4759b850",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(reg) #vypiš proměnnou reg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e205a94",
   "metadata": {},
   "outputs": [],
   "source": [
    "reg = re.search(r'\\d', sent2) #vyhledej první číslici v textu sent2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19d88a06",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(reg) #vypiš proměnnou reg"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1f28eaf",
   "metadata": {},
   "source": [
    "Pokud funkce `search` nenalezne text, který by korespondoval s regulárním výrazem, vrátí hodnotu `None`. Pokud naopak nalezne shodu, vrátí index prvního výskytu (`span`) a kolikrát se daný výraz v textu vyskytuje (`match`). V případě, že budete chtít nalézt všechny textové řetězce, nejenom první, musíte použít funkci `findall`.\n",
    "\n",
    "Efektivnějším způsobem, jak pracovat s regulárními výrazy, je uložit si je do proměnné. A to zejména, pokud stejné výrazy používáte na různých místech v kódu. Výraz pak v řešení musíte změnit pouze jednou. K tomu slouží funkce `compile`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2c03da0",
   "metadata": {},
   "outputs": [],
   "source": [
    "pattern = re.compile(r'\\d') #zkompiluj regulární výraz pro vyhledání číslic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "feb8affc",
   "metadata": {},
   "outputs": [],
   "source": [
    "reg2 = re.findall(pattern, sent2) #vyhledej všechny číslice v texti sent2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b654d4c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(reg2) #vypiš proměnnou reg2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f2125c3",
   "metadata": {},
   "source": [
    "**Poznámka:** r ve výrazu `r'\\d'` slouží v Pythonu k upřesnění, že se nejedná o běžný řetězec, ale regulární výraz. V některých případech vám regulární výrazy budou fungovat i bez r, je ale lepší jej před výrazem použít.\n",
    "\n",
    "Další funkce naleznete v [dokumentaci ke knihovně re](https://docs.python.org/3/library/re.html), další informace a užitečné odkazy naleznete v sekci 3 tohoto notebooku.\n",
    "\n",
    "## 9 Řezy\n",
    "\n",
    "Ne vždy jsou regulární výrazy vhodnou volbou k řešení jednoduchého problému. Např. pro získání interpunkce, která je připojená k předchozímu slovu, je výhodnější (a zejména rychlejší) použít řezy namísto regulárních výrazů.\n",
    "\n",
    "Řezy umožňují vybrat část z řetězce či seznamu podle určitého kritéria specifikovaného indexy. V tomto notebooku je důležité rozumět řezům řetězců.\n",
    "\n",
    "Zapisují se následujícím způsobem: `řetězec[začátek:konec:krok]`, přitom není vždy nutné specifikovat všechny součásti řezu (tj. je možné vynechat např. počáteční index). Podívejte se na následující ukázky a na [Stack Overflow](https://stackoverflow.com/questions/509211/understanding-slicing) pro detailní popis.\n",
    "\n",
    "**Poznámka:** Python jak řetězce, tak seznamy indexuje od nuly, tj. první prvek má vždy index 0, ne 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e18d81fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "w = 'autobus' #ulož textový řetězec do proměnné w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd65fc87",
   "metadata": {},
   "outputs": [],
   "source": [
    "w[2:5] #vypiš třetí až páté písmeno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c40c78b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "w[-3:] #vypiš všechna písmena začínající třetím písmenem od konce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1abd84f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "w[:4] #vypiš všechna písmena až do čtvrtého"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1091adef",
   "metadata": {},
   "outputs": [],
   "source": [
    "w[1:5:2] #vypiš každé druhé písmeno, začni na druhém písmeni a skonči na pátém"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c09e580f",
   "metadata": {},
   "source": [
    "## 10 Tokenizátor s použitím regulárních výrazů\n",
    "\n",
    "V této sekci budete mít za úkol naprogramovat tokenizátor používající regulární výrazy k tokenizaci. Než se pustíte do programování, připomeňte si práci s knihovnou re a regulárními výrazy (užitečné odkazy jsou k dispozici v sekci 3 tohoto notebooku).\n",
    "\n",
    "**Úkol:** Vytvořte program, který načte data ze souboru, tokenizuje text a výsledek uloží do nového souboru.\n",
    "\n",
    "Pracujte buď s ukázkovým textem, nebo si najděte vlastní. Vyberte ale vhodný text, který obsahuje alespoň přímou řeč, závorky, čísla s desetinnou čárkou/tečkou, zkratky, případně další problémy, které si vyberete. Text můžete slepit i z vícero zdrojů.\n",
    "\n",
    "Použijte regulární výrazy k nalezení těchto problémů a rozhodněte se, jak je budete řešit (např. budou závorky a uvozovky samostatné tokeny?). Váš přístup musí být konstatní pro celý text.\n",
    "\n",
    "Program vhodně rozdělte na funkce."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d78ffa9a",
   "metadata": {},
   "source": [
    "<details> \n",
    "    <summary>Pokud nevíte, jak začít, klikněte na tento text pro <b>zobrazení nápovědy</b>.</summary>\n",
    "    <p><b>Nápověda:</b></p>\n",
    "    <p>Vytvořte funkci, která otevře soubor a uloží obsah souboru (text) do proměnné.</p>\n",
    "    <p>Rozdělte text pomocí mezer a metody split na jednotlivé tokeny.</p>\n",
    "    <p>Použijte regulární výrazy k nalezení interpunkce, závorek, uvozovek apod. v tokenech.</p>\n",
    "    <p>K oddělení např. interpunkce od slov můžete použít řezy. Více informací o řezech naleznete třeba na <a href=\"https://stackoverflow.com/questions/509211/understanding-slice-notation\">Stack Overflow</a>.</p>\n",
    "    <p>Výsledný tokenizovaný text uložte ve vhodném formátu do nového souboru.</p>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2f79f9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(data):\n",
    "    \"\"\" Otevři textový soubor a obsah ulož do proměnné. Znaky pro nový řádek nahraď za mezery.\"\"\"\n",
    "\n",
    "    with open(data, 'r') as raw: #otevři textový soubor\n",
    "        raw = raw.read() #ulož obsah textového souboru do proměnné raw\n",
    "        raw = raw.replace('\\n', ' ') #nahraď znak pro nový řádek za mezeru\n",
    "        \n",
    "    return raw #vrať proměnnou data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac1dfb7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def punctuation(data):\n",
    "    \"\"\" Rozděl text podle mezer a tokenizuj interpunkci na konci vět. \"\"\"\n",
    "    \n",
    "    #Regulární výrazy\n",
    "    abbr = re.compile(r'\\b(?:[A-Za-z]\\.)+|\\b(?:[A-Z][a-z]{1,2}\\.)+|(?:[A-Z]\\.)+') #zkratky\n",
    "    ords = re.compile(r'\\d+\\.') #řadové číslovky\n",
    "    end_punct = re.compile(r'[\\.\\?\\!\\:\\,]$') #interpunkce na konci vět\n",
    "\n",
    "    #Tokenizace\n",
    "    data = data.split() #rozděl slova podle mezer\n",
    "    \n",
    "    for tok in data: #pro každý token v seznamu\n",
    "        where = data.index(tok) #ulož index tokenu v seznamu\n",
    "        \n",
    "        if re.search(end_punct, tok) and len(tok) > 1 and not re.search(abbr, tok) and not re.search(ords, tok):\n",
    "            #vyhledej interpunkci na konci vět a čárky za slovy\n",
    "            token1 = tok[:-1] #ulož samotné slovo\n",
    "            end = tok[-1] #ulož samotné interpunkční znaménko\n",
    "            data.remove(tok) #odstraň ze seznamu původní token\n",
    "            data.insert(where, token1) #vlož do seznamu samotné slovo\n",
    "            data.insert(where+1, end) #za samotné slovo v seznamu vlož samotné interpunkční znaménko\n",
    "            \n",
    "    return data #vrať tokenizovaný text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c1d454a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def brackets(data):\n",
    "    \"\"\" Tokenizuj závorky, uvozovky a další interpunkci jako samostatné tokeny \"\"\"\n",
    "    \n",
    "    #Regulární výrazy\n",
    "    end_br = re.compile(r'[\\.\\?\\!\\,]+[\\)\\]\\}\\'\\\"\\“]') #interpunkce uvnitř závorek a uvozovek\n",
    "    brq_front = re.compile(r'^[\\\"\\[\\(\\{\\'\\„]') #levé závorky a uvozovky\n",
    "    brq_back = re.compile(r'\\\"|\\]|\\)|\\}|\\'|\\“') #pravé závorky a uvozovky\n",
    "    \n",
    "    for tok in data: #pro každý token v seznamu\n",
    "        where = data.index(tok) #ulož index tokenu v seznamu\n",
    "\n",
    "        if re.search(end_br, tok) and len(tok) > 1:\n",
    "            #vyhledej interpunkční znaménka uvnitř závorek nebo uvozovek\n",
    "            token1 = tok[:-2] #ulož samotné slovo\n",
    "            end1 = tok[-2] #ulož samotné interpunkční znaménko\n",
    "            end2 = tok[-1] #ulož samotnou závorku nebo samotné uvozovky\n",
    "            data.remove(tok) #odstraň ze seznamu původní token\n",
    "            data.insert(where, token1) #na index původního tokenu ulož samotné slovo\n",
    "            data.insert(where+1, end1) #na následující index ulož samotné interpunkční znaménko\n",
    "            data.insert(where+2, end2) #na následující index ulož samotnou závorku nebo samotné uvozovky\n",
    "            \n",
    "        elif re.search(brq_front, tok) and len(tok) > 1:\n",
    "            #vyhledej levé závorky nebo uvozovky\n",
    "            token2 = tok[1:] #ulož slovo za závorkou nebo uvozovkami\n",
    "            brq = tok[0] #ulož samotnou závorku nebo uvozovky\n",
    "            data.remove(tok) #odstraň ze seznamu původní token\n",
    "            data.insert(where, brq) #na index původního tokenu ulož samotnou závorku nebo samotné uvozovky\n",
    "            data.insert(where+1, token2) #na následující index ulož samotné slovo\n",
    "        \n",
    "        elif re.search(brq_back, tok) and len(tok) > 1:\n",
    "            #vyhledej pravé závorky nebo uvozovky\n",
    "            token1 = tok[:-1] #ulož samotné slovo před závorkou nebo uvozovkami\n",
    "            brq = tok[-1] #ulož samotnou závorku nebo samotné uvozovky\n",
    "            data.remove(tok) #odstraň ze seznamu původní token\n",
    "            data.insert(where, token1) #na index původního tokenu ulož samotné slovo\n",
    "            data.insert(where+1, brq) #na následující index ulož samotnou závorku nebo samotné uvozovky\n",
    "                        \n",
    "    return data #vrať tokenizovaný text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4dffeef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_tokenized_text(tokenized_text, file_name):\n",
    "    \"\"\" Ulož tokenizovaný text do souboru \"\"\"\n",
    "    \n",
    "    with open(file_name, 'a') as txt: #vytvoř nový soubor v módu append\n",
    "        for tok in tokenized_text: #každý token v seznamu\n",
    "            txt.write(tok + '\\n') #zapiš do souboru na nový řádek\n",
    "            \n",
    "    return 0 #úspěšné ukončení fce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4adb2fbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize(text):\n",
    "    \"\"\" Tokenizuj text a ulož jej do souboru \"\"\"\n",
    "    \n",
    "    text = prepare_data(text) #zavolej funkci prepare_data\n",
    "    print('Příprava dat...')\n",
    "    \n",
    "    text = punctuation(text) #zavolej funkci punctuation\n",
    "    print('Tokenizace...')\n",
    "    \n",
    "    text = brackets(text) #zavolej funkci brackets\n",
    "    \n",
    "    save_tokenized_text(text, 'tokenized.txt') #zavolej funkci save_tokenized_text\n",
    "    print('Ukládání tokenizovaného textu do souboru tokenized.txt...')\n",
    "    \n",
    "    print('Hotovo.')\n",
    "    return 0 #úspěšné ukončení fce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b6f1ba0",
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenize('text.txt') #spusť funkci tokenize, tokenizuj soubor text.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28ea64e2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}