funkcional.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funkcionální přístup\n",
    "\n",
    "## Comprehension\n",
    "\n",
    "Tato kapitola by se dala také nazvat **Stručný senzam**\n",
    "\n",
    "Obecný zápis je:\n",
    "\n",
    "    seznam = [VLOŽIT for prom in zdroj_seznam if vyraz] \n",
    "\n",
    "Například:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mocniny = [i*i for i in range(10)]\n",
    "mocniny"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "suda = [i for i in range(20) if i%2 == 0]\n",
    "suda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 0, 5, 10, 15, 0, 3, 6, 9]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sez=[1,5,3]\n",
    "l=[n*m for n in sez for m in range(4)]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 0], [1, 1], [2, 4], [3, 9], [4, 16]]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kvadrat = [[n,n*n] for n in range(5)]\n",
    "kvadrat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobně lze vytvářet i slovníky `dict`. Obecná syntax vypadá asi takto: \n",
    "\n",
    "    slovnik = { VLOŽ_KLÍČ : VLOŽ_HODNOTU for prom in zdroj_seznam if vyraz }\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 65, 'B': 66, 'C': 67, 'D': 68, 'E': 69, 'F': 70, 'G': 71}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slovnik = { k : ord(k) for k in \"abcdefg\".upper() }\n",
    "slovnik"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## funkce Lambda\n",
    "\n",
    "Lambda je anonimní funkce -- tedy funkce, která nemá jméno. Lambda je způsob, jak převést jednoduchý výraz na funkci. Používá se, když\n",
    "potřebujete získat funkci, která dělá totéž jako obyčejný výraz. (Zde se zatím pořád funkce nějak jmenuje, takže zatím není anonymní.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f=lambda x,y : x%y      # vytvoření funkce f(x,y) vracející zbytek po celočíselném dělení x/y\n",
    "f(12,7)                 # volání funkce f, vrátí 5\n",
    "\n",
    "liche=lambda x: x%2 == 1  # funkce, která vrací True, pokud je argument liché číslo\n",
    "liche(12)               # vrátí False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Je to to stejné jako bych napsal jednoduchou funkci. Funkce ale nebude anonimní nedá se použít ve výrazu.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def liche(x):\n",
    "    return(x%2 == 1)\n",
    "\n",
    "liche(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zabudované funkce pro funkcionální programování\n",
    "\n",
    "**filter**(f,sek)\n",
    "* f -- libovolná funkce; \n",
    "* sek -- posloupnost\n",
    "\n",
    "Vrátí posloupnost těch prvků z posloupnosti sek, pro které vrátí funkce `f` hodnotu\n",
    "True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[24, 30, 36, 42, 48, 54]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delitele_sesti=filter(lambda x: x%6==0 ,range(20,60))\n",
    "\n",
    "list(delitele_sesti)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**map**(f,sek)\n",
    "* `f` -- libovolná funkce\n",
    "* `sek` -- posloupnost\n",
    " \n",
    "Zavolá postupně funkci `f` všemi hodnotami posloupnosti a vrátí novou\n",
    "posloupnost z výsledků pokud má funkce `f` více argumentů, musí se použít stejn\n",
    "počet posloupností (pokud jejich délka neodpovídá, místo chybějících prvků se\n",
    "posílá hodnota none)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# hromadně převedu řetězce na čísla\n",
    "cisla = map(int, '1 2 3 4 5 6 7 8 9'.split())\n",
    "\n",
    "list(cisla)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 12, 20, 30]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# roznásobí seznamy\n",
    "vynasobeno = map(lambda x,y : x*y, [1,2,3,4,5], [2,3,4,5,6] )\n",
    "\n",
    "list(vynasobeno)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**reduce**(f,sek)\n",
    "* `f` -- funkce se dvěma argumenty\n",
    "* `sek` -- posloupnost\n",
    "\n",
    "Složí posloupnost do jediné hodnoty tak, že vezme první dva prvky poslounosti,\n",
    "dosadí je do funkce a vrátí místo nich výsledek. Takto pokračuje, až do konce\n",
    "seznamu.\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import functools\n",
    "\n",
    "seznam = [1, 2, 3, 4]\n",
    "functools.reduce(lambda x,y : x+y, seznam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "faktorial = functools.reduce(lambda x,y : x*y, range(1,6))\n",
    "faktorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}