p1/dodatna predavanja/02 zanimivejsi pogoji.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logični operatorji ne delajo le z `bool`\n",
    "\n",
    "V Pythonu seveda velja, tako kot v Cju, da je 0 neresnična, vsa druga števila pa so resnična."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 0 or 1\n",
    "1\n",
    ">>> 0 and 0\n",
    "0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prav tako veljajo za neresnične `None` (`None` je malo podoben Cjevskumu `NULL`u, vendar ne preveč, saj Python nima kazalcev), neresničen je tudi prazen niz, prazen seznam... vse, kar je prazno. Do sem nič posebnega in nepričakovanega.\n",
    "\n",
    "Posebno pa je tole: človek bi pričakoval, da `and` vrne `True`, če sta leva in desna stran resnični, in `False`, če ne. Prav tako bi pričakoval, da bo `or` vrnil `True`, če je vsaj ena od strani resnična in `False`, če ni. No, tak človek bi se motil.\n",
    "\n",
    "Pravilo je takšno:\n",
    "\n",
    "- **`and`**: če je vrednost na levi strani neresnična, jo vrne; sicer vrne vrednost na desni.\n",
    "- **`or`**: če je vrednost na levi strani resnična, jo vrne; sicer vrne vrednost na desni.\n",
    "\n",
    "Na prvi pogled tidve pravili samo na malo bolj zapleten način opisujeta, kar pač morata početi `and` in `or`. Da, že, vendar v primeru, da imamo samo `True` in `False`. `False and <karkoli>` vrne levo stran, torej `False`; `True and False` vrne desno stran, torej `False`; `True and True` vrne desno stran, torej `True`.\n",
    "\n",
    "Ker je tudi za vsako drugo stvar določeno, ali je resnična ali neresnična (kot smo napisali: število je resnično, če je različno od 0; različne druge stvari so resnične, če so neprazne), pa imata pravili zanimive posledice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 1 and 1\n",
    "1\n",
    ">>> 1 and 2\n",
    "2\n",
    ">>> 2 and 1\n",
    "1\n",
    ">>> 2 and 0\n",
    "0\n",
    ">>> 0 and 2\n",
    "0\n",
    ">>> \"\" and 2\n",
    "''\n",
    ">>> 3 or 0\n",
    "3\n",
    ">>> 3 or \"\"\n",
    "3\n",
    ">>> 2 and 3 or 4\n",
    "3\n",
    ">>> 2 and 3 or 0\n",
    "3\n",
    ">>> 2 and 3 or 4\n",
    "3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se zdi uporabno? Ne? Pa poglejte tole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> '' or '<neregistriran uporabnik>'\n",
    "'<neregistriran uporabnik>'\n",
    ">>> 'Janez' or '<neregistriran uporabnik>'\n",
    "'Janez'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kadar programiram v kakem drugem jeziku, ne Pythonu, tole res pogrešam.\n",
    "\n",
    "## `if-else` AKA Pythonov japonski operator\n",
    "\n",
    "Kaj pa naredi tole?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "x > 0 and 42 or 13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ali pa, recimo, tako (da bo počelo kaj smiselnega):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x > 0 and x or 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Branje moramo začeti pri `or`, navsezadnje je izraz, v bistvu, tak: `(x > 0 and 42) or 13`. Zdaj najprej pogledamo levo stran. Tam imamo `and`.\n",
    "- Če je `x` več kot `0`, bo rezultat izraza `x > 0 and 42` enak `42`, torej imamo `42 or 13`, to pa je `42`.\n",
    "- Če `x` ni večji od `0`, pa bo `and` neresničen, `False`, torej imamo `False or 13`, kar je `13`.\n",
    "\n",
    "Ali pa takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "y = 8\n",
    "\n",
    "x > y and x or y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če je `x` večji od `y`, je rezultat `x`, sicer `y`.\n",
    "\n",
    "Nas to na kaj spominja? No, da to je isto kot `x > y ? x : y`. Vsaj za tiste, ki iz kakega drugega jezika poznate operator `?:`. Iz Pythona ga namreč ne morete, ker ga nima.\n",
    "\n",
    "V večini jezikov, torej, imamo \"ternarni\" operator `?:`. Ternarni? No, da. Operatorji so lahko unarni, tako kot, na primer unarni minus (`-3`), `not` (`not b` ali, v C-jevski sintaksi, `!b`) ali dvojiški komplement, `~`. Lahko so binarni, kot `+`, `-`, `*`, `/` in tako naprej; to so tisti, ki sprejmejo dva operanda. Lahko pa so ternarni, kot je `?:`.\n",
    "\n",
    "`?:` sprejme tri operande. Izraz `a ? b : c` ima vrednost `b`, kadar je `a` resničen, sicer pa `c`. Ker Python tega nima (oziroma, ni imel in še vedno nima v tej obliki), so programerji namesto `a ? b : c` pisali `a and b or c`. Kar je večinoma delovalo, včasih pa tudi ne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0\n",
    "y = -5\n",
    "\n",
    "x > y and x or y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zakaj to ne vrne `x`? `x > y` je vendar resničen! Poglejmo, kaj dobimo, če vstavimo `x` in `y` (poleg tega pa dodamo še oklepaje, da bo bolj očitno, da se najprej poračuna `and`): `(0 > -5 and 0) or -5` oziroma `(True and 0) or -5`. Ker je `0` neresnično, je to `0 or -5`, torej `-5`.\n",
    "\n",
    "Debata je bila dolga, trajala je leta. Operatorja `?:` v Python niso uvedli, ker je grd, nepythonovski. Python je zračen, v njem ni nobenih `&&` in `::*`, torej tudi `?:` ne bomo tolerirali. Ampak boljšega si pa niso izmislili. Na koncu je benevolentni dosmrtni diktator Pythona odločil, da se bo to zapisovalo z izrazom `if-else`, takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x if x > 0 else y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nek C-ja vajen študent je nekoč komentiral, da je tale operator japonski. Nekako, narobe obrnjen. Ali pa tudi ne: prebere se čisto lepo. Mar nisem zgoraj napisal \"*Izraz `a ? b : c` ima vrednost `b`, kadar je `a` resničen, sicer pa `c`.*\" To je dobesedno to: `b if a else c`.\n",
    "\n",
    "Vseeno je operator čuden in ga pravzaprav ne uporabljamo radi in pogosto.\n",
    "\n",
    "Operator `if-else` je del izraza. To ni isto kot `if` in `else`, o katerem smo se sicer poučili danes. Uporabljamo ga lahko, recimo tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = x if x > 0 else y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ali tako"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "625"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(5 * (x if x > 0 else y), 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ujemanje vzorcev\n",
    "\n",
    "Tipično vprašanje prišlekov iz drugih jezikov je: a `switch`-a pa Python nima? Za tiste, ki ne veste, kaj je `switch`: v C-ju lahko napišemo\n",
    "\n",
    "```c\n",
    "switch(err.code) {\n",
    "    case 400: msg = \"Bad request\"; break;\n",
    "    case 404: msg = \"Page not found\"; break;\n",
    "    case 418: msg = \"I'm a teapot\"; break;\n",
    "    default: msg = \"Whatever\";\n",
    "}\n",
    "```\n",
    "\n",
    "In podobno v drugih jezikih. V Pythonu pa ne. Ker tam lahko napišeš:\n",
    "\n",
    "```python\n",
    "if err.code == 400:\n",
    "    msg = \"Bad request\"\n",
    "elif err.code == 404:\n",
    "    msg = \"Page not found\"\n",
    "elif err.code == 418:\n",
    "    msg = \"I'm a teapot\"\n",
    "```\n",
    "\n",
    "Ali, točneje, ker ti tega ni treba pisati, saj lahko, kot bomo izvedeli čez slab mesec, napišeš\n",
    "\n",
    "```\n",
    "messages = {400: \"Bad request\", 404: \"Page not found\", 418: \"I'm a teapot\"}\n",
    "```\n",
    "\n",
    "in potem\n",
    "\n",
    "```\n",
    "msg = messages[err.code]\n",
    "```\n",
    "\n",
    "Tu bi se kdo uprl, da to ni isto: v `switch` lahko dodaš še marsikaj drugega kot en sam izraz. Upor je bil preslišan do različice Pythona 3.10, ki je v tem trenutku stara par dni in spodnje kode sploh še ne morem izvajati v Jupytru, ker ga le-ta še ne podpira. V Pythonu 3.10, torej, lahko napišemo tole:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "code = 418\n",
    "\n",
    "match code:\n",
    "    case 400:\n",
    "        msg = \"Bad request\"\n",
    "    case 404: \n",
    "        msg = \"Page not found\"\n",
    "    case 418: \n",
    "        msg = \"I'm a teapot\"\n",
    "    case _: \n",
    "        msg = \"Whatever\"\n",
    "\n",
    "print(msg)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na prvi pogled je stvar takšna kot v jezikih, ki so prevzeli C-jevski zapis, samo da so v Pythonu iz navidez neznanega razloga zamenjali `switch` z `match`. To ni nič takega; v Kotlinu, recimo, bi se tole zapisalo kot\n",
    "\n",
    "```kotlin\n",
    "when (code) {\n",
    "    400 -> msg = \"Bad request\";\n",
    "    404 -> msg = \"Page not found\";\n",
    "    418 -> msg = \"I'm a teapot\";\n",
    "    else -> msg = \"Whatever\";\n",
    "}\n",
    "```\n",
    "\n",
    "(Kotlin v resnici carski jezik; gornje se bolj pravilno napiše tako:\n",
    "\n",
    "```kotlin\n",
    "msg = when (code) {\n",
    "    400 -> \"Bad request\";\n",
    "    404 -> \"Page not found\";\n",
    "    418 -> \"I'm a teapot\";\n",
    "    else -> \"Whatever\";\n",
    "}\n",
    "```\n",
    "\n",
    "ker je v Kotlinu `when` pravzprav izraz. Kot tudi večina drugih stvari v Kotlinu.)\n",
    "\n",
    "No, vrnimo se v Python. Pythonov `match` ni isto kot C-jevski `switch`, temveč veliko več. Pythonov `match` preverja ujemanje strukture, ne le vsebine.\n",
    "\n",
    "```python\n",
    "match tocka:\n",
    "    case (0, 0): \n",
    "        print(\"izhodišče\")\n",
    "    case (x, y): \n",
    "        print(\"ni izhodišče\")\n",
    "    case _: \n",
    "        print(\"ni točka\")\n",
    "```\n",
    "\n",
    "Če ima `tocka` vrednost `(0, 0)`, bo tole izpisalo, `\"izhodišče\"`; če ima točka kake druge koordinate, na primer `(3, 1)`, bo izpisalo `\"ni izhodišče\"`; če pa ima `tocka` vrednost `42`, bo izpisalo `\"ni točka\"` - ker pač ni oblike `(x, y)`.\n",
    "\n",
    "No, to ni še nič. Napišemo lahko tole:\n",
    "\n",
    "```python\n",
    "match tocka:\n",
    "    case (0, 0): \n",
    "        print(\"izhodišče\")\n",
    "    case (x, 0): \n",
    "        print(\"x =\", x, \"(na osi y)\")\n",
    "    case (0, y):\n",
    "        print(\"y =\", y, \"(na osi x)\")\n",
    "    case (x, y):\n",
    "        print(\"tocka, x =\", x, \"in y =\", y)\n",
    "    case _: \n",
    "        print(\"ni točka\")\n",
    "```\n",
    "\n",
    "Python gre po vrsti in poišče prvi primer, ki opiše `tocka`: najprej preverjamo, ali sta obe koordinati 0, nato ali je druga koordinata enaka 0, nato ali je prva 0, sicer pa, ali sploh imamo dve koordinati. In v vseh teh primerih priredi spremenljivki `x` ali `y` podatek, ki je na tem mestu.\n",
    "\n",
    "Seveda lahko naredimo tudi to:\n",
    "\n",
    "```python\n",
    "match tocka:\n",
    "    case (0, 0):\n",
    "        print(\"izhodišče\")\n",
    "    case (x, 0):\n",
    "        print(\"x =\", x, \"(na osi y)\")\n",
    "    case (0, y): \n",
    "        print(\"y =\", y, \"(na osi x)\")\n",
    "    case (x, y):\n",
    "        print(\"tocka, x =\", x, \"in y =\", y)\n",
    "    case (x, y, z):\n",
    "        print(\"olala, tri dimenzije\")\n",
    "    case _: \n",
    "        print(\"ni točka\")\n",
    "```\n",
    "\n",
    "No, zakaj bi se ustavili pri treh. Kot bomo videli prihodnji teden (ko bomo tudi boljše razumeli, kaj je tule v ozadju in kaj pomeni tale zvezdica) lahko naredimo tudi to:\n",
    "\n",
    "```python\n",
    "tocka = (3, 0, 5, 6, 8)\n",
    "match tocka:\n",
    "    case (0, 0): \n",
    "        print(\"izhodišče\")\n",
    "    case (x, 0):\n",
    "        print(\"x =\", x, \"(na osi y)\")\n",
    "    case (0, y): \n",
    "        print(\"y =\", y, \"(na osi x)\")\n",
    "    case (x, y): \n",
    "        print(\"tocka, x =\", x, \"in y =\", y)\n",
    "    case (x, y, *ostale):\n",
    "        print(\"olala,\", 2 + len(ostale), \"dimenzij!\")\n",
    "    case _: \n",
    "        print(\"ni točka\")\n",
    "```\n",
    "\n",
    "Da ne zapletamo brez potrebe z `x` in `y`, bi lahko pisali tudi:\n",
    "\n",
    "```python\n",
    "    case (*t, ): print(\"olala,\", len(t), \"dimenzij!\")\n",
    "```\n",
    "\n",
    "Še en lep primer iz [dokumentacije](https://www.python.org/dev/peps/pep-0636/):\n",
    "\n",
    "```python\n",
    "command = \"take keys\"\n",
    "\n",
    "match command.split():\n",
    "    case (\"quit\", ):\n",
    "        print(\"End of game\")\n",
    "    case (\"take\", object): \n",
    "        print(\"You took the\", object)\n",
    "    case (\"touch\", what): \n",
    "        print(\"Don't touch\", what)\n",
    "    case (\"talk\", \"to\", person): \n",
    "        print(\"You said: 'Hi,\", person, \"'\")\n",
    "```\n",
    "\n",
    "Dodati je možno tudi pogoje!\n",
    "\n",
    "```python\n",
    "tocka = (3, 0)\n",
    "match tocka:\n",
    "    case (0, 0):\n",
    "        print(\"izhodišče\")\n",
    "    case (x, 0) if x > 0:\n",
    "        print(\"desno od izhodišča, x =\", x, \"(na osi y)\")\n",
    "    case (x, 0):\n",
    "        print(\"levo od izhodišča, x =\", x, \"(na osi y)\")\n",
    "    case _: print(\"karkoli\")\n",
    "```\n",
    "\n",
    "Ko Python najde ujemanje, preveri še pogoj, in če ta ni izpolnjen, nadaljuje s preiskovanjem naslednjih vzorcev."
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}