L3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Język Python - Wykład 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![coś napisane w Pythonie](https://cdn-images-1.medium.com/max/1200/0*LStEb38q3d2sOffq.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "a = \"\"\"Hello\n",
    "world\"\"\"\n",
    "print(str(a))\n",
    "print(repr(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funkcje (c.d.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- nie można ich przeciążać\n",
    "- parametry mogą mieć wartości domyślne\n",
    "- mogą przyjmować argumenty pozycyjne lub nazwane (keyword argument)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Argumenty \\*args, \\**kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say_more(times, *args):\n",
    "    print(args)\n",
    "    print((', '.join(args) + \" | \") * times)\n",
    "\n",
    "say_more(3, 'one', 'two',)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def say_even_more(*args, **kwargs):\n",
    "    print(args)  # krotka\n",
    "    print(kwargs)  # słownik\n",
    "\n",
    "say_even_more(1, 2, 3, foo=4, bar=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "say_even_more(*(1, 2, 3), **{'foo': 4, 'bar': 5})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Zmienne globalne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    print(x)\n",
    "    \n",
    "x = 14\n",
    "func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def func():\n",
    "    x = 4\n",
    "    print(\"Inside:\", x)\n",
    "    \n",
    "x = 17\n",
    "func()\n",
    "print(\"Outside:\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def func():\n",
    "    print(x)\n",
    "    x = 12\n",
    "\n",
    "x = 8\n",
    "func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def func2():\n",
    "    global x\n",
    "    print('x is', x)\n",
    "    x = 2\n",
    "    print('Changed global x to', x)\n",
    "x = 50\n",
    "func2()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funkcje jako zmienne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def apply(f, x, y):\n",
    "    return(f(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "apply(add, 2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Closures (Domknięcia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Domknięcie - funkcja wraz z otoczeniem referencyjnym (wszystkie zmienne z czasu utworzenia) - dostępne nawet po opuszczeniu otoczenia leksykalnego"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funkcje zagnieżdżone:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer():\n",
    "    x = 137\n",
    "    def inner():\n",
    "        print(x)\n",
    "    x = 11\n",
    "    inner()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "outer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def outer(y):\n",
    "    def inner():\n",
    "        print(y)\n",
    "    return inner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "inner1 = outer(11)\n",
    "inner2 = outer(111)\n",
    "inner1()\n",
    "inner2()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Domknięcia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_power_func(n):\n",
    "    print(\"id(n): %X\" % id(n))\n",
    "    def nth_power(x):\n",
    "        return x**n\n",
    "    print(\"id(nth_power): %X\" % id(nth_power))\n",
    "    return nth_power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "raised_to_4 = generate_power_func(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "repr(raised_to_4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raised_to_4(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "sqr = generate_power_func(2)\n",
    "print(sqr(3))\n",
    "print(raised_to_4(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "nth_power(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "del generate_power_func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "generate_power_func(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "raised_to_4(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "raised_to_4.__closure__[0].cell_contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sqr.__closure__[0].cell_contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Domknięcia i zasięg zmiennych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer():\n",
    "    y = 137\n",
    "    def inner():\n",
    "        nonlocal y\n",
    "        print(\"inner\", y)\n",
    "        y = 0\n",
    "    print(\"outer pre\", y)\n",
    "    inner()\n",
    "    print(\"outer post\", y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Rejony poszukiwania symbolu:\n",
    "- symbole lokalne funkcji\n",
    "- symbole lokalne funkcji zewnętrznej\n",
    "- i jeszcze bardziej zewnętrznej\n",
    "- ...\n",
    "- symbole globalne (modułu)\n",
    "- symbole wbudowane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def outer():\n",
    "    z = 7\n",
    "    def medium():\n",
    "        z = 4\n",
    "        def inner():\n",
    "            nonlocal z\n",
    "            z = 3\n",
    "        inner()\n",
    "    medium()\n",
    "    print(z)\n",
    "\n",
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Domknięcie w Groovy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    def localMethod() {\n",
    "      def localVariable = new java.util.Date()\n",
    "      return { println localVariable }\n",
    "    }\n",
    "    def clos = localMethod()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Domknięcie w JavaScript"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    function createMarker(point, number) {\n",
    "        var marker = new GMarker(point);\n",
    "        var message = [\"This\",\"is\",\"the\",\"secret\",\"message\"];\n",
    "        marker.value = number;\n",
    "        GEvent.addListener(marker, \"click\", function() {\n",
    "            var myHtml = \"<b>#\" + number + \"</b><br/>\" +\n",
    "                message[number -1];\n",
    "            map.openInfoWindowHtml(point, myHtml);\n",
    "        });\n",
    "        return marker;\n",
    "    }\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dekoratory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logged(f):\n",
    "    def logged_f(*args, **kwargs):\n",
    "        print(\"Called {!r} with params {} and {}\".format(f.__name__, args, kwargs))\n",
    "        return f(*args, **kwargs)\n",
    "    return logged_f\n",
    "    \n",
    "say_even_more = logged(say_even_more)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "say_even_more(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "@logged\n",
    "def g(n):\n",
    "    print(\"Another simple method printing %d.\" % n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "g(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Example ...\n",
    "@synchronized\n",
    "@logging\n",
    "def myfunc(arg1, arg2, ...):\n",
    "    # ...do something\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Zmienne statyczne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def func():\n",
    "    if 'time' in dir(func):\n",
    "        func.time += 1\n",
    "    else:\n",
    "        func.time = 1\n",
    "    print(\"func called for the\", func.time, \"time\")\n",
    "    \n",
    "for _ in range(3):\n",
    "    func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listy - zaawansowane użycie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Przedłużanie listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "extend_list = [1, 2, 3]\n",
    "extend_list.extend(\"Ala ma kota\")\n",
    "extend_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Usuwanie z listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del extend_list[2]\n",
    "extend_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "del extend_list[1:3]\n",
    "extend_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "del extend_list\n",
    "print(extend_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Lista jako stos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stack = [3, 4, 5, 6, 7]\n",
    "stack.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "stack.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "stack.append(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "stack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "queue = [3, 4, 5, 6, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "queue.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "queue.append(10)\n",
    "queue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Zamiast tego lepiej użyć specjalnie do tego przeznaczonej struktury deque z modułu standardowego collections:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "queue.popleft()                 # The second to arrive now leaves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "queue                           # Remaining queue in order of arrival"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Programowanie funkcyjne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* filter - filtrowanie kolekcji\n",
    "* map - modyfikacja kolekcji\n",
    "* reduce - redukowanie kolekcji (wyliczanie wartości z jej elementów), w Python3 w module functools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Policzyć, ile owoców wspólnie mają Merry i Tom:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = {\n",
    "    'Merry': [\n",
    "        ('apple', 5),\n",
    "        ('orange', 3),\n",
    "    ],\n",
    "    'John': [\n",
    "        ('berries', 1),\n",
    "        ('orange', 10),\n",
    "    ],\n",
    "    'Tom' : [\n",
    "        ('peach', 2),\n",
    "    ],\n",
    "}\n",
    "list(fruits.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Filtrujemy \"bazę\" z owoców Johna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    "list(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Usuwamy imiona, nie są nam już potrzebne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mapa1 = map(lambda y: y[1], \n",
    "        filter(lambda x: x[0] in ['Merry', 'Tom'], fruits.items())\n",
    ")\n",
    "list(mapa1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Alternatywnie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x[1] for x in fruits.items() if x[0] in [\"Merry\", \"Tom\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Sklejamy listę list w jedną listę:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Mapujemy listę tupli na listę liczb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
    "list(mapa2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Finalnie redukujemy listę do sumy elementów:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Możemy także użyć gotowego operatora dodawania z modułu operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "list(chain(*[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sum(it[1] for it in chain(*[item[1] for item in fruits.items() if item[0] in {'Merry','Tom'}]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([y[1] for x in [owoce for name, owoce in fruits.items() if name in [\"Merry\", \"Tom\"]] for y in x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Słowniki (dict) - zaawansowane użycie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Usuwanie elementów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "defaults = {\n",
    "    'apple': 1,\n",
    "    'orange': 2,\n",
    "    'peach': 3,\n",
    "}\n",
    "\n",
    "print(defaults)\n",
    "del defaults['apple']\n",
    "print(defaults)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "defaults = {\n",
    "    'apple': 1,\n",
    "    'orange': 2,\n",
    "    'peach': 3,\n",
    "}\n",
    "\n",
    "print(defaults)\n",
    "defaults.pop('apple')\n",
    "print(defaults)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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ątek 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",
    "* Generator to \"funkcja po której można iterować\", w każdej iteracji zwracająca kolejną wartość\n",
    "* Do zwrócenia kolejnej wartości używamy ``yield`` zamiast ``return``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Iteratory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, \"X\", 3.14]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# czy obiekt l (lista) ma atrybut __iter__ ?\n",
    "'__iter__' in dir(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "'__next__' in dir(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# pobieramy iterator\n",
    "it = iter(l) \n",
    "# it = l.__iter__() # alternatywnie\n",
    "type(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# iterujemy\n",
    "next(it)\n",
    "# it.__next__() # alternatywnie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "r = range(3)\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "g = (i*i for i in range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "type(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"__next__\" in dir(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for i in [a**2 for a in range(20000000)]:\n",
    "    break\n",
    "print(\"DONE\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in (a**2 for a in range(20000000)):\n",
    "    break\n",
    "print(\"DONE\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### polecenie ``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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fib()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "it = iter(fib())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "next(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "list(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    yield 2\n",
    "    yield 3\n",
    "    return 4\n",
    "\n",
    "i = iter(f())\n",
    "print(next(i))\n",
    "print(next(i))\n",
    "print(next(i))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### List comprehension (jeszcze raz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Technicznie rzecz 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": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "list(combinations('ABCD', 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "list(permutations('AB C D'.split(), 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "list(combinations_with_replacement('ABCD', 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "list(product('ABC', 'XY'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "list(product('ABC', 'XY', ['Ą', 'Ę']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "iterator = permutations('ABC', 2)\n",
    "print(iterator)\n",
    "print(list(iterator))\n",
    "print(list(iterator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Formatowanie (PEP 8 c.d.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* 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 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 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"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}