2016-17/docs/wyklady/js-python_w09.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Języki skryptowe - Python\n",
    "## Wykład 9\n",
    "\n",
    "---\n",
    "\n",
    "* typy sekwencyjne: *set* i *frozenset*\n",
    "* generatory\n",
    "* omówienie zadań z listy 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Typy sekwencyjne \n",
    "\n",
    "---\n",
    "\n",
    "* do tej pory poznaliśmy cztery typy sekwencyjne:\n",
    "    * *str* - typ tekstowy\n",
    "    * *list* - *mutowalna* sekwencja\n",
    "    * *tuple* - *niemutowalna* sekwencja\n",
    "    * *range* - *niemutowalna* sekwencja liczb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sekwencja *set*\n",
    "\n",
    "---\n",
    "\n",
    "* *set* jest *mutowalną* sekwencją\n",
    "* różnice względem *list*\n",
    "    * nie może zawierać duplikatów\n",
    "    * jest nieuporządkowana\n",
    "    * może zawierać tylko *hashowalne* obiekty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Definiowanie *set*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zbior = {1, 4, 6, 2, 1} # nawiasy klamrowe\n",
    "\n",
    "type(zbior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 4, 6}\n"
     ]
    }
   ],
   "source": [
    "print(zbior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-119e4f5506a9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mzbior\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# nie ma indeksowania zbiorów\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object does not support indexing"
     ]
    }
   ],
   "source": [
    "zbior[0] # nie ma indeksowania zbiorów"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *set* z *list*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 4, 6}\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 4, 6, 2, 1]\n",
    "\n",
    "zbior = set(lista) # stwórz zbiór na bazie listy\n",
    "\n",
    "print(zbior)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dodawanie elementów do zbioru\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "zbior = {1, 2, 3}\n",
    "\n",
    "print(zbior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "zbior.add(4) # dodaj 4\n",
    "\n",
    "print(zbior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "zbior.add(4) # jeszcze raz dodaj 4\n",
    "\n",
    "print(zbior) # nie ma duplikatów"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Elementy *niehashowalne*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-c1da28ad9f1d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# zbiór nie może przechowywać\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# elementów niehashowalnych\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mzbior\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlista\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "zbior = {1, 2, 3}\n",
    "\n",
    "lista = [4, 5] # lista jest niehashowalna\n",
    "\n",
    "# zbiór nie może przechowywać \n",
    "# elementów niehashowalnych\n",
    "zbior.add(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sekwencje hashowalne\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(4, 5), 1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "zbior = {1, 2, 3}\n",
    "\n",
    "krotka = (4, 5) # krotka jest hashowalna\n",
    "\n",
    "# więc można dodać krotkę\n",
    "# do zbioru\n",
    "zbior.add(krotka)\n",
    "\n",
    "print(zbior)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Usuwanie elementów ze zbioru\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3}\n"
     ]
    }
   ],
   "source": [
    "zbior = {1, 2, 3}\n",
    "\n",
    "zbior.remove(1) # usuń 1\n",
    "\n",
    "print(zbior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-15d16e079b36>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# zwróci błąd jeśli element nie istnieje\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mzbior\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 1"
     ]
    }
   ],
   "source": [
    "# zwróci błąd jeśli element nie istnieje\n",
    "zbior.remove(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bezpieczne usuwanie?\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "zbior = {1, 2, 3}\n",
    "\n",
    "# aby uniknąć błędów i przerwania programu\n",
    "# można sprawdzić, czy na pewno element\n",
    "# znajduje się w zbiorze\n",
    "if 1 in zbior:\n",
    "    zbior.remove(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# lub skorzystać z try...except\n",
    "try:\n",
    "    zbior.remove(1)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# lub skorzystać z discard\n",
    "zbior.discard(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zastosowanie zbiorów\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# usuwanie duplikatów z listy\n",
    "\n",
    "lista = [2, 1, 2, 3, 4, 3, 2, 1, 5, 5, 2]\n",
    "\n",
    "lista = list(set(lista))\n",
    "\n",
    "# uwaga - tracimy kolejność\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Część wspólna zbiorów\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4, 5}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {1, 2, 3, 4, 5}\n",
    "B = {3, 4, 5, 6, 7}\n",
    "\n",
    "A.intersection(B) # część wspólna A i B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4, 5}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lub krócej\n",
    "A & B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Część wspólna list\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "A = [1, 2, 3, 4, 5]\n",
    "B = [3, 4, 5, 6, 7]\n",
    "\n",
    "# rzutuje A i B na zbiory\n",
    "# wyznacza ich część wspólną\n",
    "# rzutuje na listę\n",
    "wspolna = list(set(A) & set(B))\n",
    "\n",
    "print(wspolna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## *frozenset*\n",
    "\n",
    "---\n",
    "\n",
    "* jak *set* ale *niemutowalny*, czyli nie można modyfikować zawartości"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zamrozony_zbior = frozenset([1, 2, 3, 4, 5])\n",
    "\n",
    "type(zamrozony_zbior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'frozenset' object has no attribute 'add'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-c3b7844219a4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mzamrozony_zbior\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# nie można dodawać / usuwać\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'add'"
     ]
    }
   ],
   "source": [
    "zamrozony_zbior.add(1) # nie można dodawać / usuwać"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przykład - Totolotek\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "# z wykładu 7\n",
    "\n",
    "def losowanie():\n",
    "    \"\"\"Losuje 6 liczb od 1 do 49.\"\"\"\n",
    "    # nie jesteśmy zabezpieczni przed powtórzeniami\n",
    "    return sorted([randint(1, 49) for _ in range(6)])\n",
    "\n",
    "def check(a, b):\n",
    "    \"\"\"Sprawdza ilość takich samych elementów.\"\"\"\n",
    "    return len([n for n in a if n in b])\n",
    "\n",
    "def play():\n",
    "    \"\"\"Gra w lotka.\"\"\"\n",
    "    lotto = losowanie() # losowanie lotto\n",
    "    kupon = losowanie() # kupon chybił-trafił\n",
    "    return check(kupon, lotto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Totolotek z *set*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "def losowanie():\n",
    "    \"\"\"Losuje 6 liczb od 1 do 49.\"\"\"\n",
    "    los = set() # tutaj zapiszemy wyniki losowania\n",
    "\n",
    "    while len(los) < 6: # dodawaj aż 6 unikatów\n",
    "        los.add(randint(1, 49))\n",
    "    \n",
    "    return los\n",
    "\n",
    "def check(a, b):\n",
    "    \"\"\"Sprawdza ilość takich samych elementów.\"\"\"\n",
    "    return len(a & b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Totolotek - test\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{35, 7, 12, 16, 48, 29}\n",
      "{32, 10, 13, 26, 29, 31}\n"
     ]
    }
   ],
   "source": [
    "lotto = losowanie()\n",
    "kupon = losowanie()\n",
    "\n",
    "print(lotto, kupon, sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check(lotto, kupon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Totolotek z *frozenset*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from random import sample\n",
    "\n",
    "# frozenset bo losowania nie będziemy modyfikować\n",
    "\n",
    "def losowanie():\n",
    "    \"\"\"Losuje 6 liczb od 1 do 49.\"\"\"\n",
    "    los = sample(range(1, 50), 6) # sample gwarantuje brak powtórzeń\n",
    "    return frozenset(los) # zwracamy jako zamrożony zbiór\n",
    "\n",
    "def check(a, b):\n",
    "    \"\"\"Sprawdza ilość takich samych elementów.\"\"\"\n",
    "    return len(a & b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Totolotek - test\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frozenset({37, 46, 48, 19, 25, 31})\n",
      "frozenset({38, 40, 41, 18, 19, 30})\n"
     ]
    }
   ],
   "source": [
    "lotto = losowanie()\n",
    "kupon = losowanie()\n",
    "\n",
    "print(lotto, kupon, sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check(lotto, kupon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Generatory\n",
    "\n",
    "---\n",
    "\n",
    "* funkcja, która zachowuje się jak iterator (czyli można np. wykorzystać ją w pętli)\n",
    "* zamiast tworzyć całą listę obiektów, które będą przechowywane w pamięci\n",
    "* oszczędza czas i pamięć"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dygresja: *range*\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loop, best of 3: 1.68 µs per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n1 range(1000000) # tworzy obiekt range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 loop, best of 3: 53.3 ms per loop\n"
     ]
    }
   ],
   "source": [
    "# kolejne elementy range\n",
    "# muszą zostać zapisane w pamięci\n",
    "%timeit -n1 list(range(1000000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Ciąg geometryczny\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def geometryczny(a1, q, n):\n",
    "    \"\"\"Generuje n wyrazów ciągu geometrycznego.\"\"\"\n",
    "    \n",
    "    ciag = [a1]\n",
    "    \n",
    "    for _ in range(n-1): # n-1 bo pierwszy już jest\n",
    "        ciag.append(ciag[-1]*q) # następny = poprzedni * iloraz\n",
    "        \n",
    "    return ciag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683]\n"
     ]
    }
   ],
   "source": [
    "ciag = geometryczny(1, 3, 10)\n",
    "\n",
    "print(ciag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Ciąg geometryczny - generator\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def gen_geometryczny(a1, q, n):\n",
    "    \"\"\"Generuje n wyrazów ciągu geometrycznego.\"\"\"\n",
    "    \n",
    "    for _ in range(n):\n",
    "        yield a1 # zwróć obecną wartość a1\n",
    "        a1 *= q  # i czekaj na kolejną iterację"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Generator a lista\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "ciag1 = geometryczny(1, 3, 10)     # zwraca listę \n",
    "ciag2 = gen_geometryczny(1, 3, 10) # zwraca generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683]\n"
     ]
    }
   ],
   "source": [
    "print(ciag1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object gen_geometryczny at 0x7f9bac1ec678>\n"
     ]
    }
   ],
   "source": [
    "print(ciag2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Generator jak iterator\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(ciag2) # pierwszy element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(ciag2) # kolejny element itd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, "
     ]
    }
   ],
   "source": [
    "# a najczęściej w pętli\n",
    "for i in gen_geometryczny(1, 3, 10):\n",
    "    print(i, end=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Czas\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 12.8 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 geometryczny(1, 3, 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 978 ns per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 gen_geometryczny(1, 3, 10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Czas dokładniej\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def test_lista():\n",
    "    \"\"\"Pętla po liście\"\"\"\n",
    "    for element in geometryczny(1, 3, 10000):\n",
    "        pass\n",
    "    \n",
    "def test_generator():\n",
    "    \"\"\"Pętla po generatorze\"\"\"\n",
    "    for element in gen_geometryczny(1, 3, 10000):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 13.6 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 test_lista()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 12.1 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 test_generator()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lista czy generator\n",
    "\n",
    "---\n",
    "\n",
    "* generator będzie z reguły szybszy\n",
    "* generator może być nieskończony\n",
    "* jednak nie można wykonywać operacji na \"elementach\", np. sortowania\n",
    "* lista może być efektywniejsza, jeśli planujemy więcej pętli"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## \"Wyczerpanie\" generatora\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "ciag = gen_geometryczny(1, 3, 20) # generuje 20 wyrazów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 9 27 81 243 729 2187 6561 19683 "
     ]
    }
   ],
   "source": [
    "for i in range(10): # wydrukuj 10 pierwszych\n",
    "    print(next(ciag), end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59049 177147 531441 1594323 4782969 14348907 43046721 129140163 387420489 1162261467 "
     ]
    }
   ],
   "source": [
    "for element in ciag: # nie zaczyna od pierwszego!\n",
    "    print(element, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wielekrotne użycie\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def lista_loop(n=10):\n",
    "    \"\"\"Wykonuje n pętli po liście\"\"\"\n",
    "    \n",
    "    ciag = geometryczny(1, 3, 10000)\n",
    "    \n",
    "    for _ in range(n):\n",
    "        for element in ciag:\n",
    "            pass\n",
    "    \n",
    "def gen_loop(n=10):\n",
    "    \"\"\"Wykonuje n pętli po generatorze\"\"\"\n",
    "    \n",
    "    for _ in range(n):\n",
    "        for element in gen_geometryczny(1, 3, 10000):\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 14.2 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 lista_loop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 77.4 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 gen_loop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Powtórka: listy składane (*list comprehensions*)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# chcemy stworzyć listę zawierającą\n",
    "# kwadraty wszystkich cyfr\n",
    "\n",
    "kwadraty = []\n",
    "\n",
    "for x in range(10):\n",
    "    kwadraty.append(x**2)\n",
    "    \n",
    "print(kwadraty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# a korzystając z listy skladanej\n",
    "\n",
    "kwadraty = [x**2 for x in range(10)]\n",
    "\n",
    "print(kwadraty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Append vs lista składana\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def create_list(n=100000):\n",
    "    \"\"\"Tworzy listę kwadratów pierwszych n liczb naturalnych\"\"\"\n",
    "    \n",
    "    kwadraty = []\n",
    "    \n",
    "    for x in range(n):\n",
    "        kwadraty.append(x**2)\n",
    "        \n",
    "    return kwadraty\n",
    "\n",
    "def list_comprehension(n=100000):\n",
    "    \"\"\"Tworzy listę kwadratów pierwszych n liczb naturalnych\"\"\"\n",
    "    \n",
    "    return [x**2 for x in range(n)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Czas\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 48.3 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 x = create_list() # lista tworzona przez append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 loops, best of 3: 42.5 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit -n3 y = list_comprehension() # lista składana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "create_list() == list_comprehension() # wynik ten sam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Przykład\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def force(m, a):\n",
    "    \"\"\"Zwraca wartość siły [N].\n",
    "    \n",
    "    Liczy siłę jaką należy zadziałać na ciało\n",
    "    o masie m [kg], aby nadać mu przyspieszenie a [m/s^2].\n",
    "    \"\"\"\n",
    "    return m*a\n",
    "\n",
    "wagi = [10, 20, 30, 40, 50] # kg\n",
    "przyspieszenia = [1, 2, 3, 4, 5] # m/s^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 40, 90, 160, 250]\n"
     ]
    }
   ],
   "source": [
    "# stwórz tablicę z wartościami sił \n",
    "\n",
    "sily = [force(m, a) for m, a in zip(wagi, przyspieszenia)]\n",
    "\n",
    "print(sily)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Generator \"jak lista składana\"\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# lista składana\n",
    "list_comprehension = [x**2 for x in range(10)]\n",
    "\n",
    "# generator expression\n",
    "generator = (x**2 for x in range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 49 64 81 "
     ]
    }
   ],
   "source": [
    "for x in generator:\n",
    "    print(x, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 49 64 81 "
     ]
    }
   ],
   "source": [
    "# lub prościej\n",
    "\n",
    "for x in (x**2 for x in range(10)):\n",
    "    print(x, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Uwagi na koniec\n",
    "\n",
    "---\n",
    "\n",
    "* unikaj tworzenia list przez *append*, jeśli można wykorzystać *list comprehension*\n",
    "* unikaj tworzenia list jeśli jest to zbędne (użyj generatorów)\n",
    "* unikaj *generator function* na rzecz *generator expression*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Próbne kolokwium - zadanie 1\n",
    "\n",
    "---\n",
    "\n",
    "Napisz skrypt, który wygeneruje listę zawierającą 100 pierwszych wyrazów ciągu geometrycznego (dla zadanych a1 i q - pierwszy wyraz ciągu i iloraz).\n",
    "\n",
    "Następnie wydrukuje na ekranie ten ciąg oraz jego podciąg zawierający tylko parzyste wyrazy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 1 - wersja I\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# podnoszenie q do potęgi jest bardzo czasochłonne!\n",
    "\n",
    "def geometryczny_v1(a1, q, n):\n",
    "    \"\"\"Zwraca n-ty wyraz ciągu geometrycznego (a1, q)\"\"\"\n",
    "    \n",
    "    return a1*q**(n-1) # nie wymaga wyjaśnienia (oby...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# składamy listę na bazie naszej funkcji\n",
    "\n",
    "ciag = [geometryczny_v1(1, 3, n+1) for n in range(100)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# print(ciag) # drukuje cały ciąg\n",
    "# print(ciag[1::2]) # drukuje tylko parzyste wyrazy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 1 - wersja II\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def geometryczny_v2(a1, q, n, ciag=[]):\n",
    "    \"\"\"Tworzy listę n pierwszych wyrazów ciągu (a1, q)\"\"\"\n",
    "    \n",
    "    for _ in range(n):\n",
    "        ciag.append(a1) # dodaj obecny wyraz\n",
    "        a1 *= q         # następny wyraz\n",
    "        \n",
    "    return ciag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "ciag = geometryczny_v2(1, 3, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# print(ciag) # drukuje cały ciąg\n",
    "# print(ciag[1::2]) # drukuje tylko parzyste wyrazy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 1 - wersja III\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def geometryczny_v3(a1, q, n):\n",
    "    \"\"\"Generator ciągu geometrycznego (a1, q)\"\"\"\n",
    "    \n",
    "    for _ in range(n):\n",
    "        yield a1 # zwróć obecny wyraz i czekaj\n",
    "        a1 *= q  # następny wyraz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "ciag = geometryczny_v3(1, 3, 100) # generator!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# drukuj cały ciąg\n",
    "\n",
    "# for x in ciag:\n",
    "#     print(x, end=' ')\n",
    "\n",
    "# nie ma wycinków generatorów\n",
    "# ale można skorzystać z itertools.islice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 1 - wersja IV\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def geometryczny_v4(a1, q, n, ciag=[]):\n",
    "    \"\"\"Ciąg geometryczny (a1, q) rekurencyjnie\"\"\"\n",
    "    \n",
    "    if not n:\n",
    "        return ciag # zwróć ciąg gdy dotrzemy do n\n",
    "    \n",
    "    ciag.append(a1) # dodaj obecny element\n",
    "    # wywołaj rekurencyjnie z kolejnym elementem\n",
    "    return geometryczny_v4(a1*q, q, n-1, ciag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "ciag = geometryczny_v4(1, 3, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# print(ciag) # drukuje cały ciąg\n",
    "# print(ciag[1::2]) # drukuje tylko parzyste wyrazy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Próbne kolokwium - zadanie 2\n",
    "\n",
    "---\n",
    "\n",
    "Napisz funkcję, która sprawdza, czy podana liczba jest liczbą pierwszą. Funkcja powinna zwracać True lub False.\n",
    "\n",
    "Napisz skrypt, który sprawdzi, czy podana przez użytkownika liczba jest liczbą pierwszą."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 2 - wersja I\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def is_prime_v1(n):\n",
    "    \"\"\"Sprawdza czy n jest liczbą pierwszą.\"\"\"\n",
    "    \n",
    "    if n < 2:\n",
    "        return False # 0 i 1 nie są pierwsze\n",
    "    \n",
    "    if n < 4:\n",
    "        return True # 2 i 3 są pierwsze\n",
    "    \n",
    "    if n % 2 == 0:\n",
    "        return False # parzyste nie są pierwsze\n",
    "    \n",
    "    i = 3\n",
    "    \n",
    "    while i < n:\n",
    "        if n % i == 0:\n",
    "            return False # dzieli się przez i\n",
    "        i += 1\n",
    "\n",
    "    return True # nie dzieli się przez nic    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_prime_v1(11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dygresja o dzielnikach\n",
    "\n",
    "---\n",
    "\n",
    "* Niech $n = a * b$\n",
    "* Jeśli $a = b$, to $a = b = \\sqrt(n)$\n",
    "* Jeśli $a \\neq b$, to albo $a < \\sqrt(n)$ albo $b < \\sqrt(n)$\n",
    "* Co oznacza, że jeśli nie znajdziemy dzielnika mniejszego od $\\sqrt(n)$, to nie znajdziemy og też dalej\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 2 - wersja II\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def is_prime_v2(n):\n",
    "    \"\"\"Sprawdza czy n jest liczbą pierwszą.\"\"\"\n",
    "    \n",
    "    if n < 2:\n",
    "        return False # 0 i 1 nie są pierwsze\n",
    "    \n",
    "    if n < 4:\n",
    "        return True # 2 i 3 są pierwsze\n",
    "    \n",
    "    if n % 2 == 0:\n",
    "        return False # parzyste nie są pierwsze\n",
    "    \n",
    "    i = 3\n",
    "    \n",
    "    while i*i < n: # szukamy do pierwiastka z n\n",
    "        if n % i == 0:\n",
    "            return False # dzieli się przez i\n",
    "        i += 1\n",
    "\n",
    "    return True # nie dzieli się przez nic  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_prime_v2(11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sito Eratostenesa\n",
    "\n",
    "---\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Implementacja\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def sieve_v1(n):\n",
    "    \"\"\"Create Sieve of Eratosthenes\"\"\"\n",
    "    is_prime = [False, False] + [True] * n # ustaw flagi na True\n",
    "    \n",
    "    i = 2\n",
    "    \n",
    "    while i * i < n: # do pierwiastka z n\n",
    "        if is_prime[i]:\n",
    "            for j in range(2*i, n, i): # zmień flagę\n",
    "                is_prime[j] = False    # dla wszystkich wielokrotności\n",
    "        i += 1\n",
    "\n",
    "    return is_prime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 "
     ]
    }
   ],
   "source": [
    "primes = sieve_v1(100)\n",
    "\n",
    "for i in range(100):\n",
    "    if primes[i]:\n",
    "        print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Próbne kolokwium - zadanie 3\n",
    "\n",
    "---\n",
    "\n",
    "Napisz skrypt, który wymaga trzech argumentów z linii komend (wsk. sys.argv), czyli: `python moj_skrypt.py arg1 arg2 arg3`\n",
    "\n",
    "które są długościami boków trójkąta (można założyć, że podane argumenty są liczbami). Na tej podstawie skrypt powinien wydrukować na ekranie następujące informacje:\n",
    "\n",
    "* obwód i pole trójkąta\n",
    "* informację czy trójkąt jest równoboczny, równoramienny czy różnoboczny\n",
    "* informację czy trójkąt jest prostokątny, ostrokątny czy rozwartokątny\n",
    "\n",
    "W przypadku złej liczby argumentów program powinien wyświetlić odpowiedni komunikat i zakończyć działanie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 3\n",
    "\n",
    "---\n",
    "\n",
    "* Pełny skrypt można znalęźć tutaj: [zadanie 3](https://raw.githubusercontent.com/TomaszGolan/js-python/master/src/triangle.py)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 3 - część I\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting zad3.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile zad3.py\n",
    "\n",
    "\"\"\"Moduł do obsługi trójkątów.\"\"\"\n",
    "\n",
    "import sys\n",
    "import math\n",
    "\n",
    "\n",
    "def help():\n",
    "    \"\"\"Drukuje instrukcję obsługi i zamyka program\"\"\"\n",
    "\n",
    "    print(\"usage: python triangle.py bok1 bok2 bok3\")\n",
    "    sys.exit(1)\n",
    "\n",
    "\n",
    "def generate(a, b, c):\n",
    "    \"\"\"Zwraca posortowane boki trójkąta jako floaty.\"\"\"\n",
    "\n",
    "    return sorted([float(a), float(b), float(c)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 3 - część II\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Appending to zad3.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile -a zad3.py\n",
    "\n",
    "def check(a, b, c):\n",
    "    \"\"\"Zamyka program, jeśli nierówność trójkąta nie jest spełniona.\"\"\"\n",
    "\n",
    "    if a + b <= c:\n",
    "        print(\"Nierówność trojkąta nie jest spełniona.\\n\")\n",
    "        help()\n",
    "\n",
    "\n",
    "def obwod(a, b, c):\n",
    "    \"\"\"Zwraca obwód trójkąta\"\"\"\n",
    "\n",
    "    return a + b + c\n",
    "\n",
    "\n",
    "def pole(a, b, c):\n",
    "    \"\"\"Zwraca pole trójkąta\"\"\"\n",
    "\n",
    "    p = obwod(a, b, c) / 2\n",
    "    # wzór Herona\n",
    "    return math.sqrt(p*(p - a)*(p - b)*(p - c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 3 - część III\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Appending to zad3.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile -a zad3.py\n",
    "\n",
    "def typ_boki(a, b, c):\n",
    "    \"\"\"Zwraca typ trójkąta (ze względu na boki)\"\"\"\n",
    "\n",
    "    if a == b == c:\n",
    "        return \"równoboczny\"\n",
    "    elif a == b or b == c:\n",
    "        return \"równoramienny\"\n",
    "    else:\n",
    "        return \"różnoboczny\"\n",
    "\n",
    "\n",
    "def typ_katy(a, b, c):\n",
    "    \"\"\"Zwraca typ trójkąta (ze względu na kąty)\"\"\"\n",
    "\n",
    "    x = a**2 + b**2 - c**2\n",
    "\n",
    "    if x == 0:\n",
    "        return \"prostokątny\"\n",
    "    elif x > 0:\n",
    "        return \"ostrokątny\"\n",
    "    else:\n",
    "        return \"rozwartokątny\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 3 - część IV\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Appending to zad3.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile -a zad3.py\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "\n",
    "    try:\n",
    "        a, b, c = generate(sys.argv[1], sys.argv[2], sys.argv[3])\n",
    "    except:\n",
    "        help()\n",
    "\n",
    "    check(a, b, c)\n",
    "\n",
    "    print(\"Obwód trójkąta =\", obwod(a, b, c))\n",
    "    print(\"Pole trójkąta =\", pole(a, b, c))\n",
    "    print(\"Trójkąt jest\", \ttyp_boki(a, b, c))\n",
    "    print(\"Trójkąt jest\", typ_katy(a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 3 - test\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "usage: python triangle.py bok1 bok2 bok3\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "python zad3.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obwód trójkąta = 12.0\n",
      "Pole trójkąta = 6.0\n",
      "Trójkąt jest różnoboczny\n",
      "Trójkąt jest prostokątny\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "python zad3.py 3 4 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Próbne kolokwium - zadanie 4\n",
    "\n",
    "---\n",
    "\n",
    "Korzystając z metody równego podziału (bisekcji) znajdź przybliżone miejsce zerowe funkcji: `f(x) = x**3 + 2*x*2 - 4*x - 10` w przedziale [1:3]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Metoda bisekcji\n",
    "\n",
    "---\n",
    "\n",
    "* $f(x)$ jest ciągła w przedziale $[a, b]$\n",
    "* i przyjmuje różne znaki na końcach przedziału $f(a)f(b) < 0$\n",
    "* idea:\n",
    "    * sprawdzamy, czy środek $x$ jest miejscem zerowym -> koniec\n",
    "    * dzielimy przedział na dwa: $[a, x]$ i $[x, b]$\n",
    "    * wybieramy przedział, dla którego znaki są różne na brzegach\n",
    "    * powtarzamy do skutku"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 4 \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def bisekcja(f, a, b, epsilon=0.0001):\n",
    "    \"\"\"Szuka miejsca zerowego f w [a, b] z dokładnością epislon.\n",
    "    \n",
    "    Zakładamy b > a oraz f(a)*f(b) < 0\n",
    "    \"\"\"\n",
    "    \n",
    "    while b - a > epsilon: # dopóki mieścimy się w epsilon\n",
    "        x = (b + a) / 2    # środek przedziału\n",
    "                \n",
    "        if f(x) == 0:       # miejsce zerowe znalezione\n",
    "            return x\n",
    "        elif f(x)*f(a) < 0: # nowy przedział [a, x1]\n",
    "            b = x\n",
    "        else:               # nowy przedział [x1, b]\n",
    "            a = x \n",
    "    \n",
    "    return (b + a) / 2 # zwracamy przybliżoną wartość    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zadanie 4 - test\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x0 = 2.117950439453125\n",
      "f(x0) = 0.00014644321370838043\n"
     ]
    }
   ],
   "source": [
    "def funkcja(x):\n",
    "    return x**3 + 2*x**2 - 4*x - 10\n",
    "\n",
    "x0 = bisekcja(funkcja, 1, 3)\n",
    "\n",
    "print(\"x0 =\", x0)\n",
    "print(\"f(x0) =\", funkcja(x0))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}