funkcje.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"img/logos.png\" width=\"1500\" align=\"center\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">Paweł Święcki</code></h2>\n",
    "<h1 align=\"center\"><code style=\"background-color:white\">Podstawy Pythona: Funkcje</code></h1>\n",
    "<h3 align=\"center\"><code style=\"background-color:white\">PyLight #9</code></h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a href=\"https://github.com/pawelswiecki/python_podstawy_funkcje\n",
    "\"><h3 align=\"center\">https://github.com/pawelswiecki/python_podstawy_funkcje</h3></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h1><code style=\"background-color:white\">O czym powiem</code></h1>\n",
    "\n",
    "<h2><code style=\"background-color:white\">1. Fundamentalia ;)</code></h2>\n",
    "\n",
    "<h2><code style=\"background-color:white\">2. Struktura funkcji</code></h2>\n",
    "\n",
    "<h2><code style=\"background-color:white\">3. Jak dobrze pisać funkcje</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h1 align=\"center\"><code style=\"background-color:white\">1. Fundamentalia</code></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div align=\"center\">O co tu w ogóle chodzi?</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">Czym jest funkcja?</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funkcja rozumiana potocznie\n",
    "\n",
    "> Funkcja to zadanie, które spełnia lub ma spełnić jakaś osoba lub rzecz.\n",
    "\n",
    "(zob. https://sjp.pwn.pl/szukaj/funkcja.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funkcja matematyczna\n",
    "\n",
    "Definicja funkcji jednoargumentowej:\n",
    "\n",
    "> Dla danych dwóch zbiorów $X$ oraz $Y$ funkcja $f$ to przyporządkowanie każdemu elementowi zbioru $X$ dokładnie jednego elementu zbioru $Y$, co zapisujemy $f: X  \\rightarrow Y$.\n",
    " \n",
    "(por. https://pl.wikipedia.org/wiki/Funkcja)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Można powiedzieć, że funkcja matematyczna to **mapowanie**:\n",
    "\n",
    "<img src=\"img/function-wikipedia.png\" width=\"350\">\n",
    "\n",
    "<div align=\"center\">Funkcja mapująca figurę geometryczną na jej kolor [obrazek z <a href=\"https://en.wikipedia.org/wiki/Function_(mathematics)\">wikipedii</a>]</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "W Pythonie funkcja (jedno- lub wieloargumentowa) może być czystym mapowaniem, ale takie funkcje są tylko jednym z rodzajów funkcji."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funkcja w Pythonie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "W Pythonie (i innych językach) funkcja rozumiana jest szerzej niż w matematyce – może być mapowaniem, ale nie musi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Funkcja to wydzielony fragment programu, który:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- **dostaje jakieś dane** (input), po czym"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- **coś robi**, a następnie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- **zwraca jakieś dane** (output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Inne określenia o podobnym znaczeniu: _procedure_, _routine_, _subroutine_, _subprogram_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Jest jeszcze _method_ (metoda). Jest to funkcja na stałe przywiązana do obiektu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">Po co nam funkcje?</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### 1. Aby podzielić program na mniejsze fragmenty.\n",
    "\n",
    "Tak się go łatwiej rozwija, kod jest bardziej zrozumiały i łatwiejszy w debuggowaniu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### 2. Aby można było powtórnie używać części kodu.\n",
    "\n",
    "Na przykład jeśli zdefiniuję funkcję liczenia średniej, to potem mogę używać jej wszędzie, gdzie tylko potrzebuję średniej."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">Jak zdefiniować funkcję?</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Funkcje definiowane są przy pomocy słówka **`def`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def nazwa_funkcji(parametry_funkcji):\n",
    "    # tutaj jest to, co funkcja robi\n",
    "    return dane_które_funkcja_zwraca"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Na przykład:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def add_one(number):\n",
    "    result = number + 1\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Funkcja ta jest czystym mapowaniem i implementuje funkcję matematyczną $f(x) = x + 1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">Jak używać funkcji?</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Funkcji używamy w sposób następujący:\n",
    "\n",
    "`nazwa_funkcji(argumenty_przekazane_do_funkcji)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_one(11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_one(41)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Aby zachować w zmiennej wartość zwróconą przez funkcję robimy tak:\n",
    "\n",
    "`zmienna = nazwa_funkcji(argumenty)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Na przykład:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "result = add_one(255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "256"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h1 align=\"center\"><code style=\"background-color:white\">2. Struktura funkcji</code></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Powtórzmy – funkcja to wydzielony fragment programu, który:\n",
    "\n",
    "A. **dostaje jakieś dane**, po czym\n",
    "\n",
    "B. **coś robi**, a następnie\n",
    "\n",
    "C. **zwraca jakieś dane**.\n",
    "\n",
    "Jak zaraz zobaczymy, każdy z tych punktów jest opcjonalny."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "Schemat funkcji\n",
    "===============     A. dane przekazane (argumenty)\n",
    "                                [INPUT]\n",
    "                                   |\n",
    "                                   |\n",
    "                                   v\n",
    "              def moja_funkcja(parametry):\n",
    "                  +--------------------+\n",
    "                  |                    |\n",
    "                  | B. przetwarzanie   |\n",
    "                  |       danych       |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |                    |\n",
    "                  |return ...          |\n",
    "                  +--------------------+\n",
    "                           |\n",
    "                           |\n",
    "                           v\n",
    "                  C. dane zwrócone\n",
    "                       [OUTPUT]\n",
    "'''[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Zacznę od (A) danych przekazanych, potem omówię (C) dane zwrócone, a na końcu (B) to, co w funkcja robi w środku."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">A. To, co funkcja dostaje</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div align=\"center\">O parametrach i argumentach.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### \"Parametr\" a \"argument\"\n",
    "\n",
    "Czasem używa się tych słów zamiennie, czasem się je myli, a nie chcemy ich mylić, bo głupio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Parametr** to zmienna w definicji funkcji."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "def add_one(number):\n",
    "    ...       ^\n",
    "              |\n",
    "           parametr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Argument** to dana przekazana do funkcji."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "result = add_one(11)\n",
    "                 ^\n",
    "                 |\n",
    "              argument\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Wywołujemy tu funkcję `add_one` z _argumentem_ `11`. Argument ten zostaje przekazany do _parametru_ `number` tej funkcji. Od teraz ramach tej funkcji `number` ma wartość `11`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Czy funkcja może nie mieć żadnych parametrów?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tak:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def get_pythons_creator_name():\n",
    "    return 'Guido van Rossum'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "name = get_pythons_creator_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Guido van Rossum'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Czy funkcja może mieć wiele parametrów?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tak:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(3, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def save_user_data(ip, isp, country, language, device, browser, os):\n",
    "    print('User data saved.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User data saved.\n"
     ]
    }
   ],
   "source": [
    "save_user_data('151.101.13.140', 'AT&T', 'us', 'en-US', 'pc', 'Mozilla/5.0', 'Ubuntu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Sporo tych argumentów, aż można się pomylić..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Wywoływanie funkcji wraz z nazwami parametrów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_one(number=33)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(x=1, y=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Czasem jest to bardzo przydatne, szczególnie gdy funkcja ma wiele parametrów:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User data saved.\n"
     ]
    }
   ],
   "source": [
    "save_user_data(\n",
    "    ip='151.101.13.140',\n",
    "    isp='AT&T',\n",
    "    country='us',\n",
    "    language='en-US',\n",
    "    device='pc',\n",
    "    browser='Mozilla/5.0',\n",
    "    os='Ubuntu',\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User data saved.\n"
     ]
    }
   ],
   "source": [
    "# Dużo lepiej, niż:\n",
    "save_user_data('151.101.13.140', 'AT&T', 'us', 'en-US', 'pc', 'Mozilla/5.0', 'Ubuntu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Parametry z wartościami domyślnymi (_default parameter values_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Możemy też zdefinować funkcję tak, by przyjmowała wprawdzie argument, ale jeśli nie zostanie on przekazany, to odpowiedni parametr przyjmie wartość domyslną (_default_):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def launch_missiles(missiles, drill=True):\n",
    "    if not drill:\n",
    "        print('📣 This is not a drill! 📣\\n')\n",
    "    for missile_id in missiles:\n",
    "        if drill:\n",
    "            print(f'Pretending to launch missile #{missile_id}... 😌')\n",
    "        else:\n",
    "            print(f'Launching missile #{missile_id}! 😱')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "W samej definicji parametrowi `drill` domyślnie przypisaliśmy `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Wywołajmy funkcję `launch_missiles` tylko z jednym argumentem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pretending to launch missile #1... 😌\n",
      "Pretending to launch missile #3... 😌\n",
      "Pretending to launch missile #7... 😌\n"
     ]
    }
   ],
   "source": [
    "launch_missiles([1, 3, 7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Czyli parametr `drill` otrzymał wartość `True`. Uff..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Dobra, wystrzelmy te pociski!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "📣 This is not a drill! 📣\n",
      "\n",
      "Launching missile #1! 😱\n",
      "Launching missile #2! 😱\n",
      "Launching missile #3! 😱\n",
      "Launching missile #4! 😱\n"
     ]
    }
   ],
   "source": [
    "launch_missiles([1, 2, 3, 4], drill=False)\n",
    "\n",
    "# można też `launch_missiles([1, 2, 3, 4], False)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**UWAGA!** Wartościami domyślnymi powinny być wyłącznie obiekty niezmienne (immutable). Dlaczego? Zob. <a href=\"https://www.youtube.com/watch?v=Lb-t3TOBIQ0\">prezentację</a> PyLight Marcina Jaroszewskiego oraz <a href=\"https://github.com/PyLightMeetup/Domyslne-niezmienne-czyli-o-argumentach-funkcji/blob/master/domyslne_niezmienne.ipynb\">materiały</a> do niej."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funkcje z dowolną liczbą argumentów\n",
    "\n",
    "#### czyli `*args` i `**kwargs`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- \"args\" to skrót od \"arguments\"\n",
    "\n",
    "- \"kwargs\" to skrót od \"keyword arguments\" (czyli argumenty nazwane)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`*args` \"pakuje\" w siebie wszystkie pozostałe nienazwane argumenty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def save_personal_data(*args):\n",
    "    print(f'args = {args}')\n",
    "    print(type(args))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args = (445, 'Bob Smith', 'ALIVE')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "save_personal_data(445, 'Bob Smith', 'ALIVE')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Czyli `args` to krotka (tuple)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`**kwargs` \"pakuje\" w siebie wszystkie pozostałe nazwane argumenty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def save_personal_data2(**kwargs):\n",
    "    print(f'kwargs = {kwargs}')\n",
    "    print(type(kwargs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kwargs = {'id_': 44, 'name': 'Boba Fett', 'status': 'MIA'}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "save_personal_data2(id_=44, name='Boba Fett', status='MIA')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Czyli `kwargs` to dict."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Możemy też łączyć `*args` z `**kwargs`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def save_personal_data3(*args, **kwargs):\n",
    "    print(f'args = {args}')\n",
    "    print(f'kargs = {kwargs}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args = (10, 'R2-D2')\n",
      "kargs = {'droid_type': 'astromech'}\n"
     ]
    }
   ],
   "source": [
    "save_personal_data3(10, 'R2-D2', droid_type='astromech')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Możemy również łączyć zwykłe przekazywanie parametrów z `*args` i `**kwargs`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def save_personal_data4(id_, name, **extra_data):\n",
    "    print(f'id_ = {id_}')\n",
    "    print(f'name = {name}')\n",
    "    print(f'extra_data = {extra_data}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id_ = 10\n",
      "name = Luke Skywalker\n",
      "extra_data = {'status': 'FORCE_GHOST', 'last_occupation': 'Ahch-To'}\n"
     ]
    }
   ],
   "source": [
    "save_personal_data4(\n",
    "    id_=10,\n",
    "    name='Luke Skywalker',\n",
    "    status='FORCE_GHOST',\n",
    "    last_occupation='Ahch-To',\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Można używać innych nazw na oznaczenie obu, ale przyjęły się \"args\" i \"kwargs\". Istotą są tu gwiazdki: `*` oraz `**`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Po co w ogóle `*args` i `**kwargs`\n",
    "\n",
    "Przy ich pomocy nasze funkcje mogą być elastyczniejsze:\n",
    "\n",
    "- Przydaje się to na przykład w kontekście OOP i dziedziczenia. \n",
    "\n",
    "- Twórcy bibliotek często wykorzystują tę technikę, by uczynić funkcje w swoich bibliotekach bardziej uniwersalnymi. Widoczne jest to na przykład w bibliotece **requests**, w której funkcja `request` przyjmuje wiele opcjonalnych parametrów, które są \"łapane\" przy pomocy `**kwargs`, zob. http://docs.python-requests.org/en/master/api/#requests.request."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">C. To, co funkcja zwraca</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div align=\"center\">Czyli dane, które dostajemy od funkcji.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "Schemat funkcji\n",
    "===============     A. dane przekazane (argumenty)\n",
    "                                [INPUT]\n",
    "                                   |\n",
    "                                   |\n",
    "                                   v\n",
    "              def moja_funkcja(parametry):\n",
    "                  +--------------------+\n",
    "                  |                    |\n",
    "                  | B. przetwarzanie   |\n",
    "                  |       danych       |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |                    |\n",
    "                  |return ...          |\n",
    "                  +--------------------+\n",
    "                           |\n",
    "                           |\n",
    "                           v\n",
    "                  C. dane zwrócone\n",
    "                       [OUTPUT]\n",
    "'''[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Czy funkcja może zwracać wiele wartości?\n",
    "\n",
    "I tak, i nie. Funkcja może zwracać tylko jeden obiekt, ale może to być obiekt złożony z wielu obiektów:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def get_two_numbers():\n",
    "    return 1, 2\n",
    "\n",
    "# można też z nawiasem: `return (1, 2)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "two_numbers = get_two_numbers()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(two_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Aby oddzielnie zapisać obie dane ze zwróconej krotki przy przypisywaniu krotki zwróconej z funkcji używamy... drugiej krotki, po lewej stronie `=`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "number_one, number_two = get_two_numbers()\n",
    "# również tu można z nawiasem: `(number_one, number_two)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number_one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number_two"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Czy funkcja może nic nie zwracać?\n",
    "\n",
    "I tak, i nie..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def useless_function(x):\n",
    "    y = x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "useless_function(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Tak naprawdę nawet ta funkcja coś zwraca, tylko w sposób niejawny. Tym czymś jest obiekt **`None`**. \n",
    "\n",
    "Obiekt `None` reprezentuje **nic** lub **brak**. Więc funkcja zwracająca `None` w pewnym sensie nic nie zwraca."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "what = useless_function(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(what)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "W trzech przypadkach funkcja może zwracać `None`:\n",
    "\n",
    "- w funkcji w ogóle nie ma słówka `return`\n",
    "\n",
    "- w funkcji jest `return` bez niczego po nim w tej samej linijce\n",
    "\n",
    "- w funkcji jest `return None` (albo `return zmienna`, gdzie to zmiennej przypisany jest `None`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def give_me_none():\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "x = give_me_none()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2 align=\"center\"><code style=\"background-color:white\">B. To, co funkcja robi</code></h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div align=\"center\">Bebechy funkcji.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "Schemat funkcji\n",
    "===============     A. dane przekazane (argumenty)\n",
    "                                [INPUT]\n",
    "                                   |\n",
    "                                   |\n",
    "                                   v\n",
    "              def moja_funkcja(parametry):\n",
    "                  +--------------------+\n",
    "                  |                    |\n",
    "                  | B. przetwarzanie   |\n",
    "                  |       danych       |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |          .         |\n",
    "                  |                    |\n",
    "                  |return ...          |\n",
    "                  +--------------------+\n",
    "                           |\n",
    "                           |\n",
    "                           v\n",
    "                  C. dane zwrócone\n",
    "                       [OUTPUT]\n",
    "'''[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Co funkcja _może_ robić?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**1. Przetwarzać dane**\n",
    "\n",
    "Nawet `result = number + 1` to przetwarzane danych."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**2. Wywoływać efekty uboczne**\n",
    "\n",
    "**Efekt uboczny** funkcji to jej dodatkowa (poza zwróceniem wartości) interakcja z czymś poza nią, np. wysłanie maila, pobranie danych z API. Więcej o tym kiedy indziej :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funkcje dużo robiące\n",
    "\n",
    "Funkcja może robić praktycznie nieograniczoną liczbę rzeczy. Jednak najlepsze są funkcje wyspecjalizowane, które dobrze robą jedną rzecz – jak mówi **Single Responsibility Principle**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Jeśli funkcja musi zrobić dużo, to najlepiej podzielić jej pracę na mniejsze fragmenty i zlecić ich wykonanie... mniejszym funkcjom pomocniczym."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Wyobraźmy sobie, że mamy napisać funkcję `update_password` zmieniającą hasło użytkownika. Funkcja ta powinna:\n",
    "\n",
    "- sprawdzać, czy stare hasło i powtórzone stare hasło są równe\n",
    "- sprawdzać, czy stare hasło jest poprawne\n",
    "- sprawdzać, czy nowe hasło ma odpowiednią liczbę znaków\n",
    "- sprawdzać, czy nowe hasło ma odpowiednie znaki\n",
    "- wygenerować hash nowego hasła\n",
    "- dokonać próby zmiany hasha hasła w bazie danych\n",
    "- zgłosić błąd przy zmianie hasha\n",
    "- dokonać odpowiedniego wpisu do logów systemowych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Jeśli to wszystko wrzucimy \"luzem\" do jednej funkcji `update_password`, to funkcja ta będzie: \n",
    "\n",
    "- nieczytelna\n",
    "\n",
    "- trudna w utrzymaniu\n",
    "\n",
    "- trudna w testowaniu\n",
    "\n",
    "- podatna na bugi\n",
    "\n",
    "- podatna na luki bezpieczeństwa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Nalepiej wydzielić poszczególne zadania tej funkcji i przenieść je do wielu funkcji pomocniczych, które będą wywoływane z wewnątrz funkcji `update_password`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Funkcje te będą mogły być oddzielnie gruntownie otestowane, co zwiększy bezpieczeństwo i niezawodność systemu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    ":D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Funkcje nic nie robiące"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Na drugim biegunie mamy funkcje, które nic nie robią. Na przykład tzw. funkcja tożsamościowa (identity function) po prostu zwraca przekazaną wartość: $f(x) = x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def identity(value):\n",
    "    return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "identity(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Taka funkcja w większości przpadków jest dość bezużyteczna, ale są case'y, w których ma to sens."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Dla zabawy możemy też zdefiniować funkcję, która nic nie przyjmuje, nic nie robi i nic nie zwraca (albo lepiej: zwraca nic):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def it_does_absolutely_nothing():\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "it_does_absolutely_nothing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`¯\\_(ツ)_/¯`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h1 align=\"center\"><code style=\"background-color:white\">3. Jak dobrze pisać funkcje?</code></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "<div align=\"center\">Kilka prostych wskazówek.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nazywanie funkcji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**1. Funkcje należy nazywać zgodnie z konwencją `snake_case`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Nie `PascalCase`, tak w Pythonie nazywamy klasy.\n",
    "\n",
    "Nie `camelCase`, tak w Pythonie nic nie nazywamy.\n",
    "\n",
    "Nie `UPPER_CASE_WITH_UNDERSCORES`, tak w Pythonie nazywamy stałe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**2. Nazwy funkcji powinny być informatywne**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Nazwa funkcji powinna prawdziwie oddawać to, co funkcja robi. Wprowadzanie w błąd użytkownika funkcji nie jest fajne. Na przykład funkcja `update_user_data` nie może w żadnym wypadku usuwać użytkownika z systemu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Nadmierne używanie skrótów w nazwach funkcji też nie jest zabawne ;)\n",
    "\n",
    "Na przykład co robi funkcja `med_sum`? Czy to \"medium sum\", \"median sum\", \"medical sum\", a może \"medieval summary\"?\n",
    "Jeśli funkcja sumuje wartości medialne, to lepiej nazwać ją `sum_of_medians` (albo `medians_sum`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**3. Nazwy funkcji nie powinny być za długie**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Nazwa `get_user_country_by_id_or_by_name_whatever_is_passed` jest lekko przesadna. Lepiej skrócić do `get_user_country` a dodatkowe wyjaśnienie działania funkcji dać w komentarzu lub w docstring."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Wyjątkiem są nazwy funkcji testujących, gdzie długie nazwy są nawet wskazane, na przykład: `test_user_update_should_fail_on_wrong_user_id`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Cel i długość funkcji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**4. Single Responsibility Principle**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Funkcja powinna robić jedną dobrze określoną rzecz i robić ją dobrze."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**5. Funkcje nie powinny być za długie**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Stosuję prostą zasadę: funkcja ma mieścić się w oknie edytora otwartego na pełnym ekranie.\n",
    "\n",
    "Dobrze jest móc widzieć całą funkcję na raz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dzięki :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Pytania?"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}