00_podstawy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Język Python\n",
    "## Podstawy"
   ]
  },
  {
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\"The story of Jython begins one summer in Ashland, Oregon. I was juggling in a park behind a theater when I met Pavel Curtis, a scientist at Xerox PARC, who wanted to pass clubs. While we were juggling together he told me about a wonderful new programming language called Python. **Writing code in Python felt like writing the sort of natural informal code that developers would use when they wanted to quickly share ideas. It was executable pseudo-code.**\"\n",
    "Jim Hugunin - http://hugunin.net/story_of_jython.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Note:\n",
    "\n",
    "The use of Python 3 is highly preferred over Python 2. Consider upgrading your applications and infrastructure if you find yourself still using Python 2 in production today. If you are using Python 3, congratulations — you are indeed a person of excellent taste. —Kenneth Reitz\n",
    "\n",
    "[http://docs.python-requests.org/en/master/]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sprawy organizacyjne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Prowadzący:\n",
    "    * dr inż. Zbigniew Kaleta, zkaleta@agh.edu.pl\n",
    "    * dr inż. Marek Gajęcki, mag@agh.edu.pl\n",
    "    * mgr inż. Bartosz Minch, minch@agh.edu.pl\n",
    "* Współautorzy materiałów: \n",
    "    * dr inż. Krzysztof Dorosz, [@krzysztofdorosz](https://twitter.com/krzysztofdorosz)\n",
    "    * dr inż. Michał Korzycki, [@michalkorzycki](https://twitter.com/michalkorzycki)\n",
    "    * dr Leszek Grzanka, [@leszekgrzanka](https://twitter.com/leszekgrzanka)\n",
    "* Slajdy udostępnione w formacie Jupyter Notebook na githubie https://github.com/agh-glk/python-lecture (warto zainstalować rozszerzenie RISE)\n",
    "* Na pewno nie unikniemy gdzieś błędu w materiałach wykładu, dlatego gorąco zachęcamy do zgłaszania poprawek na githubie (fork + pull request)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Zaliczenie\n",
    "#### Składowe:\n",
    "* projekt z wagą 2\n",
    "* kolokwium z wagą 1\n",
    "* obie składowe **muszą być pozytywne**\n",
    "* w przypadku negatywnej oceny z którejś składowej, przysługuje 1 (słownie: jeden) termin poprawy\n",
    "* ostateczna ocena to średnia ważona wszystkich uzyskanych ocen +- 0.5, przy czym nie mniej niż 3.0, jeżeli obie składowe zostały zaliczone\n",
    "\n",
    "#### Terminy oddania projektu:\n",
    "* podstawowy: ostatnie zajęcia własnej grupy w semestrze\n",
    "* poprawkowy: koniec letniej sesji egzaminacyjnej (13 września)\n",
    "\n",
    "#### Terminy kolokwiów:\n",
    "* podstawowy: 6. laboratorium\n",
    "* poprawkowy: 25 VI **ALBO** 3 IX (albo = xor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Wykład wg USOSa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Cechy rozpoznawcze Pythona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* wcięcia jako element składni\n",
    "* w pełni obiektowy\n",
    "* bardzo wysokiego poziomu\n",
    "* dynamiczna typizacja (*duck typing*)\n",
    "* język skryptowy (interpretowany), ale również kompilowany do *bytecode*'u\n",
    "* liberalny interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Zalety:\n",
    "\n",
    " * zwięzły\n",
    " * czytelny (duża ekspresja)\n",
    " * bardzo dużo zasobów: frameworków, bibliotek, tutoriali\n",
    " * bardzo popularny\n",
    "\n",
    "https://madnight.github.io/githut/#/\n",
    "\n",
    "https://www.tiobe.com/tiobe-index/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Wady:\n",
    "\n",
    "* prędkość\n",
    "* Global Interpreter Lock\n",
    "* niekompatybilne linie 2.x i 3.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przyczyny powstania - historia języka i jego twórca"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* BDFL - **Guido van Rossum**\n",
    "    * Benevolent Dictator For Life\n",
    "* Centrum Wiskunde & Informatica – Amsterdam Hollandia\n",
    "\n",
    "![BDFL](img/Lecture/guido1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Pierwsza implementacja - XII 1989\n",
    "\n",
    "> \"Over six years ago, in December 1989, I was looking for a \"hobby\" programming project that would keep me occupied during the week around Christmas. My office (a government-run research lab in Amsterdam) would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of ABC that would appeal to Unix/C hackers. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus).\" Guido van Rossum\n",
    "\n",
    "Źródło: https://www.python.org/doc/essays/foreword/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Interpreter napisany w języku C, najstarszy (14.10.1990) kod interpretera dostępny tutaj:\n",
    "https://github.com/python/cpython/tree/daadddf7ae82f9e352e660d14a8a27285d992b2f\n",
    "\n",
    "* Wersja 0.9.0 - II 1991\n",
    "* Wersja 1.0 – I 1994\n",
    "* Wersja 2.0 – 16 X 2000\n",
    "    * Zbieranie nieużytków (Garbage collector)\n",
    "    * Zwykłe ciągi znaków oraz Unicode\n",
    "    * 2.2 wszystko stało się obiektem, generatory\n",
    "* Wersja 3.0 – 3 XII 2008\n",
    "    * *print* jest funkcją a nie slowem kluczowym\n",
    "    * tylko Unicode\n",
    "    * nowy operator dzielenia /\n",
    "    * nowa składnia raise/except\n",
    "* Na wykładzie korzystamy z linii 3.10.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Alternatywne implementacje Pythona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* CPython - standardowa implementacja jest często w kontekście innych alternatywnych nazywana CPython\n",
    "\n",
    "* RPython - Restricted Python, statycznie typowany podzbiór języka Python, JIT \n",
    "\n",
    "* PyPy - interpreter Pythona napisany w ... Pythonie (dokładnie w RPythonie), it's all about speed, JIT\n",
    "\n",
    "* Jython – interpreter napisany na JVM\n",
    "\n",
    "* IronPython - Python dla platformy .NET\n",
    "\n",
    "* Stackless Python - nie używa C call stack, skierowany na wielowątkowość (microthreads)\n",
    "\n",
    "* Unladen Swallow - sponsorowany przez Googla zawieszony po 2009 roku projekt, który miał dostarczyć super wydajną wersję CPythona. Nie wyszło.\n",
    "\n",
    "* Cython - Python kompilowany do C\n",
    "\n",
    "* MicroPython, CircuitPython - Pythony dla mikrokontrolerów"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Adafruit Trinket](img/Lecture/AdafruitTrinket.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## PEP 20 - Python ZEN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PEP - Python Enhancement Proposal - system dokumentów (podobna idea jak w RFC), zawierający pomysły na rozwój środowiska Python\n",
    "\n",
    "\n",
    "PEP 20 - http://www.python.org/dev/peps/pep-0020/\n",
    "\n",
    "***Long time Pythoneer Tim Peters succinctly channels the BDFL's guiding principles for Python's design into 20 aphorisms, only 19 of which have been written down.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## PEP 8 - Zasady formatowania kodu\n",
    "http://www.python.org/dev/peps/pep-0008/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    " **,,code is read much more often than it is written''** (BDFL)\n",
    " \n",
    " Po co wytyczne do formatowania kodu?\n",
    "   * spójność stylu wewnątrz modułów i projektu\n",
    "   * wytyczne to nie wyrocznia, można je pominąć, gdy:\n",
    "      * czyni to kod mniej czytelnym\n",
    "      * aby być spójnym z istniejącym kodem\n",
    "      * jest ryzyko utraty kompatybilności wstecz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* snake_case\n",
    "* 4 spacje na jedno wcięcie kodu \n",
    "* Nie używać znaków tabulacji (``\\t``)\n",
    "* Nigdy nie mieszać znaków tabulacji ze spacjami do robienia wcięć w jednym kodzie\n",
    "* Dwie puste linie pomiędzy kodem klas i funkcji (na najwyższym poziomie)\n",
    "* Jedna pusta linia pomiędzy kodem metod i funkcji zagnieżdżonych\n",
    "* Maksymalna długość linii kodu to 79 znaków\n",
    "* Nie używać ``from <module> import *`` - zatrucie przestrzeni nazw\n",
    "* starać się nie używać zmiennych ``l`` (małe L, podobne do 1), ``O`` (duże o, podobne do zero), ``I`` (duże i, podobne do 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Znaki spacji przed i po wyrażeniach przypisania i porównania (z wyjątkiem listy argumentów)\n",
    "\n",
    "    Dobrze:\n",
    "        a = 5\n",
    "        b = [1, 2, 3, 4]\n",
    "        f(a=5, b=10)\n",
    "    \n",
    "    Źle:\n",
    "        a=5\n",
    "        a= 5\n",
    "        a =5\n",
    "        f(a = 5, b = 10)\n",
    "        f(a= 5, b= 10)\n",
    "\n",
    "* Bez spacji na brzegach nawiasowania i listy argumentów\n",
    "\n",
    "    Dobrze:\n",
    "        (a + 3) * (5 - b)\n",
    "        \n",
    "    Źle:\n",
    "        (a+3)*(5-b)\n",
    "        ( a + 3 ) * ( 5 - b )\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jak uruchomić program w Pythonie?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* nie uruchamiać - pisać wprost w interpreterze (dobre jako kalkulator lub do najprostszych testów)\n",
    "* python &lt;nazwa pliku&gt; (patrz także: *shebang*)\n",
    "* sposób mieszany: python -i &lt;nazwa pliku&gt;\n",
    "* uruchomienie modułu: python -m pakiet.moduł\n",
    "* wpisując w interpreterze *import &lt;nazwa modułu&gt;*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przypisanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "a, b = 10, 15\n",
    "b, a = a, b\n",
    "print(a, b)\n",
    "\n",
    "# this be a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 0.5\n",
    "\n",
    "if number > 0:\n",
    "    print(\"Dodatni\")\n",
    "    print(\"Czyli większy od zera\")\n",
    "elif number == 0:\n",
    "    print(\"Zero\")\n",
    "else:\n",
    "    print(\"Ujemny\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Dodatni\" if number > 0 \n",
    "      else (\"Zero\" if number == 0 else \"Ujemny\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "wartosc1 if warunek else wartosc2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## MATCH-CASE\n",
    "\n",
    "dostępny od wersji 3.10\n",
    "\n",
    "https://towardsdatascience.com/the-match-case-in-python-3-10-is-not-that-simple-f65b350bb025"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def http_status(status):\n",
    "    match status:\n",
    "        case 400:\n",
    "            print(\"Bad request\")\n",
    "        case 401 | 403:\n",
    "            print(\"Authentication error\")\n",
    "        case 404:\n",
    "            return \"Not found\"\n",
    "        case _:\n",
    "            return \"Other error\"\n",
    "\n",
    "http_status(400)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pętla WHILE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 23\n",
    "running = True\n",
    "\n",
    "while running:\n",
    "    guess = int(input('Enter an integer : '))\n",
    "    if guess == number:\n",
    "        print('Congratulations, you guessed it.')\n",
    "        running = False # this causes the while loop to stop\n",
    "        break # - but we can't use break here -> no else then \n",
    "    elif guess < number:\n",
    "        print('No, it is a little higher than that.')\n",
    "    else:\n",
    "        print('No, it is a little lower than that.')\n",
    "else:\n",
    "    print('The while loop is over.')\n",
    "# Do anything else you want to do here\n",
    "\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pętla FOR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typowa pętla po liczbach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)\n",
    "else:\n",
    "    print('The for loop is over')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "W praktyce najczęściej iterujemy po elementach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in ['apple', 'orange', 'peach']:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for e in ('apple', 'orange', 'peach'):\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for e in {'apple', 'orange', 'peach'}:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "W takiej pętli nie mamy dostępu do indeksu elementu w liście, ale możemy taki uzyskać, odpowiednio mapując kolekcję za pomocą enumerate (generator):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "list(enumerate(['apple', 'orange', 'peach']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i, e in enumerate(['apple', 'orange', 'peach']):\n",
    "    print(i, e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(enumerate(['apple', 'orange', 'peach']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "collection = ['apple', 'orange', 'Peach']\n",
    "def is_valid(s):\n",
    "    return s.islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ind, elem in enumerate(collection):\n",
    "    if not is_valid(elem):\n",
    "        print(\"ERROR: Element {} at position {} is invalid\".format(elem, ind))\n",
    "        break\n",
    "else:\n",
    "    print(\"OK, all elements valid\")\n",
    "    # continuing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for ind, elem in enumerate(collection):\n",
    "    if not is_valid(elem):\n",
    "        print(\"ERROR: Element {} at position {} is invalid\".format(elem, ind))\n",
    "        break\n",
    "else:  # this is for's else\n",
    "    print(\"OK, all elements valid\")\n",
    "    # continuing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for i, j in zip([3, 4, 5], [6, 7, 8]):\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i, j, k in zip([3, 4, 5, 6], [6, 7, 8], [1, 2, 3]):\n",
    "    print(i, j, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from itertools import zip_longest\n",
    "\n",
    "for i, j, k in zip_longest([3, 4, 5, 6], [6, 7, 8], [1, 2, 3]):\n",
    "    print(i, j, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from itertools import zip_longest\n",
    "\n",
    "for i, j, k in zip_longest([3, 4, 5, 6], [6, 7, 8], [1, 2, 3], fillvalue=0):\n",
    "    print(i, j, k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Ewaluacja warunków"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wartością fałszywą jest:\n",
    "* False\n",
    "* None\n",
    "* 0\n",
    "* 0.0\n",
    "* pusty napis, lista, krotka, słownik...\n",
    "\n",
    "Wszystko inne jest prawdziwe*\n",
    "\n",
    "Ewaluacja wyrażenia złożonego jest przerywana, jeśli końcowa wartość jest znana.\n",
    "\n",
    "Wartością całego wyrażenia jest wartość ostatniego członu, który był ewaluowany."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\"a\" and 0 and [0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "0 or [0] or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "bool(\"False\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    print(\"X\")\n",
    "    return False\n",
    "\n",
    "\"1\" or f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def xor(a, b):\n",
    "    return bool(a) != bool(b)\n",
    "\n",
    "# albo from operator import xor\n",
    "\n",
    "xor([0], [])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Jakie są priorytety i wiązanie operatorów logicznych?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "True or False and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "True and False or True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "https://docs.python.org/3/reference/expressions.html#operator-precedence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Porównanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1000\n",
    "b = 1000\n",
    "print(a == b)\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 1000\n",
    "b = a\n",
    "print(a == b)\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "b -= 1\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Importowanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import e\n",
    "print(e)\n",
    "print(math.e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi as PI\n",
    "print(PI)\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Szablon programu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    print(\"Hello world\")\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Typizacja zmiennych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Python, Groovy, JavaScript, Ruby są **dynamicznie typowalne (dynamic typing)**\n",
    "    * Typ związany z wartością – nie zmienną\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1000000\n",
    "print(x, type(x), repr(x), id(x))\n",
    "x = \"1000000\"\n",
    "print(x, type(x), repr(x), id(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* C/C++, Java są **statycznie typowalne (static typing)**\n",
    "     * Typ związany ze zmienną – nie wartością, czasem niejawnie:\n",
    "            \n",
    "```\n",
    "int main() {\n",
    "    int x = 5;\n",
    "    float y = 1.2;\n",
    "    auto z = x*y;\n",
    "    return 0;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Python jest **silnie typowalny (strongly typed)**\n",
    "    * Kontrola, czy operacje są wykonalne na danym typie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"1\" + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"1\" + str(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(\"1\") + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "\n",
    "* JavaScript jest **słabo typowalny (weakly typed)**\n",
    "    * Rzutowania wykonywane są w locie\n",
    "    * \"9\" + 1 -> \"91\"; \"91\" - 1 -> 90\n",
    "\n",
    "* Python ma **bezpieczną typizację (type-safe)**\n",
    "* C **nie ma bezpiecznej typizacji (type-unsafe)**\n",
    "    * rzutowanie z/na void*            \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Duck Typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Duck:\n",
    "    def quack(self): \n",
    "        print(\"Quaaaaaack!\")\n",
    "    def feathers(self): \n",
    "        print(\"The duck has white and gray feathers.\")\n",
    "\n",
    "class Person:\n",
    "    def quack(self):\n",
    "        print(\"The person imitates a duck.\")\n",
    "    def feathers(self): \n",
    "        print(\"The person takes a feather and shows it.\")\n",
    "\n",
    "def in_the_forest(duck):\n",
    "    duck.quack()\n",
    "    duck.feathers()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def game():\n",
    "    donald = Duck()\n",
    "    john = Person()\n",
    "    in_the_forest(donald)\n",
    "    in_the_forest(john)\n",
    "\n",
    "game()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}