{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podívejme se v rychlosti, jak Python pracuje s řetězci a se soubory. Ukážeme si základní principy a jednoduché příklady.\n",
    "<!-- TEASER_END -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Řetězce -- Python str\n",
    "S řetězci jsme se už setkali mnohokrát, řekli jsme si také, že `str` objekt je immutable (neměnitelný). V rychlosti teď shrneme základy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "řetězce jsou ve dvojitých\n"
     ]
    }
   ],
   "source": [
    "print(\"řetězce jsou ve dvojitých\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nebo jednoduchých uvozovkách, tj. \" nebo '\n"
     ]
    }
   ],
   "source": [
    "print('nebo jednoduchých uvozovkách, tj. \" nebo \\'')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "řetězce spojíme operátorem +\n"
     ]
    }
   ],
   "source": [
    "print('řetězce spojíme ' + 'operátorem +')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ můžeme případně vynechat, takže dlouhé řetězce můžeme rozložitdo více řádků, nejlépe uvnitř závorek\n"
     ]
    }
   ],
   "source": [
    "print('+ můžeme případně vynechat, '\n",
    "      'takže dlouhé řetězce můžeme rozložit'\n",
    "      'do více řádků, nejlépe uvnitř závorek')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python podporuje unicode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Τὴ γλῶσσα μοῦ ἔδωσαν ἑλληνικὴ\n"
     ]
    }
   ],
   "source": [
    "print(\"Τὴ γλῶσσα μοῦ ἔδωσαν ἑλληνικὴ\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\[\\frac{{\\partial \\psi }}{{\\partial R}}\\]\n"
     ]
    }
   ],
   "source": [
    "# pokud chceme psát spoustu speciálních znaků, např. \\, použijeme r\" ...\"\n",
    "# to se hodí třeba pro LaTeX\n",
    "print(r\"\\[\\frac{{\\partial \\psi }}{{\\partial R}}\\]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "řetězce podporují řezy\n"
     ]
    }
   ],
   "source": [
    "s = \"řřeettěězzccee  ppooddppoorruujjíí  řřeezzyy\"\n",
    "print(s[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "řetězce lze násobit násobit násobit \n"
     ]
    }
   ],
   "source": [
    "s = \"řetězce lze \" + 3 * \"násobit \"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### f-strings\n",
    "\n",
    "Python 3.6 zavedl moderní způsob formátování řetězců pomoci tzv. [f-strings](https://docs.python.org/3/reference/lexical_analysis.html#f-strings). Syntaxe je velice jednoduchá: před první uvozovky vložit znak `f` a pak všechny výrazy uvnitř `{složených závorek}` nahradit jejich textovou reprezentací.\n",
    "\n",
    "Např.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Eric. You are 74.'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = \"Eric\"\n",
    "age = 74\n",
    "f\"Hello, {name}. You are {age}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2 * 37 = 74'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"2 * 37 = {2 * 37}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Můžeme volat i metody / funce:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'eric idle is funny.'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = \"Eric Idle\"\n",
    "f\"{name.lower()} is funny.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Výrazy se dají formátovat pomocí [formátovacího mini-jazyka](https://docs.python.org/3/library/string.html#formatspec):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'result:      12.35'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import decimal\n",
    "\n",
    "value = decimal.Decimal(\"12.34567\")\n",
    "width = 10\n",
    "precision = 4\n",
    "\n",
    "f\"result: {value:{width}.{precision}}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Taday is November 05, 2019'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datetime as dt\n",
    "\n",
    "today = dt.date.today()\n",
    "f\"Taday is {today:%B %d, %Y}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existují ještě dva starší (zastaralé) způsoby formátování: pomocí `%` operátoru a pomocí `format` metody. Doporučení je používat už jen f-strings, případně [`string.Template`](https://docs.python.org/3/library/string.html#template-strings). Viz např. https://realpython.com/python-string-formatting/#which-string-formatting-method-should-you-use.\n",
    "\n",
    "<img src=\"./python-string-formatting-flowchart.4ecf0148fd87.png\" alt=\"python string formatting flowchart\" style=\"width:400px;\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metody třídy `str`\n",
    "Výpis \"veřejných\" metod `str`, k němuž použijeme `join` pro vytvoření řetězce z iterátoru a `startswith` pro test začátku řetězce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'capitalize, casefold, center, count, encode, endswith, expandtabs, find, format, format_map, index, isalnum, isalpha, isascii, isdecimal, isdigit, isidentifier, islower, isnumeric, isprintable, isspace, istitle, isupper, join, ljust, lower, lstrip, maketrans, partition, replace, rfind, rindex, rjust, rpartition, rsplit, rstrip, split, splitlines, startswith, strip, swapcase, title, translate, upper, zfill'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\", \".join([m for m in dir(\"\") if not m.startswith(\"_\")])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mezery apod. ořízneme pomocí `strip`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  \t abc\n",
      "\n",
      "\n",
      "abc\n"
     ]
    }
   ],
   "source": [
    "s = \"  \\t abc\\n\\n\"\n",
    "print(s)\n",
    "print(s.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Často se hodí split, je to vlastně opak join."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', ' 2', ' 3', ' čtyři', ' 5']\n",
      "[1, 2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "s = \"1, 2, 3, čtyři, 5\"\n",
    "# rozdílema na částí oddělené čárkou\n",
    "s = s.split(\",\")\n",
    "print(s)\n",
    "# zkusíme převést na čísla\n",
    "s = [int(a) for a in s if a.strip().isdigit()]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Velikost písmen mění `upper`, `lower`, `capitalize`, `swapcase`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "VŠECHNA PÍSMENA VELKÁ\n"
     ]
    }
   ],
   "source": [
    "print(\"všechna písmena velká\".upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Základy práce se soubory\n",
    "Pro práci se sounory je základní příkaz `open`, který vrací instanci `file`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.TextIOWrapper name='./150_prace-s-retezci-a-se-soubory.ipynb' mode='r' encoding='UTF-8'>\n"
     ]
    }
   ],
   "source": [
    "f = open(\"./150_prace-s-retezci-a-se-soubory.ipynb\", \"r\")\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'buffer, close, closed, detach, encoding, errors, fileno, flush, isatty, line_buffering, mode, name, newlines, read, readable, readline, readlines, reconfigure, seek, seekable, tell, truncate, writable, write, write_through, writelines'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# metody file\n",
    "\", \".join([m for m in dir(f) if not m.startswith(\"_\")])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# teď soubor zavřeme\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nejčastější je procházet soubor jako iterátor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: {\n",
      "1:  \"cells\": [\n",
      "2:   {\n",
      "3:    \"cell_type\": \"mar\n",
      "4:    \"metadata\": {},\n",
      "5:    \"source\": [\n",
      "6:     \"Podívejme se v\n",
      "7:     \"<!-- TEASER_END\n",
      "8:    ]\n",
      "9:   },\n",
      "10:   {\n"
     ]
    }
   ],
   "source": [
    "f = open(\"./150_prace-s-retezci-a-se-soubory.ipynb\", \"r\")\n",
    "\n",
    "# print first 10 lines with line numbers and max 20 characters per line\n",
    "for count, line in enumerate(f):\n",
    "    print(f\"{count}: {line[:20].rstrip()}\")\n",
    "    if count == 10:\n",
    "        break\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pro práci se soubory je velice užitečný (*a jednoznačně preferevaný*) blok [`with`](https://docs.python.org/3/reference/compound_stmts.html#with), který používá tzv. context managery. To nám zajistí, že soubor bude vždy zavřen, i když během práce se souborem dojde k chybě (neodchycená výjimka). Nahrazuje to tak `try..except..finally` blok. \n",
    "\n",
    "Použití je velice jednoduché, předchozí příklad by vypadal takto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: {\n",
      "1:  \"cells\": [\n",
      "2:   {\n",
      "3:    \"cell_type\": \"mar\n",
      "4:    \"metadata\": {},\n",
      "5:    \"source\": [\n",
      "6:     \"Podívejme se v\n",
      "7:     \"<!-- TEASER_END\n",
      "8:    ]\n",
      "9:   },\n",
      "10:   {\n"
     ]
    }
   ],
   "source": [
    "with open(\"./150_prace-s-retezci-a-se-soubory.ipynb\", \"r\") as f:\n",
    "    # print first 10 lines with line numbers and max 20 characters per line\n",
    "    for count, line in enumerate(f):\n",
    "        print(f\"{count}: {line[:20].rstrip()}\")\n",
    "        if count == 10:\n",
    "            break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Všimněte si, že chybí explicitní volání `f.close()`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}