Python2016_Wyklad-02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Język Python - Wykład 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PEP 8 - Zasady formatowania kodu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **,,code is read much more often than it is written''** (BDFL)\n",
    " \n",
    " Po co wytyczne do formatowania kodu?\n",
    "   * spójność stylu wewnątrz modułów i projektu\n",
    "   * wytyczne to nie wyrocznia, można je pominąć, gdy:\n",
    "      * czyni to kod mniej czytelnym\n",
    "      * aby być spójnym z istniejącym kodem\n",
    "      * jest ryzyko utraty kompatybilności wstecz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* http://www.python.org/dev/peps/pep-0008/\n",
    "* 4 spacje na jedno wcięcie kodu \n",
    "* Nie używać znaków tabulacji (``\\t``)\n",
    "* Nigdy nie mieszać znaków tabulacji ze spacjami do robienia wcięć jednym kodzie\n",
    "* Jedna pusta linia pomiędzy kodem funkcji i metod\n",
    "* Dwie puste linie pomiędzy kodem klas\n",
    "* Maksymalna długość linii kodu to 79 znaków\n",
    "* Nie używać ``from <module> import *`` - zatrucie przestrzeni nazw\n",
    "* starać się nie używać zmiennych ``l`` (małe L, podobne do 1), ``O`` (duże o, podobne do zero), ``I`` (duże i, podobne do 1)\n",
    "* Znak spacji po znaku ``,`` w słownikach, zbiorach, listach, krotkach, argumentach oraz po znaku ``:`` w słownikach (nie przed!)\n",
    "\n",
    "    Dobrze:\n",
    "        [1, 2, 3, 4]\n",
    "        {'black': 5, 'orange': 10}\n",
    "        f(1, 4)\n",
    "    \n",
    "    Źle:\n",
    "        [1,2,3,4]\n",
    "        [ 1,2,3,4 ]\n",
    "        { 'black' : 5, 'orange' : 10 }\n",
    "        f(1,4)\n",
    "        f( 1 , 4 )\n",
    "    \n",
    "* Znaki spacji przed i po wyrażeniach przypisania i porównania (z wyjątkiem listy argumentów)\n",
    "\n",
    "    Dobrze:\n",
    "        a = 5\n",
    "        b = [1, 2, 3, 4]\n",
    "        f(a=5, b=10)\n",
    "    \n",
    "    Źle:\n",
    "        a=5\n",
    "        a= 5\n",
    "        a =5\n",
    "        f(a = 5, b = 10)\n",
    "        f(a= 5, b= 10)\n",
    "\n",
    "* Bez spacji na brzegach nawiasowania i listy argumentów\n",
    "\n",
    "    Dobrze:\n",
    "        (a + 3) * (5 - b)\n",
    "        \n",
    "    Źle:\n",
    "        (a+3)*(5-b)\n",
    "        ( a + 3 ) * ( 5 - b )\n",
    "        \n",
    "\n",
    "* Bez spacji na brzegach jednoliniowych komentarzy docstring (więcej w PEP 257 http://www.python.org/dev/peps/pep-0257/)\n",
    "\n",
    "    Dobrze:\n",
    "        def make_squares(key, value=0):\n",
    "            \"\"\"Return a dictionary and a list...\"\"\"\n",
    "            d = {key: value}\n",
    "            l = [key, value]\n",
    "            return d, l\n",
    "    Źle:\n",
    "        def make_squares(key, value=0):\n",
    "            \"\"\"\n",
    "                Return a dictionary and a list...\n",
    "            \"\"\"\n",
    "            d = {key: value}\n",
    "            l = [key, value]\n",
    "            return d, l\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kilka słów o logicznych typach danych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Słowa kluczowe - traktowane specjalnie przez parser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "from keyword import kwlist\n",
    "print(kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nie można użyć słów kluczowych do nazywania zmiennych i funkcji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-edd6b49ae404>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-edd6b49ae404>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    for = 8\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "for = 8\n",
    "while = \"aaa\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wbudowane - typy, funkcje, wyjątki. Traktowane przez parser jak identyfikatory tworzone przez programistę. Można (o zgrozo) używać ich w przypisaniach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__IPYTHON__', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'dreload', 'enumerate', 'eval', 'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']\n"
     ]
    }
   ],
   "source": [
    "print(dir(__builtins__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "int = \"ojej\"\n",
    "len = lambda x : 137"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "len([0,1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "'True' in dir(__builtins__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Porównania\n",
    "\n",
    "  * Python2 (od 2.3): wbudowany typ `bool`, dwie wartości ``True`` i ``False`` **nie będące słowami kluczowymi**\n",
    "  * Python3: wbudowana klasa `bool`, dwie możliwe wartości będące obiektami tej klasy: ``True`` i ``False`` - **słowa kluczowe**\n",
    "  \n",
    "  http://python-history.blogspot.com/2013/11/story-of-none-true-false.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter an integer : 23\n",
      "Congratulations, you guessed it.\n",
      "The while loop is over.\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "def guess(number=23):\n",
    "    running = True\n",
    "\n",
    "    while running:\n",
    "        guess = int(input('Enter an integer : '))\n",
    "\n",
    "        if guess == number:\n",
    "            print('Congratulations, you guessed it.')\n",
    "            running = False # this causes the while loop to stop\n",
    "        elif guess < number:\n",
    "            print('No, it is a little higher than that.')\n",
    "        else:\n",
    "            print('No, it is a little lower than that.')\n",
    "    else:\n",
    "        print('The while loop is over.')\n",
    "        # Do anything else you want to do here\n",
    "    print('Done')\n",
    "\n",
    "# True = 0\n",
    "guess()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
     ]
    }
   ],
   "source": [
    "%reset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porównania:\n",
    "\n",
    "* nie używać \"``== True``\" ani \"`is True`\" do sprawdzania prawdziwości\n",
    "\n",
    "     * Dobrze: ``if greeting:``\n",
    "     * Żle:    ``if greeting == True:``\n",
    "     * Jeszcze gorzej: ``if greeting is True:``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listy - zaawansowane użycie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class list in module builtins:\n",
      "\n",
      "class list(object)\n",
      " |  list() -> new empty list\n",
      " |  list(iterable) -> new list initialized from iterable's items\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.n\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      L.__reversed__() -- return a reverse iterator over the list\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      L.__sizeof__() -- size of L in memory, in bytes\n",
      " |  \n",
      " |  append(...)\n",
      " |      L.append(object) -> None -- append object to end\n",
      " |  \n",
      " |  clear(...)\n",
      " |      L.clear() -> None -- remove all items from L\n",
      " |  \n",
      " |  copy(...)\n",
      " |      L.copy() -> list -- a shallow copy of L\n",
      " |  \n",
      " |  count(...)\n",
      " |      L.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  extend(...)\n",
      " |      L.extend(iterable) -> None -- extend list by appending elements from the iterable\n",
      " |  \n",
      " |  index(...)\n",
      " |      L.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(...)\n",
      " |      L.insert(index, object) -- insert object before index\n",
      " |  \n",
      " |  pop(...)\n",
      " |      L.pop([index]) -> item -- remove and return item at index (default last).\n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(...)\n",
      " |      L.remove(value) -> None -- remove first occurrence of value.\n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(...)\n",
      " |      L.reverse() -- reverse *IN PLACE*\n",
      " |  \n",
      " |  sort(...)\n",
      " |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<slot wrapper '__str__' of 'object' objects>"
      ]
     },
     "execution_count": 20,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "help(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Przedłużanie listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 21,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "extend_list = [1, 2, 3]\n",
    "extend_list.extend([4, 5, 6])\n",
    "extend_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usuwanie z listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 5, 6]"
      ]
     },
     "execution_count": 22,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "del extend_list[2]\n",
    "extend_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 6]"
      ]
     },
     "execution_count": 23,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "del extend_list[1:3]\n",
    "extend_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'extend_list' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-d45d9c033655>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mextend_list\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mextend_list\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'extend_list' is not defined"
     ]
    }
   ],
   "source": [
    "del extend_list\n",
    "print(extend_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lista jako stos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 25,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "stack = [3, 4, 5, 6, 7]\n",
    "stack.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 26,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "stack.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 27,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "stack.append(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 10]"
      ]
     },
     "execution_count": 29,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "stack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lista jako kolejka"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listy można używać jak kolejki, ale operacje na początku listy są nieefektywne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 30,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "queue = [3, 4, 5, 6, 7]\n",
    "queue.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 7, 10]"
      ]
     },
     "execution_count": 31,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "queue.append(10)\n",
    "queue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zamiast tego lepiej użyć specjalnie do tego przeznaczonej struktury deque z modułu standardowego collections:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Eric'"
      ]
     },
     "execution_count": 32,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "from collections import deque\n",
    "queue = deque([\"Eric\", \"John\", \"Michael\"])\n",
    "queue.append(\"Terry\")           # Terry arrives\n",
    "queue.append(\"Graham\")          # Graham arrives\n",
    "queue.popleft()                 # The first to arrive now leaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'John'"
      ]
     },
     "execution_count": 33,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "queue.popleft()                 # The second to arrive now leaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['Michael', 'Terry', 'Graham'])"
      ]
     },
     "execution_count": 34,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "queue                           # Remaining queue in order of arrival"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rozwijanie listy jest idiomem zastępujacym wyrażenia pętli for budującej listę:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 35,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "squares = []\n",
    "for x in range(10):\n",
    "    squares.append(x**2)\n",
    "\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To samo można zapisać prościej:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 36,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "[x**2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Można też tworzyć pętle zagnieżdzone i używać konstrukcji warunkowych:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 37,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "[(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trójki pitagorejskie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(3, 4, 5),\n",
       " (5, 12, 13),\n",
       " (6, 8, 10),\n",
       " (7, 24, 25),\n",
       " (8, 15, 17),\n",
       " (9, 12, 15),\n",
       " (10, 24, 26),\n",
       " (12, 16, 20),\n",
       " (15, 20, 25),\n",
       " (20, 21, 29)]"
      ]
     },
     "execution_count": 38,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "n = 30\n",
    "[(x,y,z) for x in range(1,n) for y in range(x,n) for z in range(y,n) if x**2 + y**2 == z**2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('THE', 'the', 3),\n",
       " ('QUICK', 'quick', 5),\n",
       " ('BROWN', 'brown', 5),\n",
       " ('FOX', 'fox', 3),\n",
       " ('JUMPS', 'jumps', 5),\n",
       " ('OVER', 'over', 4),\n",
       " ('THE', 'the', 3),\n",
       " ('LAZY', 'lazy', 4),\n",
       " ('DOG', 'dog', 3)]"
      ]
     },
     "execution_count": 39,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "words = 'The quick brown fox jumps over the lazy dog'.split()\n",
    "[(w.upper(), w.lower(), len(w)) for w in words]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({0, 1, 4, 9, 16, 25, 36, 49, 64, 81},\n",
       " {0, 1, 8, 27, 64, 125, 216, 343, 512, 729})"
      ]
     },
     "execution_count": 42,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "a = { x**2 for x in range(10)}\n",
    "b = { x**3 for x in range(10)}\n",
    "a,b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operacje na zbiorach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 64}"
      ]
     },
     "execution_count": 43,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "a & b  # intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 4, 8, 9, 16, 25, 27, 36, 49, 64, 81, 125, 216, 343, 512, 729}"
      ]
     },
     "execution_count": 44,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "a | b  # union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 9, 16, 25, 36, 49, 81}"
      ]
     },
     "execution_count": 45,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "a - b  # difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{8, 27, 125, 216, 343, 512, 729}"
      ]
     },
     "execution_count": 46,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "b - a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 8, 9, 16, 25, 27, 36, 49, 81, 125, 216, 343, 512, 729}"
      ]
     },
     "execution_count": 47,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "a ^ b  # symmetric difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "a <= b  # is subset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionary comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 17, 'b': 34, 'z': 3}"
      ]
     },
     "execution_count": 51,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "mcase = {'a':10, 'b': 34, 'A': 7, 'Z':3}\n",
    "mcase_frequency = { k.lower() : mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys() }\n",
    "mcase_frequency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ala', 'kota', 'ma'}"
      ]
     },
     "execution_count": 52,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "new_set = {i for i in ['ala', 'ma', 'kota', 'kota']}\n",
    "new_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda wyrażenia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Funkcja nienazwana utworzona w miejscu (anonimowa)\n",
    "* Można ją przypisać do zmiennej \n",
    "* Najczęściej używamy jej przy programowaniu funkcyjnym (wstrzykujemy logikę kodu do funkcji jako argument, np. patrz sortowanie)\n",
    "* Ciało funkcji lambda składa się z pojedynczego wyrażenia, którego ewaluacja zwracana jest jako wynik funkcji\n",
    "* Historia http://python-history.blogspot.com/2009/04/origins-of-pythons-functional-features.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>>"
      ]
     },
     "execution_count": 53,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "lambda x: x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 54,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "operator_dodaj = lambda x, y: x + y\n",
    "operator_dodaj(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'big'"
      ]
     },
     "execution_count": 57,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "lambda x: \"big\" if x > 100 else \"small\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bla bla bli blu blurp'"
      ]
     },
     "execution_count": 58,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "f = lambda s : \" \".join(s.split())\n",
    "text = '''bla bla\n",
    "bli      blu\n",
    "blurp\n",
    "'''\n",
    "f(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sortowanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sortowanie przez tworzenie nowej listy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 60,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "sta = (5, 2, 3, 1, 4)\n",
    "sorted(sta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sortowanie w miejscu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 61,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "a = [5, 2, 3, 1, 4]\n",
    "a.sort(reverse=True)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sortowaniem z użyciem klucza:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('apple', 3), ('banana', 2), ('orange', 1)]"
      ]
     },
     "execution_count": 62,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "fruits = [('apple', 3), ('orange', 1), ('banana', 2)]\n",
    "sorted(fruits, key=lambda fruit: fruit[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('orange', 1), ('banana', 2), ('apple', 3)]"
      ]
     },
     "execution_count": 63,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "sorted(fruits, key=lambda fruit: fruit[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kluczem może być nawet callable, który go wygeneruje:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'C', 'Z', 'a', 'c', 'z']"
      ]
     },
     "execution_count": 64,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "chars = ['Z', 'z', 'C', 'c', 'A', 'a']\n",
    "sorted(chars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'a', 'C', 'c', 'Z', 'z']"
      ]
     },
     "execution_count": 65,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "sorted(chars, key=str.lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python implementuje stabilne sortowanie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "tuple index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-69-fcf80fccd98c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0moperator\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mitemgetter\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0msorted\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'red'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'blue'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'red'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'blue'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mitemgetter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: tuple index out of range"
     ]
    }
   ],
   "source": [
    "from operator import itemgetter\n",
    "sorted([('red', 1), ('blue', 1), ('red', 2), ('blue', 2)], key=itemgetter(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programowanie funkcyjne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* filter - filtrowanie kolekcji\n",
    "* map - zmiana formatu kolekcji\n",
    "* reduce - redukowanie kolekcji (wyliczanie wartości z jej elementów), w Python3 w module functools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Policzyć, ile owoców wspólnie mają Merry i Tom:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Merry', [('apple', 5), ('orange', 3)]), ('Tom', [('peaches', 2)]), ('John', [('berries', 1), ('orange', 10)])])"
      ]
     },
     "execution_count": 70,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "fruits = {\n",
    "    'Merry': [\n",
    "        ('apple', 5),\n",
    "        ('orange', 3),\n",
    "    ],\n",
    "    'John': [\n",
    "        ('berries', 1),\n",
    "        ('orange', 10),\n",
    "    ],\n",
    "    'Tom' : [\n",
    "        ('peaches', 2),\n",
    "    ],\n",
    "}\n",
    "fruits.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filtrujemy \"bazę\" z owoców Johna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Merry', [('apple', 5), ('orange', 3)]), ('Tom', [('peaches', 2)])]"
      ]
     },
     "execution_count": 71,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "f = filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    "[it for it in f]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usuwamy imiona, nie są nam już potrzebne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[('apple', 5), ('orange', 3)], [('peaches', 2)]]"
      ]
     },
     "execution_count": 74,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "mapa1 = map(lambda y: y[1], \n",
    "        filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    ")\n",
    "[it for it in mapa1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatywnie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[('apple', 5), ('orange', 3)], [('peaches', 2)]]"
      ]
     },
     "execution_count": 75,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sklejamy listę list w jedną listę:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('apple', 5), ('orange', 3), ('peaches', 2)]"
      ]
     },
     "execution_count": 76,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "from itertools import chain\n",
    "list(chain(\n",
    "    *map(lambda y: y[1], \n",
    "        filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    "    )\n",
    "))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('apple', 5), ('orange', 3), ('peaches', 2)]"
      ]
     },
     "execution_count": 77,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "list(chain(*[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mapujemy listę tupli na listę liczb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 3, 2]"
      ]
     },
     "execution_count": 78,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "mapa2 = map(lambda f: f[1], \n",
    "    chain(\n",
    "        *map(lambda y: y[1], \n",
    "            filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    "        )\n",
    "    )\n",
    ")\n",
    "[it for it in mapa2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalnie redukujemy listę do sumy elementów:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 79,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "sum( \n",
    "    map(lambda f: f[1], \n",
    "        chain(\n",
    "            *map(lambda y: y[1], \n",
    "                filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    "            )\n",
    "        )\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 80,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "sum(it[1] for it in chain(*[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy także użyć gotowego operatora dodawania z modułu operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 81,
     "output_type": "execute_result",
     "metadata": {}
    }
   ],
   "source": [
    "import operator\n",
    "import functools\n",
    "functools.reduce(operator.add, \n",
    "    map(lambda f: f[1], \n",
    "        chain(\n",
    "            *map(lambda y: y[1], \n",
    "                filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    "            )\n",
    "        )\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Słowniki (dict) - zaawansowane użycie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aktualizacja słownika innym słownikiem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def some_function(**kwargs):\n",
    "    defaults = {\n",
    "        'apple': 1,\n",
    "        'orange': 2,\n",
    "        'peach': 3,\n",
    "    }\n",
    "    defaults.update(kwargs)\n",
    "    print(defaults)\n",
    "    print('banana' in defaults)\n",
    "\n",
    "some_function()\n",
    "some_function(apple=10)\n",
    "some_function(banana=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_dict = {key: value for key, value in [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')]}\n",
    "new_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generatory i iteratory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Generatorów i iteratorów używamy, aby oszczędzić pamięć (a także czas potrzebny na jej alokację). \n",
    "* Zysk wydajności powstaje przez ominięcie potrzeby tworzenia tymczasowych struktur pośrednich w pamięci, gdy zamiast tego możemy przeiterować kolejno po elementach i finalnie zapisać tylko te, które są potrzebne.\n",
    "* Iterable - obiekt posiadający metodę ``__iter__()`` zwracającą iterator. Przykłady:\n",
    "    * kolekcje: lista, krotka, słownik\n",
    "    * generatory (tutaj metoda ``__iter()__`` jest generowana automatycznie)\n",
    "* Iteratorem jest dowolny obiekt (kolekcja), dostarczający interfejs o następujących metodach:\n",
    "    * ``__iter__()`` - zwraca obiekt iteratora (jeśli wywołana na kolekcji)\n",
    "    * ``__next__()`` - zwraca kolejny element iteratora lub rzuca wyjątkiem StopIteration \n",
    "* Interfejsu iteratorów nie używamy najczęściej sami w kodzie, obiekty iteratorów pojawiają się w kontekstach iteracji i są używane automatycznie\n",
    "* Każda funkcja posiadająca wyrażenie yield jest generatorem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iteratory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,\"X\",3.14]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# czy obiekt l (lista) ma atrybut __iter__ ?\n",
    "'__iter__' in dir(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pobieramy iterator\n",
    "it = iter(l) \n",
    "# it = l.__iter__() # alternatywnie\n",
    "type(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iterujemy\n",
    "next(it)\n",
    "# it.__next__() # alternatywnie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(10)\n",
    "dir(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "it = iter(r)\n",
    "type(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "next(it)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generator expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generator można także wyrazić za pomocą konstrukcji ``(wyrażenie for zmienne in sekwencja)``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = (i*i for i in range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### metoda ``yield``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n=100):\n",
    "    a, b = 0, 1\n",
    "    while b < n:\n",
    "        yield b\n",
    "        a, b = b, a+b\n",
    "    else:\n",
    "        raise StopIteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fib()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "it = iter(fib())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "next(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(it)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehension (jeszcze raz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Technicznie więc ujmując **list comprehension = lista + wyrażenie generatora**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[i*i for i in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Moduł itertools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Szczególnie wart uwagi jest moduł itertools, który dostarcza bardzo wiele ciekawych narzędzi pracujących na iteratorach, pomocnych przy zaawansowanym programowaniu funkcyjnym. Wybrane ciekawe funkcje:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import * # normalnie tak nie importujemy \n",
    "list(chain([1, 2, 3], [4, 5, 6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(combinations('ABCD', 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(permutations('ABCD', 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(combinations_with_replacement('ABCD', 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(product('ABC', 'XY'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = permutations('ABC', 2)\n",
    "print(iterator)\n",
    "print(list(iterator))\n",
    "print(list(iterator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = permutations('ABC', 2)\n",
    "iterator1, iterator2 = tee(iterator, 2)\n",
    "print(iterator1, iterator2)\n",
    "print(list(iterator1))\n",
    "print(list(iterator2))\n",
    "print(list(iterator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3.0
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}