U1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Język Python - Laboratorium 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Harmonogram zajęć\n",
    "\n",
    "1. Organizacyjne\n",
    "2. Zatwierdzenie tematów i harmonogram prac\n",
    "3. Zarys systemu\n",
    "4. przedstawienie postępów, problemów, ciekawostek\n",
    "5. c.d.\n",
    "6. Prezentacja \"gotowego\" systemu\n",
    "7. Oddanie projektu, podsumowanie\n",
    "\n",
    "tydzień A: 28 II, 14 III, 28 III, 11 IV, 9 V, 23 V, 6 VI\n",
    "\n",
    "tydzień B: 7 III, 21 III, 4 IV, 25 IV, 16 V, 30 V, 13 VI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zasady oceny\n",
    "### Kryteria oceniania\n",
    "- zakres funkcjonalności\n",
    "- intuicyjność użytkowania\n",
    "- czytelność kodu\n",
    "- adekwatność użytych rozwiązań\n",
    "- sposób pracy\n",
    "\n",
    "Wszystkie kryteria są oceniane w skali 2, 3, 4, 5.\n",
    "Jeśli 2 lub więcej kryteriów jest ocenione na 2, to ocena za projekt wynosi 2.0.\n",
    "W przeciwnym przypadku jest średnią ocen za wszystkie kryteria, zaokrągloną do najbliższej oceny regulaminowej.\n",
    "Ocena może zostać podniesiona o 0.5 na zasadzie vox populi, pod warunkiem że jest pozytywna."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Git\n",
    "\n",
    "https://try.github.io/"
   ]
  },
  {
   "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": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    print(\"Hello world\")\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Równanie kwadratowe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve_quadratic(a, b, c):\n",
    "    delta = b**2 - 4*a*c\n",
    "    if delta < 0:\n",
    "        return ()\n",
    "    elif delta == 0:  # porównywanie float'a do 0 jest niebezpieczne\n",
    "        return (-b/(2*a),)\n",
    "    else:\n",
    "        return ((-b - delta**0.5) / (2*a), (-b + delta**0.5) / (2*a))\n",
    "\n",
    "def main():\n",
    "    print(solve_quadratic(1, 1, 1))\n",
    "    print(solve_quadratic(-1, 1, 1))\n",
    "    print(solve_quadratic(2, 4, 2))\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Błędy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve_quadratic(a, b, c):\n",
    "    delta = b**2 - 4*a*c\n",
    "    if delta < 0:\n",
    "        return ()\n",
    "    elif delta == 0:\n",
    "    return (-b/(2*a),)\n",
    "    else:\n",
    "        return ((-b - delta**0.5) / (2*a), (-b + delta**0.5) / (2*a))\n",
    "\n",
    "def main():\n",
    "    print(solve_quadratic(1, 1, 1))\n",
    "    print(solve_quadratic(-1, 1, 1))\n",
    "    print(solve_quadratic(2, 4, 2))\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def solve_quadratic(a, b, c):\n",
    "    delta = b**2 - 4*a*c\n",
    "    if delta < 0:\n",
    "        return ()\n",
    "    elif delta == 0:\n",
    "        return (-b/(2*aa),)\n",
    "    else:\n",
    "        return ((-b - delta**0.5) / (2*a), (-b + delta**0.5) / (2*a))\n",
    "\n",
    "def main():\n",
    "    print(solve_quadratic(1, 1, 1))\n",
    "    print(solve_quadratic(-1, 1, 1))\n",
    "    print(solve_quadratic(2, 4, 2))\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def solve_quadratic(a, b, c):\n",
    "    delta = b**2 - 4*a*c\n",
    "    if delta < 0:\n",
    "        return ()\n",
    "    elif delta == 0:\n",
    "        return (-b/2*a,)\n",
    "    else:\n",
    "        return ((-b - delta**0.5) / 2*a, (-b + delta**0.5) / 2*a)\n",
    "\n",
    "def main():\n",
    "    print(solve_quadratic(1, 1, 1))\n",
    "    print(solve_quadratic(-1, 1, 1))\n",
    "    print(solve_quadratic(2, 4, 2))\n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importowanie i funkcja dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "from math import sqrt\n",
    "\n",
    "print(\"Global\", dir(), end=\"\\n\\n\")\n",
    "print(\"Module\", dir(math), end=\"\\n\\n\")\n",
    "print(\"?\", dir('math'), end=\"\\n\\n\")\n",
    "\n",
    "def f():\n",
    "    a = 3\n",
    "    print(\"Local\", dir())\n",
    "    b = 4\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sprawdzić, kiedy jest obliczana wartość domyślna parametru funkcji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def append_five(a=[]):\n",
    "    a += [5]\n",
    "    print(a)\n",
    "   # return a\n",
    "    \n",
    "append_five()\n",
    "append_five()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def append_five(a=None):\n",
    "    if a is None:\n",
    "        a = []\n",
    "    a += [5]\n",
    "    print(a)\n",
    "    return a\n",
    "    \n",
    "append_five()\n",
    "append_five()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wczytać listę ocen z linii poleceń, obliczyć średnią i uciąć ją po zadanej liczbie miejsc po przecinku (domyślnie 2)\n",
    "\n",
    "np. \"python3 avg.py 3 4 4 -d 3\" ma dać 3.666"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# sys.argv\n",
    "- porównywanie stringów (operator `==`)\n",
    "- operator `in`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# argparse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- pobiera i analizuje argumenty wywołania\n",
    "- zastępuje przestarzały moduł optparse\n",
    "- alternatywa dla getopt (vide: C) oraz ręcznego analizowania zmiennej sys.argv\n",
    "- zarządza:\n",
    "    - parametrami pozycyjnymi\n",
    "    - parametrami opcjonalnymi (flagami) w wersji krótkiej i długiej\n",
    "    - tekstem pomocy informującym o prawidłowym użyciu (w reakcji na opcję -h/--help)\n",
    "    - komunikatem o błędnym wywołaniu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys # potrzebne dla ręcznej modyfikacji sys.argv; w przypadku uruchamiania z konsoli można usunąć\n",
    "import argparse\n",
    "\n",
    "# nie róbcie tego w domu\n",
    "def exit(*args, **kwargs):\n",
    "    print(\"Program exited with {} and {}\".format(args, kwargs))\n",
    "    \n",
    "sys.exit = exit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.argv = ['script.py','-h']\n",
    "parser = argparse.ArgumentParser()\n",
    "parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.argv = ['script.py', '-c']\n",
    "parser = argparse.ArgumentParser()\n",
    "parser.parse_args()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Argumenty pozycyjne są rozróżniane na podstawie miejsca w linii komend, gdzie występują\n",
    "- Argumenty opcjonalne (flagi) są rozróżniane na podstawie nazwy lub jej jednoznacznego prefixu\n",
    "- Jedne i drugie dodajemy wywołując komendę add_argument i przekazując jej nazwę argumentu\n",
    "- Dostęp do pobranych parametrów odbywa się poprzez obiekt Namespace, zwrócony przez metodę parse_args\n",
    "    - zwrócony obiekt ma pola, których nazwy odpowiadają pierwszej długiej nazwie (lub pierwsze w ogóle, jesli nie ma długiej - dotyczy argumentów opcjonalnych)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.argv = ['script.py', 'file.txt']\n",
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"input_file\")\n",
    "args = parser.parse_args()\n",
    "print(args.input_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parametr `nargs` oznacza liczbę argumentów danego typu. Może przyjmować następujące wartości:\n",
    "    - liczbę - program wymaga dokładnie takiej liczby parametrów\n",
    "    - \"?\" - parametr jest opcjonalny (może wystąpić raz lub nie wystąpić)\n",
    "    - \"*\" - parametr może wystąpić dowolną liczbę razy, lub nie wystąpić\n",
    "    - \"+\" - parametr może wystąpić dowolną liczbę razy, ale minimum jeden\n",
    "    - argparse.REMAINDER - parametr będzie zawierał wszystko \"zbędne\" z linii komend (np. celem przekazania do innego programu); musi to być ostatni parametr dodany do parsera\n",
    "Domyślnie równe 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.argv = ['script.py', 'file.txt', 'file1.txt', 'file2.txt']\n",
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"input_files\", nargs=\"+\")\n",
    "parser.add_argument(\"output_file\")\n",
    "args = parser.parse_args()\n",
    "print(args.input_files, args.output_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.argv = ['script.py', '-h']\n",
    "parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"-v\", \"--verbose\", action='store_true')\n",
    "\n",
    "sys.argv = ['script.py', '-v']\n",
    "print(parser.parse_args())\n",
    "\n",
    "sys.argv = ['script.py']\n",
    "print(parser.parse_args())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parametr `action` oznacza akcję do wykonania:\n",
    "    - \"store\" - zapisz przekazaną wartosć (domyślnie)\n",
    "    - \"store_const\", \"store_true\", \"store_false\" - zapisz stałą wartość (dla store_const należy dodać parametr const, okreslający wartość do zapisania)\n",
    "    - \"append\" - dopisz wartość do listy\n",
    "    - \"count\" - zlicz wystąpienia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"-o\", \"--output_file\", default=\"a.out\")\n",
    "\n",
    "sys.argv = ['script.py', '-o', 'output.file']\n",
    "print(parser.parse_args())\n",
    "\n",
    "sys.argv = ['script.py']\n",
    "print(parser.parse_args())\n",
    "\n",
    "sys.argv = ['script.py', '-o']\n",
    "print(parser.parse_args())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"-v\", \"-V\", \"--verbose\", action=\"count\", help=\"Makes output of program more verbose\")\n",
    "\n",
    "sys.argv = ['script.py','-vv','--ver']\n",
    "print(parser.parse_args())\n",
    "\n",
    "sys.argv = ['script.py','-h']\n",
    "print(parser.parse_args())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"-d\")\n",
    "\n",
    "sys.argv = ['script.py','-d', '3']\n",
    "args = parser.parse_args() \n",
    "print(args)\n",
    "print(type(args.d))\n",
    "\n",
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"-d\", type=int)\n",
    "\n",
    "sys.argv = ['script.py','-d', '3']\n",
    "args = parser.parse_args() \n",
    "print(args)\n",
    "print(type(args.d))\n",
    "\n",
    "sys.argv = ['script.py','-d', '3.5']\n",
    "print(parser.parse_args())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`type` określa typ argumentu (albo argumentów). Najczęściej używamy `int` albo `float`, ale możemy definiować własne.\n",
    "\n",
    "Właściwie możemy użyć też `list`, `tuple` itp. ale jest to mało użyteczne (jak działa konwersja stringa na krotkę?).\n",
    "\n",
    "Może to być też nazwa klasy, pod warunkiem, że konstruktor przyjmuje jednego stringa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filename(arg):\n",
    "    try:\n",
    "        with open(arg, \"r\"):\n",
    "            pass\n",
    "    except OSError:\n",
    "        raise argparse.ArgumentTypeError(\"File {!r} cannot be opened\".format(arg))\n",
    "    return arg\n",
    "\n",
    "parser = argparse.ArgumentParser()\n",
    "parser.add_argument(\"infile\", type=filename)\n",
    "print(parser.parse_args(['no_such_file.txt']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filename(arg):\n",
    "    with open(arg, \"r\"):\n",
    "        return arg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inne opcjonalne parametry dla `add_argument`\n",
    "- `metavar` - alternatywna nazwa argumentu do wyświetlenia w tekście pomocy, np. do tłumaczenia na inny język (W Jupyter notebook'u nie działa)\n",
    "- `choices` - lista wartości jakie może przyjmować argument\n",
    "\n",
    "Argumenty opcjonalne (do programu):\n",
    "- mogą mieć warianty (krótki, długi...)\n",
    "- można stosować tylko prefiks długiej nazwy, pod warunkiem, że parser jest w stanie jednoznacznie określić, o który parametr chodzi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`add_mutually_exclusive_group` - tworzy grupę parametrów, które nie mogą współwystępować"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import argparse\n",
    "\n",
    "parser = argparse.ArgumentParser()\n",
    "group = parser.add_mutually_exclusive_group()\n",
    "group.add_argument(\"-v\", \"--verbose\", action=\"store_true\")\n",
    "group.add_argument(\"-q\", \"--quiet\", action=\"store_true\")\n",
    "print(parser.parse_args([])) # można przekazać listę parametrów do funkcji parse_args\n",
    "print(parser.parse_args(['-q']))\n",
    "print(parser.parse_args(['-q','-v']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tap (Typed Argument Parser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://pypi.org/project/typed-argument-parser/\n",
    "\n",
    "Można instalować jako typed-argument-parser, **nie tap**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tap import Tap as TypedArgumentParser\n",
    "\n",
    "class MyArgs(TypedArgumentParser):\n",
    "    a: float = 1  # acceleration\n",
    "    pi: int = 3.14  # what value of pi should we use\n",
    "    input_filename: str  # file to read\n",
    "        \n",
    "args = MyArgs().parse_args([\"--input_filename\", \"log.log\"])\n",
    "print(args)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Click"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "sys.argv = \"main.py --help\".split()\n",
    "\n",
    "# źródło: https://click.palletsprojects.com/en/7.x/\n",
    "\n",
    "import click\n",
    "\n",
    "@click.command()\n",
    "@click.option('--count', default=1, help='Number of greetings.')\n",
    "@click.option('--name', prompt='Your name',\n",
    "              help='The person to greet.')\n",
    "def hello(count, name):\n",
    "    \"\"\"Simple program that greets NAME for a total of COUNT times.\"\"\"\n",
    "    for x in range(count):\n",
    "        click.echo('Hello %s!' % name)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://towardsdatascience.com/how-to-write-python-command-line-interfaces-like-a-pro-f782450caf0d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zadanie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dany jest program z dziedziny uczenia maszynowego. Należy napisać kod, który wczyta z linii poleceń następujące parametry:\n",
    "- dane treningowe\n",
    "- dane testowe\n",
    "- opcjonalnie plik wyjściowy (domyślnie wyniki będą wypisywane na ekran)\n",
    "- opcjonalnie plik z modelem (przyjmujemy, że jest jakiś plik, którego używamy domyślnie)\n",
    "- algorytm (do wyboru spośród RNN, LSTM1 i LSTM2)\n",
    "- ile przykładów negatywnych należy wygenerować (dowolna nieujemna liczba całkowita)\n",
    "- rozmiar warstwy ukrytej (do wyboru spośród 100, 150 i 300)"
   ]
  },
  {
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}