6. Funkcje.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definiowanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funkcje definiuje się przy pomocy słowa kluczowego def:\n",
    "```\n",
    "def nazwa([parametry]):\n",
    "    \n",
    "    ...\n",
    "    \n",
    "    [return [wartość]]\n",
    "```    \n",
    "jeżeli funkcja \"nie zwraca nic\" (nie ma nigdzie słowa kluczowego return) to funkcja zwraca None. Tak samo w przypadku kiedy funkcja ma wpisaną instrukcję return, ale nie ma podanej konkretnej wartosci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "def f():\n",
    "    return 2\n",
    "print(f())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    print('f')\n",
    "\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    print( 'f')\n",
    "    return\n",
    "\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do funkcji można dodawać docstring - drobną dokumentację. jest to string umieszczony pod nazwą funkcji przy definicji:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    \"\"\"\n",
    "    docstring funkcji f\n",
    "    \"\"\"\n",
    "    \n",
    "print( f.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    \"docstring funkcji f\"\n",
    "    \n",
    "print(f.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcji w pythonie nie przeciąża się - każda kolejna definicja funkcji przykrywa poprzednią funkcję o tej samej nazwie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    print('pierwsza')\n",
    "\n",
    "def f(arg):\n",
    "    print('druga')\n",
    "\n",
    "    \n",
    "print(f(0))\n",
    "print(f())  # brak wymaganego argumentu - arg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ponieważ funkcje są \"first-class citizens\" (mają takie same właściwosci jak inne obiekty) to możemy przypisać funkcję do zmiennej:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    print('f')\n",
    "\n",
    "print(f)\n",
    "g = f\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f()\n",
    "g()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nic nie stoi na przeszkodzie żeby metodę obiektu też przypisać do zmiennej:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 4, 5, 3, 4, 6, 1, 2, 4, 3, 5, 6, 4]\n",
    "c = x.count  # tworzy alias do metody count listy x\n",
    "print(c(1))\n",
    "print(c(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "oryginalną funkcję można usunąć i używać aliasu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del f\n",
    "g()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# funkcja g ma zachowaną nazwę funkcji f\n",
    "\n",
    "print(g.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Od strony interpretera tworzenie funkcji wygląda następująco:\n",
    "1. Python interpretuje kod funkcji jako code object\n",
    "2. Python tworzy obiekt funkcji do którego przypisuje poprzednio stworzony kod i inne argumenty - m. in. \\__name\\__, do którego przypisuje nazwę nadaną podczas definicji\n",
    "3. Python przypisuje obiekt funkcji do zmiennej o nazwie tej funkcji\n",
    "\n",
    "Nazwę funkcji można zmienić:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 2\n",
    "# żeby zmienić nazwę funkcji, należy ustawić wartość atrybutu __name__\n",
    "g.__name__ = 'kot-2'\n",
    "print(g)\n",
    "# "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#python 3\n",
    "# żeby zmienić nazwę funkcji, należy ustawić wartość atrybutu __qualname__\n",
    "g.__name__ = 'kot-3'\n",
    "g.__qualname__ = 'kot-3'\n",
    "print(g)  # metody __repr__ i __str__ funkcji/klas wyświetlają __qualname__ zamiast __name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\_\\_qualname\\_\\_ w Pythonie 3 oznacza bezpośrednią \"ścieżkę\" do funkcji/klasy z poziomu modułu oddzieloną kropkami. w Pythonie 2 \\_\\_qualname\\_\\_ nie funkcjonuje.\n",
    "\n",
    "I ma więcej sensu przy zagnieżdżonych klasach i funkcjach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python3\n",
    "class A:\n",
    "    def f(self):\n",
    "        pass\n",
    "    \n",
    "print(A.f.__name__)\n",
    "print(A.f.__qualname__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "również kod źródłowy można \"przeszczepić\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 2\n",
    "\n",
    "def f():\n",
    "    print('f')\n",
    "    \n",
    "def g():\n",
    "    print('g')\n",
    "    \n",
    "\n",
    "f()\n",
    "g()\n",
    "    \n",
    "f.func_code = g.func_code\n",
    "\n",
    "f()\n",
    "g()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 3\n",
    "\n",
    "def f():\n",
    "    print('f')\n",
    "    \n",
    "def g():\n",
    "    print('g')\n",
    "    \n",
    "\n",
    "f()\n",
    "g()\n",
    "    \n",
    "f.__code__ = g.__code__\n",
    "\n",
    "f()\n",
    "g()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parametry\n",
    "To ciąg nazw zmiennych używanych w kodzie źródłowym funkcji:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, b, c):\n",
    "    print(a, b, c)\n",
    "    \n",
    "f(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parametrom można przypisywać domyślne wartości - jednek każdy parametr deklarowany po parametrze z wartoscią domyślną, również musi mieć wartosć domyślną"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, b, c=1):\n",
    "    pass\n",
    "\n",
    "print('=' * 10)\n",
    "def f(a, b, c=9, d):  # SyntaxError\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do argumentów można się odwoływać poprzez nazwę"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, b, c):\n",
    "    print(a, b, c)\n",
    "    \n",
    "f(c=1, a=2, b=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wywołanie funkcji z wartosciami domyślnymi:\n",
    "def f(a, b, c=6):\n",
    "    print(a, b, c)\n",
    "    \n",
    "f(1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parametry mające wartosci domyślne nazywa się tez \"keywords\"\n",
    "\n",
    "\n",
    "W Pythonie można obsłuzyc zmienną liczbą argumentów pozycyjnych i keywordsów.\n",
    "osiąga się to przez użycie \\* lub \\*\\*. \\*oznacza argumenty pozycyjne, a \\*\\* oznacza słowa kluczowe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(*args, **kwargs):\n",
    "    print('args:', args)\n",
    "    print('kwargs:', kwargs)\n",
    "    \n",
    "f(1, 2, 3, 4, 5, 6, a=33, b='a', c='1.9')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Można zmienić kolejność słów kluczowych i unpackingu, ale unpacking i tak będzie \"przesunięty na poczatek sygnatury\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, b):\n",
    "    print(a, b)\n",
    "\n",
    "f(b=2, *(1, ))\n",
    "print('>>><<<')\n",
    "f(a=2, *(1, ))  #  TypeError - Python najpierw układa argumenty pozycyjne a potem przekazuje słowa kluczowe!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pythona 3.5+\n",
    "# można przekazywać wiele sekwencji do unpackingu:\n",
    "\n",
    "def f(a, b, c, d, log=None, debug=False):\n",
    "    print('a, b, c, d, log, debug:', a, b, c, d, log, debug)\n",
    "    \n",
    "l1 = ['a', 'b']\n",
    "l2 = ['c', 'd']\n",
    "d1 = {'log': 1}\n",
    "d2 = {'debug': True}\n",
    "\n",
    "f(*l1, *l2, **d1, **d2)\n",
    "\n",
    "# ale nie można mieszać unpackingu list i słowników:\n",
    "# f(*l1, **d1, *l2, **d2) - SyntaxError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Adnotacje**\n",
    "\n",
    "W Pythonie 3, dodane zostały adnotacje - pozwalają na określenie jakiego typu powiny być argumenty i co funkcja zwraca - ale nie ma sprawdzania typów.\n",
    "\n",
    "Adnotacje przechowywane są w atrybucie \\_\\_annotations\\_\\_ funkcji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 3\n",
    "def suma(a: int, b:int, c) -> int:  # nie do każdego argumentu trzeba dawać adnotacje - również -> jest opcjonalne\n",
    "    return int(a + b + c)\n",
    "\n",
    "print(suma(1.0, 2.0, 3))\n",
    "\n",
    "print(suma.__annotations__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UWAGA - Mutowalne wartosci domyślne\n",
    "Szczególną uwagę należy zachować przy ustawieniu typów mutowalnych jako argument domyślny funkcji - Python tworzy instancję tego obiektu **podczas definicji** a nie wywołania funkcji co może skutkować modyfikacją tego obiektu pomiędzy wywołaniami"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(l=[]):\n",
    "    l.append(3)\n",
    "    return l\n",
    "\n",
    "print(f())\n",
    "print(f([]))\n",
    "print(f())  # Wynik nie będzie taki jak oczekiwany"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zamiast ustawiania typów mutowalnych jako wartosci domyśłne powinno się ustawiać je na None i wewnatrz funkcji je tworzyć"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(l=None):\n",
    "    if l is None:\n",
    "        l = []\n",
    "    l.append(3)\n",
    "    return l\n",
    "\n",
    "print(f())\n",
    "print(f([]))\n",
    "print(f())  # Teraz działa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Keyword-only args**\n",
    "\n",
    "W Pythonie 3, możliwe jest zadeklarowanie argumentów jako keyword-only.\n",
    "\n",
    "argumenty keyword-only mogą być przekazywane tylko przez podanie ich nazwy przy wywołaniu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 3\n",
    "\n",
    "def suma(a, b, *_, wypisz=False):\n",
    "    print('_:', _)  # to i tak wypiszemy\n",
    "    if wypisz:\n",
    "        print('a: {}, b:{}'.format(a, b))\n",
    "    return a + b\n",
    "    \n",
    "print(suma(1, 2))  # zwraca sumę 1 + 2\n",
    "print()\n",
    "print(suma(1, 2, 3))  # zwraca sumę 1 + 2; 3 wpadnie do _; wypisz=False\n",
    "print()\n",
    "print(suma(1, 2, 3, 4, 5))  # zwraca sumę 1 + 2; 3, 4, 5 wpadnie do _; wypisz=False\n",
    "print()\n",
    "\n",
    "print(suma(1, 2, wypisz=True))  # jedyna możliwosć ustawienia wypisz na True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dla uproszczenia składni, zwłaszcza, jeżeli pozostałe argumenty pozycyjne nie są istotne, można zostawić samą \\* w sygnaturze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python 3\n",
    "def suma(a, b, *, wypisz=False):\n",
    "    ...\n",
    "    # dalej jest to samo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Call by sharing - przekazywanie argumentów mutowalnych do funkcji\n",
    "W Pythonie argumenty przekazywane są metodą \"call by sharing\" - jest to podobne do przekazywania przez referencję w innych językach - póki do tej zmiennej nie zostanie przypisany nowy argument, modyfikujemy oryginalny obiekt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(l):\n",
    "    l.append(3)\n",
    "    l = []\n",
    "    return l\n",
    "\n",
    "l = []\n",
    "print(f(l))\n",
    "print(l)  # <- oryginalna lista zmodyfikowana\n",
    "\n",
    "print(10 * '=')\n",
    "\n",
    "def f(l):\n",
    "    l = []\n",
    "    l.append(3)\n",
    "    return l\n",
    "\n",
    "l = []\n",
    "print(f(l))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operatory +=, -=, \\*=... również modyfikują obiekty **mutowalne** w miejscu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# przykład\n",
    "x = []\n",
    "print(id(x))\n",
    "x += [2]\n",
    "print(id(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkcje Anonimowe - lambdy\n",
    "\n",
    "lambdy definiujemy przy pomocy słowa kluczowego *lambda*.\n",
    "Zaletą lambd jest to, że mogą być przekazywane jako argumenty do innych funkcji podczas ich definiowania. Składnia jest następująca:\n",
    "\n",
    "```lambda [argumenty]: [wartosć zwracana]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(func):\n",
    "    print(func())\n",
    "    \n",
    "f(lambda: 22)  # lambda, która nie przyjmuje argumentów a zwraca 22\n",
    "\n",
    "# generalnie argumenty można tak samo określać jak dla \"normalnych\" funkcji\n",
    "suma = lambda a, b: a + b  # lambda przyjmująca argumenty a i b, a zwracajaca ich sumę\n",
    "suma2 = lambda *args: sum(args)  # lambda przyjmuje niezdefiniowaną liczbę argumentów i zwraca ich sumę\n",
    "suma3 = lambda *args, **kwargs: ...  # to damo co def suma(*args, **kwargs): ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Domknięcia\n",
    "\n",
    "zakres okalający funkcje to jej domknięcie, a zmienne w tym zakresie to free-variables (nie są skojarzone z zakresem lokalnym funkcji (bound variables) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ponieważ wartosci \"z otoczenia\" brane są dopiero w czasie wykonania funkcji a nie definicji, łatwo mozna nadziać sie na pewien problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# problem - chcemy stworzyć funkcję, która zwraca listę funkcji mnożący zadany argument przez 1, 2, 3 i 4\n",
    "\n",
    "def multiplater_factory():\n",
    "    return [lambda x: x * i for i in range(1, 5)]  # oczekujemy, ze zwróci listę 4 funkcji,\n",
    "                                                   # z których każda będzie mnożyć argument\n",
    "                                                   # przez inną liczbę\n",
    "\n",
    "multipliers = multiplater_factory()\n",
    "for f in multipliers:\n",
    "    print(f(3))  # lipa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to co wcześniej tylko nie przez list comprehension\n",
    "def multiplater_factory():\n",
    "    lista = []\n",
    "    for i in range(1, 5):\n",
    "        lista.append(lambda x: x * i)\n",
    "    return lista\n",
    "\n",
    "multipliers = multiplater_factory()\n",
    "for f in multipliers:\n",
    "    print(f(3))  # znowu lipa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to co wcześniej tylko nie przez lambdy\n",
    "def multiplater_factory():\n",
    "    lista = []\n",
    "    for i in range(1, 5):\n",
    "        def mult(x):\n",
    "            return x * i\n",
    "        lista.append(mult)\n",
    "    return lista\n",
    "\n",
    "multipliers = multiplater_factory()\n",
    "for f in multipliers:\n",
    "    print( f, f(3))  # znowu lipa - a funkcje rózne\n",
    "    \n",
    "    \n",
    "# wyjaśnienie dalej"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcje pobierają wartości zmiennych spoza swojego bloku podczas wykonania a nie definicji - czyli w czasie definicji funkcji zmienne w otoczeniu mogą nie istnieć bo będą pobierane dopiero przy wykonaniu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "x = 4\n",
    "def f():\n",
    "    print(x)\n",
    "    \n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "x = 4\n",
    "def f():\n",
    "    print(x)\n",
    "   \n",
    "x = 5\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    print(x)  # gdyby brało wartość x podczas definicji to powinien być bład\n",
    "   \n",
    "x = 5\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# jeszcze raz ten sam przykład z multiplierami tylko ręcznie ustawiamy wartość zmiennej i\n",
    "# (wcześniej ta wartość była ustawiana w pętli)\n",
    "def multiplater_factory():\n",
    "    lista = []\n",
    "    for i in range(1, 5):\n",
    "        def mult(x):\n",
    "            return x * i\n",
    "        lista.append(mult)\n",
    "    i = 33\n",
    "    return lista\n",
    "\n",
    "multipliers = multiplater_factory()\n",
    "for f in multipliers:\n",
    "    print(f(3))  # teraz mnożymy przez 33 - czyli to i co zostało ręcznie ustawione w bloku\n",
    "                 # okalającym funkcję"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Żeby sobie z tym poradzić, trzeba w jakiś sposób \"zaprosić\" zmienną do zakresu funkcji - np, przez dawanie jej jako argumentu domyślnego podczas definicji - instancjalizowanego podcas definicji na ówczesną wartosć \"i\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiplater_factory():\n",
    "    lista = []\n",
    "    for i in range(1, 5):\n",
    "        def mult(x, i=i):  # <- tutaj zmiana\n",
    "            return x * i\n",
    "        lista.append(mult)\n",
    "    return lista\n",
    "\n",
    "multipliers = multiplater_factory()\n",
    "for f in multipliers:\n",
    "    print( f, f(3))  # Działa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zmienne lokalne i domknięcia - Uwaga\n",
    "\n",
    "Jeżeli w bloku pojawia się zmienna lokalna na której wykonywane są jakieś operacje, a przypisanie jest późniejszej linijce, można natknąć się na UnboundLocalError.\n",
    "Dzieje się tak dlatego, ze przy kompilowaniu bloku funkcji, python zapisuje sobie wszystkie zmienne lokalne, i zmienna do której się przypisuje jakiś obiekt w bloku funkcji jest traktowana jako lokalna i jest brana z lokalnego zakresu, w którym może być jeszcze nie zdefiniowana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2/3\n",
    "\n",
    "x = 2  # zmienna w zewnętrznym zakresie\n",
    "\n",
    "def f():  # ta funkcja będzie działać\n",
    "    print('f')\n",
    "    x + 2\n",
    "    \n",
    "def g():  # tu będzie błąd\n",
    "    print('g')\n",
    "    y = x + 2  # wydaje się, że Python sięgnie do zewnętrzego zakresu, ale nie!\n",
    "    x = 2 * y  # ponieważ tutaj jest przypisanie to python kompilując sobie cały blok funkcji zapisze x jako\n",
    "               # zmienną lokalną - a w poprzeniej linijce jest odwołanie się do zmiennej lokalnej, ale wtedy nie\n",
    "               # jest ona jeszcze zainicjalizowana. dlatego mamy UnboundLocalError\n",
    "   \n",
    "print('f.__code__.co_varnames:', f.__code__.co_varnames)  # pusta krotka zmiennych lokalnych\n",
    "f()\n",
    "print('>>><<<')\n",
    "print('g.__code__.co_varnames:', g.__code__.co_varnames)  # są 2 zmienne - x i y\n",
    "g()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inną rzeczą, na którą trzeba zwrócić uwagę przy free-variables, jest to, że one są brane z zakresu okalającego - ale tego podczas definicji (a jak niema tego w bezpośrednio okalającym to idzie z jeszcze bardziej okalającego):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    print(x)\n",
    "    \n",
    "def g(func):\n",
    "    x = 33\n",
    "    func()\n",
    "    \n",
    "g(f)  # x jest w przestrzeni funkcji g - ale funkcja f szuka x w swoim domknięciu - czyli zakresie globalnym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to samo tylko wrzucimy x do g\n",
    "\n",
    "def f():\n",
    "    print(x)\n",
    "    \n",
    "def g(func):\n",
    "    x = 33\n",
    "    func()\n",
    "\n",
    "x = 44\n",
    "g(f)  # x jest wzięte z linijki powyżej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67\n"
     ]
    }
   ],
   "source": [
    "# domknięcie funkcji f jest w funkcji g\n",
    "    \n",
    "def g():\n",
    "    def f():\n",
    "        print(x)\n",
    "    x = 67  # teraz ten x będzie w domknięciu funkcji f\n",
    "    return f  # żeby wydobyć tę fukncję ze środka\n",
    "\n",
    "f = g() # wydobywamy f\n",
    "x = 45  # definicja x w przestrzeni modułu\n",
    "f()  # wzięło 67 - to logiczne, przecież x będace z zakresie okalającym funkcji wynici 67 i jest wewnątrz funkcji g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "# domknięcie funkcji f jest w funkcji g\n",
    "    \n",
    "def g():\n",
    "    def f():\n",
    "        print(x)\n",
    "    return f \n",
    "\n",
    "f = g() # wydobywamy f\n",
    "x = 45  # teraz weźmie tego x - ponieważ w domknięciu (wnętrze funkcji g) nie ma x, to sięga do zakresu go\n",
    "f()     # okalającego, czyli do zakresu globalnego"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dekoratory\n",
    "\n",
    "Wiemy, że funkcje to first-class citizens - czyli mozna je m.in przekazywać jako argumenty do innych funkcji. Wykorzystajmy to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dekorator v 1.0\n",
    "\n",
    "def f(func):\n",
    "    print(\"teraz wywoluje: \", func.__name__)\n",
    "    val = func()\n",
    "    print(\"koniec wywolania, wartosc zwrocona: \", val)\n",
    "    return val\n",
    "\n",
    "def g():\n",
    "    print('funkcja g')\n",
    "    return 23\n",
    "\n",
    "var = f(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dekorator v 1.1\n",
    "\n",
    "# w ten sposób stworzylismy sobie dekorator - funkcję,\n",
    "# która dodała jakąś funkcjonalność do innej fukncji - jest to bardzo prymitywna forma\n",
    "\n",
    "# czasami jest tak, zę funkcja dekorująca jest użyteczna - np. dodaje śledzenie wywołania\n",
    "# (jak ta funkcja wcześniej) - niestety poprzednią funkcja musimy za każdym razem wywoływać\n",
    "# kiedy chcemy, żeby wywołanie było rejestrowane - a nie zawsze jest to pożądane\n",
    "\n",
    "# Zamiast tego, możemy stworzyć funkcje, która przyjmuję jedną funkcją i zwraca inną,\n",
    "# ale wywołującą naszą pierwszą funkcję:\n",
    "\n",
    "def dekorator(func):\n",
    "    def podrasowana_funkcja():\n",
    "        print('wywoluje: ', func)\n",
    "        var = func()\n",
    "        print('otrzymana wartosc: ', var)\n",
    "        return var\n",
    "    return podrasowana_funkcja\n",
    "\n",
    "podrasowane_g = dekorator(g)\n",
    "podrasowane_g()\n",
    "\n",
    "print(\"dekoratorowanie oryginału\")\n",
    "# jezeli chcemy \"nadpisać\" funkcję g - nie ma problemu:\n",
    "g = dekorator(g)\n",
    "g()  # teraz funkcja g jest podrasowana \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dekorator z użyciem @ - lukier składniowy\n",
    "# żeby za każdym razem nie dekorować ręcznie - dodany został operator @:\n",
    "\n",
    "@dekorator\n",
    "def h():\n",
    "    print('ha ha ha')\n",
    "    return 55\n",
    "\n",
    "h()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dekorator z argumentami\"\n",
    "# Mamy przypadek kiedy dekorowana funkcja nie przyjmuje argumentów - \n",
    "# a to raczej rzadki przypadek. Dodamy obsługę argumentów\n",
    "\n",
    "# Generalnie, żeby dekorator był uzyteczny dla danej funkcji,\n",
    "# powinien przyjmować takie same argumenty - lub ogólnie - *args i **kwargs\n",
    "\n",
    "def dekorator(func):\n",
    "    def funkcja_koks(*args, **kwargs):\n",
    "        print('funkcja koks: ', func, args, kwargs)\n",
    "        var = func(*args, **kwargs)\n",
    "        print('koniec funkcji koksa: ', var)\n",
    "        return var\n",
    "    return funkcja_koks\n",
    "\n",
    "\n",
    "@dekorator\n",
    "def suma(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(suma.__name__)  # to już inna funkcja\n",
    "print(suma(1, 3))     # ale działa tak samo\n",
    "\n",
    "# suma(1, 2, 3, 4, 5)  # czyżby? - przyjęła wszystkie argumenty\n",
    "# suma(a=1, b=2, c=3)  # słowa kluczowe też...\n",
    "\n",
    "# niestety to inna funkcja, ale każdy kto spojrzy na definicję będzie wiedział\n",
    "# jakie parametry przekazać\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dekorator - functools.wraps\n",
    "# żeby zachować oryginale atrybuty funkcji, np. __doc__ w module functools jest dekorator wraps:\n",
    "# którym dekorujemy funkcję_koksa\n",
    "\n",
    "from functools import wraps\n",
    "\n",
    "def dekorator(func):\n",
    "    @wraps(func)\n",
    "    def funkcja_koks(*args, **kwargs):\n",
    "        print('funkcja koks: ', func, args, kwargs)\n",
    "        var = func(*args, **kwargs)\n",
    "        print('koniec funkcji koksa: ', var)\n",
    "        return var\n",
    "    return funkcja_koks\n",
    "\n",
    "\n",
    "@dekorator\n",
    "def suma(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(suma.__name__)  # ta sama nazwa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dekoratory sparametryzowane\n",
    "Dekoratory można sparametryzować, żeby \"wyciągnąć\" z nich jeszcze więcej np:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# @log_do_pliku(plik='file.log')\n",
    "# def restart_bsc():\n",
    "#     pass\n",
    "\n",
    "\n",
    "# takie dekoratory możemy robić przy pomocy klas, albo funkcji\n",
    "from functools import wraps\n",
    "\n",
    "class dekorator(object):\n",
    "    def __init__(self, parametr1=None, parametr2=None):\n",
    "        print('parametryzacja: ', parametr1, parametr2)\n",
    "        self.p1 = parametr1\n",
    "        self.p2 = parametr2\n",
    "    \n",
    "    def __call__(self, func):  # Python nie sprawdza czy dekorator jest funkcją czy klasą, tylko wywołuje ten obiekt\n",
    "        @wraps(func)           # trzeba przeciążyć ()\n",
    "        def inner(*a, **kw):\n",
    "            print('poczatek wywolania: ', func)\n",
    "            var = func(*a, **kw)\n",
    "            print('po wywolaniu')\n",
    "            return var\n",
    "        return inner\n",
    "        \n",
    "\n",
    "@dekorator(1, 2)\n",
    "def suma(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(suma(1, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ten sam efekt można uzyskać używajac funkcji:\n",
    "def dekorator(parametr1=None, parametr2=None):\n",
    "    def wlasciwy_dekorator(func):\n",
    "        print('parametryzacja: ', parametr1, parametr2)\n",
    "        @wraps(func)\n",
    "        def inner(*a, **kw): # to będzie ulepszona funkcja, ale jeszcze nie jest gotowa w 100% - nie ma pewnosci co do func\n",
    "            print('poczatek wywolania: ', func)\n",
    "            var = func(*a, **kw)\n",
    "            print('po wywolaniu')\n",
    "            return var\n",
    "        return inner\n",
    "    return wlasciwy_dekorator\n",
    "    \n",
    "    \n",
    "@dekorator(parametr1=1, parametr2=2)\n",
    "def suma(a, b):\n",
    "    return a + b\n",
    "\n",
    "print( suma(1, 3))\n",
    "\n",
    "\n",
    "print( 50 * '=')\n",
    "@dekorator()  # problem jest taki, że zawsze trzeba tutaj tę funkcje Dekorator wywołać - inaczej będzie bład\n",
    "def suma(a, b):\n",
    "    return a + b\n",
    "\n",
    "print( suma(1, 3))\n",
    "\n",
    "# @dekorator  # teraz będzie błąd\n",
    "# def suma(a, b):\n",
    "#     return a + b\n",
    "\n",
    "# print suma(1, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parametry i funkcja w jednym miejscu\n",
    "\n",
    "# 1. idea jest prosta: pierwszy argument to jest dekorowana funkcja - jeżeli wywołanie bedzie @dekorator, to python\n",
    "# automatycznie przekaze funkcje jako pierwszy paramert dekoratora\n",
    "# kolejne argumenty to parametry. w Pythonie 3 można je ustawić jako keyword-only\n",
    "\n",
    "# 2. w dalszej cześci definiujemy funkcję wewnątrzną - dokładnie tak jak w przypadku niesparametryzowanego dekoratora\n",
    "\n",
    "# 3. sprawdzanie czy został przekazany parametr func - jeżeli tak, to znaczy, że Python automatycznie przekazał\n",
    "# funkcję do dekoracji, a jeżeli nie - to znaczy że jest to wywołanie z parametrami - wtedy należy zwrócić dekorator,\n",
    "# do którego Python przekaże definiowaną funkcję\n",
    "\n",
    "def dekorator(func=None, parametr1=None, parametr2=None):\n",
    "    def wlasciwy_dekorator(func):\n",
    "        print('parametryzacja: ', parametr1, parametr2)\n",
    "        @wraps(func)\n",
    "        def inner(*a, **kw): # to będzie ulepszona funkcja, ale jeszcze nie jest gotowa w 100% - nie ma pewnosci co do func\n",
    "            print('poczatek wywolania: ', func)\n",
    "            var = func(*a, **kw)\n",
    "            print('po wywolaniu')\n",
    "            return var\n",
    "        return inner\n",
    "    if func is not None:\n",
    "        return wlasciwy_dekorator(func)\n",
    "    else:\n",
    "        return wlasciwy_dekorator\n",
    "    \n",
    "    \n",
    "@dekorator(parametr1=1, parametr2=2)  # parametry możńa przekazywać tylko jako słowa kluczowe\n",
    "def suma(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(suma(1, 3))\n",
    "\n",
    "\n",
    "@dekorator  # bez parametrów funkcja jest dekorowana od razu\n",
    "def suma(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(suma(1, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dekorowanie funkcji wieloma dekoratorami\n",
    "\n",
    "Dekoratory z wielokrotnie dekorowanej funkcji są uruchamiane \"od dołu\" - im bliżej dekorowanej funkcji tym wcześniej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dec1(func):\n",
    "    print(\"dec1\")\n",
    "    return func\n",
    "    \n",
    "def dec2(func):\n",
    "    print(\"dec2\")\n",
    "    return func\n",
    "\n",
    "def dec3(func):\n",
    "    print(\"dec3\")\n",
    "    return func\n",
    "\n",
    "def dec4(func):\n",
    "    print(\"dec4\")\n",
    "    return func\n",
    "\n",
    "\n",
    "@dec4\n",
    "@dec3\n",
    "@dec2\n",
    "@dec1\n",
    "def f():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkcje wyższych rzędów\n",
    "\n",
    "Funkcje, które przyjmują inne funkcje jako parametry są zwane funkcjami wyższego rzędu.\n",
    "Takie funkcje to m. in. map i filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(help(map))\n",
    "print(help(filter))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = map(lambda x: x**2, range(4))\n",
    "print(x)\n",
    "print(filter(lambda x: x%2, x))\n",
    "\n",
    "# praktyce to samo uzyskuje się uzywając list comprehension:\n",
    "x = [i**2 for i in range(5)]\n",
    "print(x)\n",
    "print([i for i in x if i%2])\n",
    "\n",
    "# lub krócej:\n",
    "print([i**2 for i in range(5) if i%2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map i Filter a wersja Pythona\n",
    "\n",
    "W Pythonie 2 map, filter i range zwracają listy, natomiast w Pythonie 3 generatory (obiekty typu map, filter, range). W Pythonie 2 odpowiednikiem range w Pythonie 3 jest xrange a w module itertools Python 2 ma zdefiniowane imap i ifilter, które są odpowiednikami map i filter w PYthonie 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inne przydatne funkcje\n",
    "\n",
    "dużo przydatnych funkcji do programowania funkcyjnego znajduje się w module functools.\n",
    "Inne przydatne funkcje mogą też znaleźć się w module itertools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "import itertools\n",
    "import operator\n",
    "\n",
    "print(dir(functools))\n",
    "print(dir(itertools))\n",
    "print(dir(operator))  # przydatne operatory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "# functools.partial pozwala na cześciowe wypełnienie argumentów funkcji\n",
    "def suma(a, b):\n",
    "    print('argumenty sumy: a={}, b={}'.format(a, b))\n",
    "    return a + b\n",
    "\n",
    "suma4 = functools.partial(suma, 4)  # a to 4\n",
    "suma3 = functools.partial(suma, b=3)  # b to 3\n",
    "\n",
    "print(suma4(2))\n",
    "print(suma3(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import itemgetter\n",
    "\n",
    "get2 = itemgetter(2)  # get2[x] --> x[2]\n",
    "\n",
    "x = range(4)\n",
    "y = {2: 'b'}\n",
    "\n",
    "print(get2(x))\n",
    "print(get2(y))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "x = range(3)\n",
    "y = range(3, 5)\n",
    "x_y = itertools.chain(x, y)  # łaczy 2 listy w jedną\n",
    "print(x_y, list(x_y))\n",
    "\n",
    "print(15 * '-')\n",
    "c = itertools.count()  # niekończące sie odliczanie w górę\n",
    "for i in c:\n",
    "    print(i, end='')\n",
    "    if i == 5:\n",
    "        print()\n",
    "        break\n",
    "        \n",
    "        \n",
    "print(15 * '-')\n",
    "c = itertools.repeat(10, 4)  # 4 razy powtórzy liczbę 10 -\n",
    "                             # bez drugiego argumentu nieskończenie wiele razy\n",
    "print(c, list(c))\n",
    "\n",
    "print(15 * '-')\n",
    "# itertools.cycle(sekwencja) - powtarza sekwencję\n",
    "# itertools takewhile(pradykat, sekwencja) - bierze elementy z sekwencji,\n",
    "                                           # póki predykat jest prawdziwy\n",
    "# itertools.dropwhile(predykat, sekwencja) - j.w., tylko opuszcza elementy sekwencji\n",
    "c = itertools.takewhile(bool, [1, 2, 4, 6, 0, 3, 5, 4])\n",
    "print(c, list(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generatory\n",
    "Generator to funkcja, która zawiera w kodzie słowo yield (w Pythonie 2 nie może zawierać return).\n",
    "Głównym celem generatora jest \"zawieszenie\" wykonania kodu do czasu \"wybudzenia\" generatora.\n",
    "Kiedy utuchamiamy generator, kod jest wykonywany do czasu napotkania słowa yield - wtedy wartość następująca po yield jest \"zwracana\" i generator zawiesza działanie, żeby je wznowić, w Pythonie 2 należy wywołać metodę next() generatora a w Pythonie 3 wywołać funkcję next na generatorze - wtedy wywołanie zostanie wznowione aż do kolejnego napotkania yield.\n",
    "\n",
    "Kiedy instrukcje do wykonania zakończą się, wtedy generator wyrzuci wyjątek StopIteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    "# definicja generatora\n",
    "def counter():\n",
    "    s = 0\n",
    "    while True:\n",
    "        yield s\n",
    "        s += 1\n",
    "    \n",
    "print(counter)  # na tym etapie counter to jest funkcja\n",
    "# tworzymy instancję generatora\n",
    "count = counter()  # po wywołaniu counter() zwraca instancję generatora <generator object>\n",
    "print(count)\n",
    "print(count.next())  # pobieramy pierwszą wartosć generatora\n",
    "print(count.next())\n",
    "print(count.next())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "def counter():\n",
    "    s = 0\n",
    "    while True:\n",
    "        yield s\n",
    "        s += 1\n",
    "    \n",
    "print(counter)\n",
    "count = counter()\n",
    "print(count)\n",
    "print(next(count))\n",
    "print(next(count))\n",
    "print(next(count))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen():\n",
    "    s = 0\n",
    "    yield s\n",
    "    x = 1\n",
    "    yield x\n",
    "    y = 2\n",
    "    yield y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    "    \n",
    "g = gen()\n",
    "print(g.next())\n",
    "print(g.next())\n",
    "print(g.next())\n",
    "print(g.next())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "g = gen()\n",
    "print(next(g))\n",
    "print(next(g))\n",
    "print(next(g))\n",
    "print(next(g))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generatory mają równiez metodę send - pozwala przesłąć wartosć do generatora.\n",
    "Gdy generator zatrzymuje się na yield, wywołanie metody send spowoduje przekazanie obiektu do generatora i wywołanie metody next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def gen():\n",
    "    x = None\n",
    "    while True:\n",
    "        x = yield x     # oznacza to tyle - najpierw zostanie z'yeldowany' obiekt x, potem \n",
    "        print('x:', x)  # generator się zatrzyma i przesłąnie obiektu metodą send poskutkuje\n",
    "                        # przypisaniem nowego obiektu do zmiennej i iwykonanie kodu aż do\n",
    "                        # następnego zatrzymania - czyli z'yeldowania' x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    "                    \n",
    "g = gen()\n",
    "y = g.next()\n",
    "print(y)\n",
    "g.send(1)  # send najpierw wysyłą obiekt do generatora a potem wywoluje jego next()\n",
    "g.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = gen()\n",
    "y = next(g)\n",
    "print(y)\n",
    "g.send(1)  # send najpierw wysyłą obiekt do generatora a potem wywoluje jego next()\n",
    "next(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generatorów nie można wywoływać, kiedy są w trakcie wywołania (coś na kszatałt rekurencji)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    "\n",
    "def gen():\n",
    "    while True:\n",
    "        generator = yield  # przyjmujemy obiekt z zewnątrz\n",
    "        generator.next()   # bierzemy kolejny element otrzymanego generatora\n",
    "        \n",
    "\n",
    "g = gen()\n",
    "g.next()  # przeskakujemy do yield\n",
    "g.send(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "\n",
    "def gen():\n",
    "    while True:\n",
    "        generator = yield  # przyjmujemy obiekt z zewnątrz\n",
    "        next(generator)  # bierzemy kolejny element otrzymanego generatora\n",
    "        \n",
    "\n",
    "g = gen()\n",
    "next(g)  # przeskakujemy do yield \n",
    "g.send(g)  # wysyłamy samego siebie do pobrania kolejnej wartości"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W Pythonie 3 można używać return wewnątrz generatora, żeby zwrócić jakąś wartość (w Pythonie 2 return może być tylko puste).\n",
    "\n",
    "W przypadku użycia return, python wyrzuca wyjątek StopIteration (StopAsyncIteration w przypadku asynchronicznych generatorów - niżej) zainicjalizowany zwracaną wartością - w przypadku ręcznej obsługi wyjątku, obiekt jest przechowywany w atrybucie value wyjątku"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generator Expression\n",
    "\n",
    "Podobnie do Comprehensions funkcjonuje Generator Expression - to wyrażenie tworzy generator. \n",
    "Różnica pomiędzy List Comprehension to nawiasy () zamist [].\n",
    "\n",
    "Generator stworzony przez Generator expression jest od razu gotowy do użytku."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = (i for i in range(10))\n",
    "print(gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    "print(gen.next())\n",
    "print(gen.next())\n",
    "print(gen.next())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(next(gen))\n",
    "print(next(gen))\n",
    "print(next(gen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2/3\n",
    "# jeżeli generator expression jest przekazywane do funkcji to można pominąć nawiasy:\n",
    "\n",
    "def f(arg):\n",
    "    print(arg)\n",
    "    \n",
    "f((i for i in range(3)))  # generator expression z nawiasami\n",
    "f(i for i in range(3))  # generator expression bez nawiasów\n",
    "\n",
    "# ale jeżeli jest jeszcze inny argument to trzeba dodać nawiasy\n",
    "def f(arg1, arg2):\n",
    "    print(arg1, arg2)\n",
    "\n",
    "\n",
    "# f(i for i in range(3), 1)  # generator expression bez nawiasów - SyntaxError\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**yield from**\n",
    "\n",
    "W Pythonie 3.5 pojawia się nowa instarukcja *yield from*.\n",
    "\n",
    "Tworzy ona pomost pomiędzy wewnętrznym generatorem/ami - a światem zewnetrznym"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python3.5+\n",
    "\n",
    "def licznik():\n",
    "    wartosc = 0\n",
    "    while True:\n",
    "        yield wartosc\n",
    "        wartosc += 1\n",
    "        \n",
    "        \n",
    "def opakowanie():\n",
    "    licz = licznik()\n",
    "    yield from licz\n",
    "    \n",
    "    # a normalnie by było:\n",
    "    # while True:\n",
    "    #     yield next(licz)\n",
    "    \n",
    "    \n",
    "gen = opakowanie()\n",
    "print(next(gen))\n",
    "print(next(gen))\n",
    "print(next(gen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3.5+\n",
    "\n",
    "def wewnetrzny():\n",
    "    wartosc = 'initial'\n",
    "    while True:\n",
    "        print('>>>')\n",
    "        print('wartosc przed yieldem:', wartosc)\n",
    "        wartosc = yield wartosc\n",
    "        print('wartosc po yieldzie:', wartosc)\n",
    "        \n",
    "        \n",
    "def zewnetrzny():\n",
    "    g = wewnetrzny()\n",
    "    yield from g\n",
    "    \n",
    "    \n",
    "gen = zewnetrzny()\n",
    "print(next(gen))\n",
    "print(gen.send(2))  # wartosć z send jest przekazywane teraz do wewnetrznego generatora\n",
    "print(gen.send(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W pythonie 3.6 pojawiają się asynchroniczne generatory - są to generatory defioniowane *async def* zamiast *def*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "async def gen():\n",
    "    yield 23\n",
    "    \n",
    "g = gen()\n",
    "print(g)  # async generator"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}