PwP - Ćwiczenie_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "44d6fff7",
   "metadata": {},
   "source": [
    "# Funkcje i sterowanie przepływem"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7afdf03e",
   "metadata": {},
   "source": [
    "Zapoznamy się z słowami kluczowymi:\n",
    "\n",
    "* def, return, pass\n",
    "\n",
    "* for, while, continue, break\n",
    "\n",
    "* if, elif, else\n",
    "\n",
    "* global, nonlocal\n",
    "\n",
    "<br>\n",
    "\n",
    "\n",
    "oraz funkcjami wbudowanymi:\n",
    "\n",
    "* globals / locals\n",
    "\n",
    "* enumerate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a13937c2",
   "metadata": {},
   "source": [
    "**Korekta** - Od Pythona 3.7 kolejność elementów w słowniku jest gwarantowana, tzn. elementy są zwracane w takiej kolejności, w jakiej zostały dodane."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f5e2b89",
   "metadata": {},
   "source": [
    "### Funkcje\n",
    "\n",
    "Definicję nowej funkcji rozpoczynamy od słowa kluczowego **def**. Następnie zgodnie z zalecaną konwencją* **snake_case** małymi literami podajemy nazwę funkcji, w której wyrazy rozdzielamy znakiem podkreślenia **_**. \n",
    "\n",
    "W Pythonie ważna jest dla nas **czytelność kodu**, jako iż zazwyczaj jest on częściej czytany niż pisany. Przy odpowiednio nazwanej zmiennej / funkcji komentarz powinien być zbyteczny.\n",
    "\n",
    "Po nazwie umieszczamy nawias okrągły **()**, w którym możemy umieścić wymagane przez funkcje argumenty oraz ich wartości domyślne.\n",
    "\n",
    "Na końcu lini umieszczamy **:**, po którym (przy nowym poziomie indentacji) zamieszczamy blok kodu, który ma wykonywać się przy jej wywołaniu.\n",
    "\n",
    "Definicję możemy zakończyć słowem kluczowym **return**, po którym umieszcamy wartość lub wyrażenie, które ma być zwracane. W przeciwnym wypadku funkcja zwróci **None**.\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "*PEP – Style Guide for Python Code\n",
    "\n",
    "https://peps.python.org/pep-0008/#function-and-variable-names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "37d4e118",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "def do_something(x, y=1):\n",
    "    \n",
    "    new_number = x + y\n",
    "    \n",
    "    return new_number\n",
    "\n",
    "print(do_something(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "48e52379",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " WARNING: THIS FUNCTION DOES SOMETHING!\n"
     ]
    }
   ],
   "source": [
    "def do_something(x, y=1):\n",
    "    \"\"\" WARNING: THIS FUNCTION DOES SOMETHING!\"\"\"\n",
    "    return x + y\n",
    "\n",
    "\n",
    "# w definicji funkcji do_something umieściliśmy docstring, który możemy wyświetlić używając metody specjalnej __doc__\n",
    "print(do_something.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27d05745",
   "metadata": {},
   "source": [
    "Natomiast z słowa kluczowego **pass** możemy korzystać w ogólności kiedy syntaktycznie wymagana jest kontynuacja kodu, ale żadne działanie nie ma być podjęte przez program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b0d64cc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sorki_jeszcze_nie_mam_pomysłu():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e09de811",
   "metadata": {},
   "source": [
    "Funkcje mogą również przyjmować zmienną liczbę wartości / argumentów poprzez *args oraz **kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4385395e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "8\n",
      "3 4 1\n"
     ]
    }
   ],
   "source": [
    "# *args - non-keyword arguments: zostaną spakowane do krotki args\n",
    "\n",
    "def input_a_bunch_of_stuff(*args):\n",
    "    \n",
    "    print(type(args))\n",
    "    print(sum(args))\n",
    "    print(*args)\n",
    "    \n",
    "input_a_bunch_of_stuff(3,4,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "53d127b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'x': 1, 'y': 1, 'z': 1}\n",
      "x y z\n",
      "wartość 'z' wynosi: 1\n"
     ]
    }
   ],
   "source": [
    "# **kwargs - keyword arguments: zostaną spakowane do słownika kwargs\n",
    "\n",
    "def input_a_bunch_of_stuff(**kwargs):\n",
    "    \n",
    "    print(type(kwargs))\n",
    "    print(kwargs)\n",
    "    print(*kwargs)\n",
    "    \n",
    "    if 'z' in kwargs:\n",
    "        print(f\"wartość 'z' wynosi: {kwargs['z']}\")\n",
    "    \n",
    "input_a_bunch_of_stuff(x=1, y=1, z=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88ba1d21",
   "metadata": {},
   "source": [
    "Argumenty pozycyjne muszą pojawić się przed nazwanymi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f890a8d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args = (1, 1, 1, 1, 1)\n",
      "a=9, b=9\n",
      "kwargs = {'x': 1, 'y': 1, 'z': 1}\n"
     ]
    }
   ],
   "source": [
    "# przykład ekstremalny\n",
    "\n",
    "def input_a_lot_of_stuff(a, b=5, *args, obowiązkowy_argument_kw, **kwargs):\n",
    "    \n",
    "    print(\"args =\", args)\n",
    "    print(f\"a={a}, b={b}\")\n",
    "    print(\"kwargs =\", kwargs)\n",
    "    \n",
    "# b miał wartość domyślną, ale została nadpisana\n",
    "input_a_lot_of_stuff(9, 9, 1, 1, 1, 1, 1, obowiązkowy_argument_kw=1, x=1, y=1, z=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5e71102",
   "metadata": {},
   "source": [
    "Funkcje mogą również zwracać w kilku miejscach.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f61c1074",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'No'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_my_number_good_check(my_number):\n",
    "    \n",
    "    if my_number < 15:\n",
    "        return \"No\"\n",
    "    \n",
    "    elif my_number > 15 and my_number <= 22:\n",
    "        return \"yes\"\n",
    "    \n",
    "    else:\n",
    "        return \"No\"\n",
    "    \n",
    "is_my_number_good_check(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f72ec7f",
   "metadata": {},
   "source": [
    "#### Lokalna i globalna przestrzeń nazw\n",
    "\n",
    "Funkcje nieuchronnie sprowadzają nas do koncpepcji przestrzeni nazw (*ang. namespace*), która jest w Pythonie bardzo istotna. Cytując \"The Zen of Python\":\n",
    "\n",
    "        \"Namespaces are one honking great idea -- let's do more of those!\"\n",
    "        \n",
    "Hierarchia zasięgu (*ang. scope*) zmiennych (reguła LEGB):\n",
    "\n",
    "    Built-in -- słowa kluczowe / funkcje wbudowane\n",
    "    \n",
    "            Global -- dla całego jednego pliku / modułu\n",
    "            \n",
    "                    Enclosing -- zakres lokalny funkcji zagnieżdżonych\n",
    "                    \n",
    "                            Local -- zakres lokalny"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35cb78d9",
   "metadata": {},
   "source": [
    "Wywołana funkca tworzy (na czas wykonywania) własną przestrzeń nazw, która nie będzie dostępna / widoczna z innych miejsc w programie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "91f2522e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zmienna globalna\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[7], line 11\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[38;5;28mprint\u001b[39m(x)\n\u001b[0;32m      9\u001b[0m funkcja()\n\u001b[1;32m---> 11\u001b[0m \u001b[38;5;28mprint\u001b[39m(y)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "x = 'zmienna globalna'\n",
    "\n",
    "def funkcja():\n",
    "    \n",
    "    y = 'zmienna lokalna'\n",
    "    print(x)\n",
    "\n",
    "    \n",
    "funkcja()\n",
    "\n",
    "print(y) # w tym momencie y już nie istnieje"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "106dc39e",
   "metadata": {},
   "source": [
    "Podczas interpretacji kodu zmienna będzie wyszukiwana zaczynając od najniższego poziomu, jeżeli nie zostanie w nim odnaleziona wyszukiwanie rozpocznie się na wyższym poziomie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bf064556",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W inner x = 3\n",
      "W outer x = 2\n",
      "Zmienna globalna x = 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def outer():\n",
    "    \n",
    "    x = 2\n",
    "    \n",
    "    def inner():\n",
    "        \n",
    "        x = 3\n",
    "        print(\"W inner x =\", x)\n",
    "        \n",
    "        return\n",
    "    \n",
    "    inner()\n",
    "    print(\"W outer x =\", x)\n",
    "    \n",
    "    return\n",
    "\n",
    "outer()\n",
    "print(\"Zmienna globalna x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f5a99fd",
   "metadata": {},
   "source": [
    "Etapy wykonywania kodu możemy prześledzić na https://pythontutor.com/visualize.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7ce400bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W inner x = 2\n",
      "W outer x = 2\n",
      "Zmienna globalna x = 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def outer():\n",
    "    \n",
    "    x = 2\n",
    "    \n",
    "    def inner():\n",
    "        \n",
    "        #x = 3\n",
    "        print(\"W inner x =\", x)\n",
    "        \n",
    "        return\n",
    "    \n",
    "    inner()\n",
    "    print(\"W outer x =\", x)\n",
    "    \n",
    "    return\n",
    "\n",
    "outer()\n",
    "print(\"Zmienna globalna x =\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "78fc29a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W inner x = 1\n",
      "W outer x = 1\n",
      "Zmienna globalna x = 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def outer():\n",
    "    \n",
    "    #x = 2\n",
    "    \n",
    "    def inner():\n",
    "        \n",
    "        #x = 3\n",
    "        print(\"W inner x =\", x)\n",
    "        \n",
    "        return\n",
    "    \n",
    "    inner()\n",
    "    print(\"W outer x =\", x)\n",
    "    \n",
    "    return\n",
    "\n",
    "outer()\n",
    "print(\"Zmienna globalna x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8bb96e3",
   "metadata": {},
   "source": [
    "Wykorzystując słowa kluczowe **global / nonlocal** możemy zmienić przestrzeń, w której zmienna będzie wyszukiwana, ale zazwyczaj jest to uznawane za działanie niepoprawne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "54a8a07d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W inner x = 3\n",
      "W outer x = 2\n",
      "Zmienna globalna x = 3\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def outer():\n",
    "    \n",
    "    x = 2\n",
    "    \n",
    "    def inner():\n",
    "        \n",
    "        global x\n",
    "        x = 3\n",
    "        print(\"W inner x =\", x)\n",
    "        \n",
    "        return\n",
    "    \n",
    "    inner()\n",
    "    print(\"W outer x =\", x)\n",
    "    \n",
    "    return\n",
    "\n",
    "outer()\n",
    "print(\"Zmienna globalna x =\", x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7c13ed1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W inner x = 3\n",
      "W outer x = 3\n",
      "Zmienna globalna x = 1\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "def outer():\n",
    "    \n",
    "    x = 2\n",
    "    \n",
    "    def inner():\n",
    "        \n",
    "        nonlocal x\n",
    "        x = 3\n",
    "        print(\"W inner x =\", x)\n",
    "        \n",
    "        return\n",
    "    \n",
    "    inner()\n",
    "    print(\"W outer x =\", x)\n",
    "    \n",
    "    return\n",
    "\n",
    "outer()\n",
    "print(\"Zmienna globalna x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ee7e4a2",
   "metadata": {},
   "source": [
    "Funkcje globals i locals zwracają słwonik zawierający {nazwa_zmiennej : wartość} dla danej przestrzeni nazw. Mogą być potencjalnie przydatne na egzaminie praktycznym.. (zakładam że nie)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "717a87c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': 1, 'y': 42}\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "\n",
    "def function_has_its_own_local_namespace():\n",
    "    x = 1\n",
    "    y = 42\n",
    "    \n",
    "    print(locals())\n",
    "    \n",
    "function_has_its_own_local_namespace()\n",
    "\n",
    "#print(globals())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "896f95fd",
   "metadata": {},
   "source": [
    "### Sterowanie przepływem \n",
    "\n",
    "Kolejność wykonywania instrukcji może być inna niż zapisana w kodzie źródłowym. Pośród najbardziej podstawowych zmian przepływu możemy wyróżnić:\n",
    "\n",
    "\n",
    "* wybór - wykonanie warunkowe\n",
    "* pętla - powtarzanie wykonywania\n",
    "* skok - kontynuacja od innego punktu w programie"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30b9a4d7",
   "metadata": {},
   "source": [
    "#### Instrukcje wykonywania warunkowego (*if*, *elif*, *else*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cf0981d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x jest ujemne\n"
     ]
    }
   ],
   "source": [
    "x = -1\n",
    "\n",
    "# ten warunek zawsze będzei sprawdzany\n",
    "if x == 0:\n",
    "    print(\"x jest równe zero\")\n",
    "\n",
    "# elif (czyt. else if)\n",
    "# ten warunek zostanie sprawdzony tylko jeżeli poprzedzający **if** nie będzie spełniony\n",
    "elif x > 0:\n",
    "    print(\"x jest dodatnie\")\n",
    "    \n",
    "# ten warunek zostanie sprawdzony tylko jeżeli poprzedni **elif** nie będzie spełniony\n",
    "elif x < 0:\n",
    "    print(\"x jest ujemne\")\n",
    "    \n",
    "# instrukcje w tym bloku zostaną wykonane tylko jeżeli żaden powyższy warunek nie będzie spełniony\n",
    "else:\n",
    "    print(\"x to coś zupełnie innego\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da54f0f3",
   "metadata": {},
   "source": [
    "#### Pętle - instrukcje *for* i *while*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f1f03370",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 "
     ]
    }
   ],
   "source": [
    "kolekcja = list(range(5))\n",
    "\n",
    "for element in kolekcja:\n",
    "    print(element, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "53be0d95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 \n",
      "0 1 2 3 4 5 \n",
      "0 1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 3, 1):\n",
    "    for j in range(6):\n",
    "        print(j, end=' ')\n",
    "        \n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "136ebd62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "\n",
    "while x < 10:\n",
    "    print(x, end=' ')\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "468067a4",
   "metadata": {},
   "source": [
    "Przechodzenie po słownikach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "fc533320",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frytki 7.5\n",
      "kotlet 11.5\n",
      "pomidor 2.45\n",
      "feta 60\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "    \"frytki\" : 7.5,\n",
    "    \"kotlet\" : 11.5,\n",
    "    \"pomidor\" : 2.45,\n",
    "    \"feta\" : 60\n",
    "}\n",
    "\n",
    "for key in d.keys():\n",
    "    print(key, d[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8607e5cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frytki : 7.5\n",
      "kotlet : 11.5\n",
      "pomidor : 2.45\n",
      "feta : 60\n"
     ]
    }
   ],
   "source": [
    "for key, value in d.items():\n",
    "    print(f'{key} : {value}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "0a8cafe6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['feta', 'frytki', 'kotlet', 'pomidor']\n"
     ]
    }
   ],
   "source": [
    "# key=str używa funkcji str() na każdym kluczu\n",
    "# aby nie porównywać różnych typów danych\n",
    "\n",
    "sorted_keys = sorted(d.keys(), reverse=False, key=str)\n",
    "\n",
    "print(sorted_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d07cd7f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pomidor': 2.45, 'kotlet': 11.5, 'frytki': 7.5, 'feta': 60}\n"
     ]
    }
   ],
   "source": [
    "d_sorted = dict(sorted(d.items(), reverse=True)) #sorted nie jest in-place\n",
    "print(d_sorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a1ec9e1",
   "metadata": {},
   "source": [
    "Enumerate, pokazujemy że nie jesteśmy zieloni.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "19e83149",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 M, 1 S, 2 D, 3 S, "
     ]
    }
   ],
   "source": [
    "x = [\"Marcjn\", \"Stefam\", \"Damina\", \"Sbastian\"]\n",
    "\n",
    "# lamerski sposób\n",
    "for i in range(len(x)):\n",
    "    print(i, x[i][0], end=', ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "492364c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element nr 0: M, Element nr 1: S, Element nr 2: D, Element nr 3: S, "
     ]
    }
   ],
   "source": [
    "# funkcja enumerate() zwraca iterowalny\n",
    "# obiekt typu enumerate przechowujący krotki\n",
    "# (indeks, element)\n",
    "for i, elem in enumerate(x):\n",
    "    print(f'Element nr {i}: {elem[0]}', end=', ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d94fd01e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element nr 7: M, Element nr 8: S, Element nr 9: D, Element nr 10: S, "
     ]
    }
   ],
   "source": [
    "for i, elem in enumerate(x, start=7):\n",
    "    print(f'Element nr {i}: {elem[0]}', end=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44ec42c2",
   "metadata": {},
   "source": [
    "Przechodzenie po czymś większym ;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "76faeec4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K9O3 1\n",
      "D2F8 2\n",
      "B6J9 3\n",
      "1B0D 4\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "    'K9O3' : [{'a' : [1, 2, 3]}, {'b' : [{'a' : 1}]}],\n",
    "    'D2F8' : [{'a' : [3, 2, 1]}, {'b' : [{'a' : 2}]}],\n",
    "    'B6J9' : [{'a' : [1, 1, 1]}, {'b' : [{'a' : 3}]}],\n",
    "    '1B0D' : [{'a' : [0, 0, 0]}, {'b' : [{'a' : 4}]}]\n",
    "}\n",
    "\n",
    "for some_id in d.keys():\n",
    "    for entity in d[some_id]:\n",
    "        \n",
    "        if 'b' in entity.keys():\n",
    "            \n",
    "            print(some_id, entity['b'][0]['a'])    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c650d00",
   "metadata": {},
   "source": [
    "#### Kontynacja od innego punktu w programie - break i continue\n",
    "\n",
    "*break* wychodzi z pętli podczas gdy *continue* przechodzi do następnej iteracji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5b634f42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 is not 5!\n",
      "1 is not 5!\n",
      "0 is not 5!\n",
      "4 is not 5!\n",
      "0 is not 5!\n",
      "4 is not 5!\n",
      "2 is not 5!\n",
      "1 is not 5!\n",
      "1 is not 5!\n",
      "3 is not 5!\n",
      "5 is 5!\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "while True:\n",
    "    \n",
    "    n = randint(0, 5)\n",
    "    \n",
    "    if n == 5:\n",
    "        print(n, \"is 5!\")\n",
    "        break\n",
    "        \n",
    "    else:\n",
    "        print(n, \"is not 5!\")\n",
    "        continue\n",
    "        \n",
    "    print(\":'(\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "061bd91c",
   "metadata": {},
   "source": [
    "**Zadanie 1.** Napisz funkcję, która gra z użytkownikiem w grę \"zgadnij sekretną liczbę z przedziału\" np. [0, 20]. Dopóki użytkownik niezgadnie liczby program:\n",
    "\n",
    "            1. Prosi go o podanie liczby\n",
    "            2. Uaktualnia liczbę dotychczasowych prób odgadnięcia o jeden\n",
    "            \n",
    "            3. Sprawdza czy sekretna liczba została odgadnięta,\n",
    "                    \n",
    "                    jeżeli tak - gratuluje i informuje o liczbie prób\n",
    "                    jeżeli nie - informuje użytkownika czy jest większa / mniejsza od wprowadzonej przez niego\n",
    "            \n",
    "Podpowiedź: Dane przyjęte przez input() domyślnie będą typu str, można temu zaradzić poprzez x = int(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a29ff7bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return random integer in range [a, b], including both end points.\n",
      "        \n",
      "2\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "print(randint.__doc__)\n",
    "\n",
    "sekretna_liczba = randint(0, 20)\n",
    "\n",
    "print(sekretna_liczba)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "419316d3",
   "metadata": {},
   "source": [
    "**Zadanie 2.** Napisz funkcję, która zlicza występujące w sekwencji zasady azotowe i zwraca je w postaci słownika, jeżeli podana sekwencja jest poprawnym DNA (zawiera tylko ATCG)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49f8f9fb",
   "metadata": {},
   "source": [
    "**Zadanie 3.** Napisz funkcję, która po przyjęciu poprawnej sekwencji DNA zwraca sekwencję odwrotnie komplementarną."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9416a1f",
   "metadata": {},
   "source": [
    "**Zadanie 4.** Napisz funkcję, która na podstawie danych z PDBe dla zadanego identyfikatora z Uniprot (Q9NR28) wybiera strukturę ('pdb_id' i 'entity_id') o najlepszej (najmniejszej) rozdzielczości ('resolution') dla 'experimental_method'=='Electron Microscopy'.\n",
    "\n",
    "Podpowiedź: Otrzymane dane mają strukturę {accession : [lista słowników odnalezionych struktur]}.\n",
    "\n",
    "Następnie wywołuje funkcje *get_sequence_and_structural_domains_from_pdbe* i z otrzymanych danych wypisuje 'domainName' z każdej bazy danych.\n",
    "\n",
    "Podpowiedź:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18715803",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in dane_z_drugiej_funkcji[pdb_id]['data'][0]['residues']:\n",
    "    print(i['additionalData']['domainName'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0f2ce0b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "# jeżeli brak requests - pip install requests\n",
    "# możliwe że nowsze jest https://www.ebi.ac.uk/pdbe/api/mappings/best_structures/\n",
    "\n",
    "def get_best_structurs_data_from_pdbe(accession):\n",
    "    return requests.get(f\"https://www.ebi.ac.uk/pdbe/graph-api/mappings/best_structures/{accession}\").json()\n",
    "\n",
    "def get_sequence_and_structural_domains_from_pdbe(pdb_id, entity_id):\n",
    "    return requests.get(f'https://www.ebi.ac.uk/pdbe/graph-api/pdbe_pages/domains/{pdb_id}/{entity_id}/').json()\n",
    "\n",
    "data = get_best_structurs_data_from_pdbe(\"Q9NR28\")"
   ]
  }
 ],
 "metadata": {
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}