data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Práce s dat(ovými typ)y\n",
    "================\n",
    "\n",
    "Konverze datových typů\n",
    "-----------------------------------\n",
    "\n",
    "Python **neprovádí automatickou typovou konverzi** a proto se o ni mus\n",
    "postarat programátor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-89b0d6b4af2b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m5\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'3'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "5 + '3'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + float('3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Každý datový typ má svou funkci, které se pokusí převést předložený data na\n",
    "svůj vlastní datový typ. Někdy to možné je. Jindy to možné není. Pokud to možn\n",
    "není dojde k běhové chybě. \n",
    "\n",
    " * `int()`\n",
    " * `float()`\n",
    " * `bool()`\n",
    " * `comlex()`\n",
    " * `str()`\n",
    " * `tuple()`\n",
    " * `list()`\n",
    " * `set()`\n",
    " * `ditct()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pravda je všechno co není nula nebo prázdny seznam. Bacha na `'0'`, to je totiž pravda!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('ahoj')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '5.1'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-029fb4b7dc63>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'5.1'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '5.1'"
     ]
    }
   ],
   "source": [
    "int('5.1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(5.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(5.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`int` nám usekával ale nezaokrouhloval."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('5.1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.9"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('5.9')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5+0j)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " complex('5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.14+0j)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complex(3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.1415'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(3.1415)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(3+5j)'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(3+5j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "decoding str is not supported",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-671e879e75b8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'b'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'c'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: decoding str is not supported"
     ]
    }
   ],
   "source": [
    "str('a','b','c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"['a', 'b', 'c']\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str( ['a','b','c'] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'h', 'o', 'j', ' ', 'K', 'a', 'r', 'l', 'e')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " tuple('ahoj Karle')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'h', 'o', 'j', ' ', 'K', 'a', 'r', 'l', 'e']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " list('ahoj Karle')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['H', 'A', 'C']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list( {\"A\", \"H\", \"C\"} )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A', 'B', 'C'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set('ABC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict([ ('a',1), ('b',2)  ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = dict([ ('a',1), ('b',2) , ('c',3) ])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " d['c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vícerozměrné seznamy a tečková notace\n",
    "\n",
    "### Odkazy, ukazatele\n",
    "\n",
    "Pokud v Pythonu vytváříme nějaké kolekci jako je `tuple()`, `list()`, `set()`\n",
    "nebo `dict()` jedná se vždy pouze o kolekci ukazatelů. **Z nepochopení toho\n",
    "principu vyplývá zdánlivě nelogické chování, které Python vykazuje.** Proto mu\n",
    "prosím věnujte pozornost:\n",
    "\n",
    "[jedna]: http://pythontutor.com/visualize.html#code=x%20%3D%20%5B0,1,%202,%203,%204%20,5%20%5D%0Ay%20%3D%20tuple%28'abcd'%29%0A%0Aseznam%20%3D%20%5Bx,%20y,%203.1415,%20'slovo'%5D%0A%0Aslovnik%20%3D%20%7B%7D%0Aslovnik%5B'cisla'%5D%20%3D%20x%0Aslovnik%5B'pismena'%5D%20%3D%20y%0A%0A%23zmenim%20cislo%20v%20x%0Ax%5B2%5D%3D'dvojka'%0A%23%20a%20ono%20se%20zmeni%20jak%20v%20senamu%20...%0Aprint%28seznam%29%0A%23%20...%20tak%20ve%20slovniku%0Aprint%28slovnik%29&cumulative=false&curInstr=9&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\n",
    "\n",
    "[![pythontutor.com](pythontutor1.png )][jedna]\n",
    "\n",
    "Protože kolekce uchovávají odkazy můžeme do nich uložit libovolný datový typ a\n",
    "vytvářet libovolné datové struktury libovolné hloubky. Pokud chceme k\n",
    "jednotlivým položkám přistupovat použijeme hranaté závorky `[...]`.\n",
    "\n",
    "[dva]: http://pythontutor.com/visualize.html#code=x%20%3D%20%5B0,1,%202,%203,%204%20,5%20%5D%0Ay%20%3D%20tuple%28'abcd'%29%0A%0Al%20%3D%20%5Bx,%20y,%203.1415,%20'slovo'%5D%0A%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0Aprint%28l%5B2%5D%29%0Aprint%28l%5B0%5D%5B2%5D%29%0Al%5B0%5D%5B2%5D%20%3D%20'dvojka'%0Aprint%28x%5B2%5D%29%0A%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0Ad%3D%7B%7D%0Ad%5B'prva'%5D%20%3D%20l%0Ad%5B'druha'%5D%20%3D%20x%0A%0Aprint%28d%5B'prva'%5D%29%0Aprint%28d%5B'prva'%5D%5B0%5D%29%0Aprint%28d%5B'prva'%5D%5B0%5D%5B2%5D%29&cumulative=false&curInstr=13&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\n",
    "\n",
    "[V této ukázce][dva] je proměnná `l`. Ta obsahuje odkazy na seznamy. Takže\n",
    "`l[0]` je seznam, na která ukazuje nultá položka `l`. `l[0][2]` je druhá položka\n",
    "seznamu `x`, na který ukazuje nultá položka `l`. :-)\n",
    "\n",
    "[![pythontutor.com](pythontutor2.png)][dva]\n",
    "\n",
    "------------------------------------------------\n",
    "\n",
    "V Pythonu lze pomocí tečky `.` přistoupit k metodám daného datového typu. To už\n",
    "známe:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ahoj'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s='   ahoj   '\n",
    "s.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   AHOJ   '"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ale návratovou hodnotou metody `.strip()` je opět řetězec. Proto lze psát rovnou\n",
    "\n",
    "\n",
    "Podobně tomu může být pokud vnoříme seznamy, nebo do seznamu vložíme řetězec.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AHOJ'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.strip().upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobně tomu může být pokud vnoříme seznamy, nebo do seznamu vložíme řetězec."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [0,1, 2, 3, 4 , 5 ]\n",
    "y = ['abcd','Ahoj', 'slovo']\n",
    "l = [x,y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'slovo'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[1].pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AHOJ'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[1].pop().upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abcd']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aHOJ'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam=[7,3.1415,\"Ahoj\"]\n",
    "seznam[2].swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam[2].swapcase().index('H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kopírování kolekcí\n",
    "\n",
    "### Mělká kopie\n",
    "\n",
    "Jak bylo řečeno, všechny proměnné v Pythonu uchovávají pouze odkazy na objekty.\n",
    "To se pokouší demonstrovat [tato ukázka][tri].\n",
    "\n",
    "[tri]: http://pythontutor.com/visualize.html#code=a%20%3D%20%5B'ahoj',%20'nazdar',%20'hello'%5D%0Ab%20%3D%20a%0A%20%20%20%20%0Ab%5B2%5D%20%3D%20'ciao'%0Aprint%28a%29%0Aprint%28b%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\n",
    "\n",
    "\n",
    "\n",
    "[![pythontutor.com](pythontutor3.png)][tri]\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['ahoj', 'nazdar', 'hello']\n",
    "b = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Změním sice proměnnou `b` ale změna proběhne i uvnitř `a` protože `a` i `b`\n",
    "ukazuje na stejný objekt. Proto pokud chceme vytvořit skutečnou kopii (říká se\n",
    "jí mělká kopie) použijeme výřez, který vyřeže všechny prvky. Při výřezu toti\n",
    "vždy vzniká nový objekt.\n",
    "\n",
    "[ctyri]: http://pythontutor.com/visualize.html#code=a%20%3D%20%5B'ahoj',%20'nazdar',%20'hello'%5D%0Ab%20%3D%20a%5B%3A%5D%0A%20%20%20%20%0Ab%5B2%5D%20%3D%20'ciao'%0Aprint%28a%29%0Aprint%28b%29&cumulative=false&curInstr=2&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\n",
    "\n",
    "[![pythontutor.com](pythontutor4.png)][ctyri]\n",
    "\n",
    "[V další ukázce][ctyri] je změna oproti předchozí pouze na řádku `2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['ahoj', 'nazdar', 'hello']\n",
    "b = a[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[pet]: http://pythontutor.com/visualize.html#code=ovoce%20%3D%20%5B'jablko',%20'hru%C5%A1ka',%20'broskev'%5D%0Azelenina%20%3D%20%5B'zel%C3%AD',%20'kedlub',%20'paprika'%5D%0A%0Ajidlo%20%3D%20%5Bovoce,%20zelenina%5D%0Afood%20%3D%20jidlo%5B%3A%5D%0A%0Afood%5B1%5D%5B1%5D%20%3D%20'kapusta'%0Aprint%28jidlo%5B1%5D%5B1%5D%29&cumulative=false&curInstr=6&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\n",
    "\n",
    "\n",
    "#### Hluboká kopie\n",
    "\n",
    "Jsou ale [situace][pet], kdy si s mělkou kopií nevystačíme. Například u vícerozměrných\n",
    "seznamů. Vytvoříme sice nový seznam (`list`), ale jsou v něm ty stejné odkazy na\n",
    "ty stejné původní objekty.\n",
    "\n",
    "\n",
    "[![pythontutor.com](pythontutor5.png)][pet]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kapusta\n"
     ]
    }
   ],
   "source": [
    "ovoce = ['jablko', 'hruška', 'broskev']\n",
    "zelenina = ['zelí', 'kedlub', 'paprika']\n",
    "\n",
    "jidlo = [ovoce, zelenina]\n",
    "food = jidlo[:]\n",
    "\n",
    "food[1][1] = 'kapusta'\n",
    "print(jidlo[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vyvořil jsem nový seznam `food` ale jeho obsah je stejný jako seznam `jídlo`.\n",
    "A když změním položku v jednom seznamu změní se automaticky i ve druhém, protože oba ukazují na stejné místo.\n",
    "\n",
    "Tuto situaci řeší modul `copy` a jeho metoda `deepcopy`. \n",
    "\n",
    "[sest]: http://pythontutor.com/visualize.html#code=import%20copy%0Aovoce%20%3D%20%5B'jablko',%20'hru%C5%A1ka',%20'broskev'%5D%0Azelenina%20%3D%20%5B'zel%C3%AD',%20'kedlub',%20'paprika'%5D%0A%0Ajidlo%20%3D%20%5Bovoce,%20zelenina%5D%0Afood%20%3D%20copy.deepcopy%28jidlo%29%0A%0Afood%5B1%5D%5B1%5D%20%3D%20'kapusta'%0Aprint%28jidlo%5B1%5D%5B1%5D%29&cumulative=false&curInstr=7&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false\n",
    "\n",
    "[![pythontutor.com](pythontutor6.png)][sest]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kedlub\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "ovoce = ['jablko', 'hruška', 'broskev']\n",
    "zelenina = ['zelí', 'kedlub', 'paprika']\n",
    "\n",
    "jidlo = [ovoce, zelenina]\n",
    "food = copy.deepcopy(jidlo)\n",
    "\n",
    "food[1][1] = 'kapusta'\n",
    "print(jidlo[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------------\n",
    "\n",
    "Pri práci s daty se někdy může hodit, když víte jak [**rozbalit** seznam nebo slovník ](./funkce.ipynb#Rozbaleníseznamu-a-slovníku)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}