commit 6ce80c779653460b185dc5cc2574e2aa2f4ea35e
Author: Jakub Pokrywka <jakubpokrywka@gmail.com>
Date:   Sat Nov 18 10:21:48 2023 +0100

    zajecia1

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..580bac0
--- /dev/null
+++ b/README.md
@@ -0,0 +1,52 @@
+# Programowanie w pythonie
+
+Materiały do zajęć Programowanie w Pythonie prowadzone na Wydziale Matematyki i Informatyki UAM w ramach studiów podyplomowych Przetwarzanie danych - Big Data. Kurs 2023/2024
+
+
+## Informacja o przedmiocie
+
+Prowadzący: mgr inż. Jakub Pokrywka. Kontakt przez komunikator MS TEAMS lub mailowy (jakub.pokrywka@amu.edu.pl).
+
+
+## Materiały do przedmiotu i jak się uczyć
+
+Program jest wzorowany na https://github.com/tomekd/python . Spora cześć zadań się pokrywa, ale nie wszystkie.
+
+Do nauki można wykorzystać wiele tutoriali internetowych python (w wersji python3). Pomocne mogą byc w szczególności:
+* Learning Python, 5th Edition by Lutz, Mark
+* [datacamp.com](https://datacamp.com): Portal DataCamp zawiera wiele interaktywych kursów nt. poszczególnych elementów języka Python (również dla języka R.).
+* [Python3: From None to Machine Learning](https://python.astrotech.io/) 
+* [Real Python](https://realpython.com/)
+* [Dive in Python](https://diveintopython3.net/): Klasyczny kurs programowania w Pythonie.
+* [Filmy na Youtubie](https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6): seria filmów od Microsoftu nt. podstaw programowania w Pythonie.
+
+
+## Ogólny Plan zajęć
+
+- Zajęcia 1 - Wprowadzenie do python
+- Zajęcia 2 - Analiza danych
+
+- Zajęcia 3 - Analiza danych, instalacja środowiska, IDE 
+- Zajęcia 4 - Podstawy uczenia maszynowego w python
+
+- Zajęcia 5 - Podstawy uczenia maszynowego w python, obługa maszyny wirtualnej
+- Zajęcia 6 - Tworzenie REST API
+
+- Zajęcia 7 - Tworzenie REST API, testowanie aplikacji
+
+
+## Zaliczenie przedmiotu
+
+- Projekt wykonujemy w grupach (1-3) osoby
+- Kod źródłowy powinien być umieszczony na git wraz z plikiem `environment.yml` przeznaczonym do instalacji środowiska dla conda
+- Prezentacja całego projektu powinna trwać 5-15 minut
+
+Skala ocen
+- Należy wybrać zbiór danych (akceptacja grup oraz zbioru danych przez prowadzącego na pierwszych 17.11.21 lub drugich zajęciach 18.11.23), zaprezentować analizę tego zbioru danych (tabelki, wykresy, wnioski) w max 10 minut- zaliczenie na ocenę 3)
+- Należy wytrenować prosty model uczenia maszynowego (lub użyć gotowego modelu) i zaprezentować jego wyniki na zbiorze testowym. Jakość modelu nie będzie oceniana, ale powinien radzić sobie lepiej niż bardzo prosty model (klasa większościowa dla klasyfikacji lub średnia dla regresji)- zaliczenie na ocenę 4
+- Należy wystawić model z poprzedniego punktu w prostej aplikacji REST i zaprezentować jego działanie. Do aplikacji powininy być napisane 2-3 proste przypadki testowe- zaliczenie na llocenę 4.5
+- Należy udostępnić aplikację w sieci wydziałkowej 5
+
+
+W celu prezentacji projektu należy umowić sie z prowadzącym na prezentacje zdalną lub na wydziale (tylko w dni pracujące).
+Termin oddania zadań do koniec stycznia 2024. Dodatkowo można zgłosić prezentacje do końca 2023- wtedy prowadzący proponuje ocenę i zespół może albo ją przyjąć lub nie i spróbować jeszcze raz w styczniu. 
\ No newline at end of file
diff --git a/zajecia1/.ipynb_checkpoints/1_prezentacja-checkpoint.ipynb b/zajecia1/.ipynb_checkpoints/1_prezentacja-checkpoint.ipynb
new file mode 100644
index 0000000..165eb3c
--- /dev/null
+++ b/zajecia1/.ipynb_checkpoints/1_prezentacja-checkpoint.ipynb
@@ -0,0 +1,65 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Python- charakterystyka\n",
+    "\n",
+    "- język skryptowy ogólnego zastosowania\n",
+    "- wysokopoziomowy\n",
+    "- otwartoźródłowy\n",
+    "- działa na platformach Linux, MacOS, Windows\n",
+    "- obiektowy, ale wspiera też inne paradygmaty\n",
+    "- język nterpretowany (zatem nie wymaga kompilacji)\n",
+    "- Obecnie używa się python w wersji 3, która nie jest kompatybilna z wersją 2. Python 2 nie jest dalej rozwijany\n",
+    "- Główną zaletą pythona jest czytelność kodu, co wynika z założenia że kod się cześćiej czyta niż pisze. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Zastosowania python\n",
+    "- najbardziej popularny język do analizy danych obok R\n",
+    "- najbardziej popularny język do uczenia maszynowego, w szczególności sieci neuronowych. Posiada biblioteki TensorFlow (wraz z wbudowanym Keras) oraz Pytorch\n",
+    "- inne zastosowania naukowe\n",
+    "- Tworzenie stron internetowych (Django) oraz mikroserwisów (Flask, FastApi, Bottle)\n",
+    "- skrypty, automayzacja, utrzymanie serwerów"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Uruchamianie python\n",
+    "\n",
+    "- uruchamianie skryptu *.py\n",
+    "- uruchamianie python w trybie interaktywnym przez interpreterze python lub ipython\n",
+    "- uruchamianie skryptu + tryb interaktywny\n",
+    "- jupyter notebook"
+   ]
+  }
+ ],
+ "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
+}
diff --git a/zajecia1/.ipynb_checkpoints/2_podstawy-checkpoint.ipynb b/zajecia1/.ipynb_checkpoints/2_podstawy-checkpoint.ipynb
new file mode 100644
index 0000000..e78a44b
--- /dev/null
+++ b/zajecia1/.ipynb_checkpoints/2_podstawy-checkpoint.ipynb
@@ -0,0 +1,2919 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Podstawy języka Python\n",
+    "\n",
+    "&nbsp;\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The area of the triangle is 14.696938456699069\n"
+     ]
+    }
+   ],
+   "source": [
+    "sides = [5, 6, 7]\n",
+    "\n",
+    "# calculate the semi-perimeter\n",
+    "s = sum(sides) / 2\n",
+    "\n",
+    "# calculate the area\n",
+    "area = s\n",
+    "for side in sides:\n",
+    "    area = area * (s - side)\n",
+    "area = area ** 0.5\n",
+    "\n",
+    "print(f'The area of the triangle is {area}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Zmienne"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user1 = \"Alicja\"\n",
+    "user2 = \"Bartosz\"\n",
+    "user3 = \"Cecylia\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user = \"t.dwojak\"\n",
+    "mail_domain = \"amu.edu.pl\"\n",
+    "\n",
+    "email = user + '@' + mail_domain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Zmienne\n",
+    " * Nazwy zmiennych muszą być unikatowe.\n",
+    " * Wielkość liter w nazwie zmiennych ma znaczenie.\n",
+    " * Brak konieczności określenia typu."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Funkcja `print`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello Python!\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Hello Python!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello\n",
+      "Python\n",
+      "Hello Python !\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Hello') \n",
+    "print('Python')\n",
+    "print('Hello', 'Python', '!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tomasz\n",
+      "Użytkownik: tomasz\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'tomasz'\n",
+    "\n",
+    "print(user)\n",
+    "print('Użytkownik:', user)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Typy liczbowe\n",
+    "\n",
+    " * liczby całkowite: `int`\n",
+    " * liczby rzeczywiste (zmiennoprzecinkowe): `float`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "year = 2021\n",
+    "pi = 3.14159"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dziś jest 17 / 10 / 2021\n"
+     ]
+    }
+   ],
+   "source": [
+    "day = 17\n",
+    "month = 10\n",
+    "year = 2021\n",
+    "\n",
+    "print('Dziś jest', day, '/', month, '/', year)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Operacje arytmetyczne na liczbach:\n",
+    " * dodawanie `+`, np. `2 + 3`\n",
+    " * odejmowanie `-`, np. `10-9`\n",
+    " * mnożenie `*`, np. `2.0 * 3.0`\n",
+    " * dzielenie `/`, np. `3 / 4` ( == 0.75)\n",
+    " * dzielenie całkowite `//`, np. `3 / 4` (0)\n",
+    " * reszta z dzielenia `%`, np. `6 % 4` (2)\n",
+    " * potęgowanie `**`, np. `10 ** 3` (1000)\n",
+    " * nawiasy `(...)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dziś upłynęło 36840 sekund.\n"
+     ]
+    }
+   ],
+   "source": [
+    "hour = 10\n",
+    "minutes = 14\n",
+    "seconds = ((60 * 60 * hour) +  60 * minutes)\n",
+    "print(\"Dziś upłynęło\", seconds, \"sekund.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11\n"
+     ]
+    }
+   ],
+   "source": [
+    "print( 1 + (20 // 3) + (4 * -5) % 6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje na zmiennej\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x = 5\n",
+    "\n",
+    "x = x + 5\n",
+    "\n",
+    "x += 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operatory\n",
+    "\n",
+    "Na przykład:\n",
+    " * `+=`\n",
+    " * `-=`\n",
+    " * `/=`\n",
+    " * `*=`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Konwersja typów"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-3\n",
+      "3.0\n",
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "pi_int = int(-3.14)\n",
+    "print(pi_int)\n",
+    "\n",
+    "trzy = float(3)\n",
+    "print(trzy)\n",
+    "print(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6.28\n",
+      "7.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = '3.14'\n",
+    "print(float(x) * 2)\n",
+    "\n",
+    "print(int('42') / 6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Wartości logiczne\n",
+    "\n",
+    "W Pythonie są dwie wartości logiczne:\n",
+    " * prawda (`True`),\n",
+    " * fałsz (`False`).\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = False\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "* Wszystkie liczby różne od 0 mają wartość logiczną `True`.\n",
+    "* Funkcja `bool` pozwala na konwersję do zmiennej logicznej.\n",
+    "* Do negacji służy słowo kluczowe `not`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wartość logiczna sumy: True\n",
+      "Wartość logiczna zera to:  False False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "suma = 1 + 2\n",
+    "\n",
+    "print('Wartość logiczna sumy:', bool(suma))\n",
+    "\n",
+    "print('Wartość logiczna zera to: ', bool(0), bool(0.0))\n",
+    "\n",
+    "print(not False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operatory porównania\n",
+    " * równość: `==`\n",
+    " * różne: `!=`\n",
+    " * większy: `>`\n",
+    " * większy lub równy: `>=`\n",
+    " * mniejszy: `<`\n",
+    " * mniejszy lub równy `<=`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'bob'\n",
+    "\n",
+    "print(user == 'bob')\n",
+    "\n",
+    "print(3 < 7)\n",
+    "\n",
+    "print(0 != 0.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Do łączenia warunków logicznych służą dwa słowa kluczowe:\n",
+    " * `and`: koniunkcja,\n",
+    " * `or`: alternatywa."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(True and True)\n",
+    "print(True and False)\n",
+    "print(True or False)\n",
+    "print(False or False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W Pythonie istnieje jeszcze jeden typ wartości `None`, który oznacza brak wartości lub wartość pustą. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wartość zmiennej: None\n",
+      "Wartość logiczna zmiennej: False\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = None\n",
+    "\n",
+    "print('Wartość zmiennej:', user)\n",
+    "print('Wartość logiczna zmiennej:', bool(user))\n",
+    "print(user == False)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na pierwsze zadanie (1a i 1b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Komentarze\n",
+    " * Komentarze nie są interpretowane.\n",
+    " * Komentarze w Pythonie zaczynają się od znaku '#'\n",
+    " * Istnieją komentarze wielolinijkowe tagowane potrójnym \", czyli \"\"\" \"\"\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bardzo ważna wiadomość\n",
+      "Mamy piękną jesień.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Bardzo ważna wiadomość\") # A to jest komentarz\n",
+    "\"\"\"\n",
+    "Komentarz\n",
+    "wielo-\n",
+    "linijkowy\n",
+    "\"\"\"\n",
+    "# print(\"Nie chcę być wydrukowanym\")\n",
+    "print(\"Mamy piękną jesień.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Ciągi znaków (łańcuchy znakowe lub stringi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "  * Możemy zdefiniować je na 3 sposoby: `''`, `\"\"` lub `str`.\n",
+    "  * Python preferuje pojedynczy cudzysłów.\n",
+    "  * Domyślne kodowanie to UTF-8."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user0 = 'John'\n",
+    "user1 = \"Alice\"\n",
+    "\n",
+    "nun_users = str(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "It's fine.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sent = \"It's fine.\"\n",
+    "\n",
+    "sent = 'It\\'s fine.'\n",
+    "\n",
+    "print(sent)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rok: 2021\n",
+      "False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "var = str(2021)\n",
+    "\n",
+    "print('rok:', var)\n",
+    "print(var == 2021)\n",
+    "print(var == '2021')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Pusty ciąg znaków\n",
+    "x = ''"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje na stringach\n",
+    " * łączenie: `+`\n",
+    " * powtórzenie: `*`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t.dwojak@amu.edu.pl\n"
+     ]
+    }
+   ],
+   "source": [
+    "username = 't.dwojak'\n",
+    "domain = 'amu.edu.pl'\n",
+    "email = username + '@' + domain\n",
+    "print(email)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "NOOOOOOOO!\n"
+     ]
+    }
+   ],
+   "source": [
+    "big_no = 'N' + 'O' * 8 + '!'\n",
+    "print(big_no)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dziś jest 2021/10/17\n"
+     ]
+    }
+   ],
+   "source": [
+    "date = str(2021) + '/' + str(10) + '/' + str(17)\n",
+    "print('Dziś jest', date)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje na stringach, cd.\n",
+    " * długość łańcucha znakowego: `len`: np. `len('Ala') == 3`,\n",
+    " * zamiana na małe litery `lower` lub na wielkie: `upper`,\n",
+    " * zamiana liter: `replace`,\n",
+    " * usuwanie białych znaków: `strip`,\n",
+    " * sprawdzenie czy string rozpoczyna sie danych prefiksem: `startswith`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Słowo mickiewicz ma 10 liter.\n",
+      "python\n",
+      "mickiewicz\n",
+      "2021\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'mickiewicz'\n",
+    "print('Słowo', user, 'ma', len(user), 'liter.')\n",
+    "\n",
+    "print('Python'.lower())\n",
+    "\n",
+    "print(user.replace('T', 'R'))\n",
+    "\n",
+    "print('      2021     '.strip())\n",
+    "\n",
+    "print(user.startswith('mic'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Słowo tomasz ma 6 liter.\n",
+      "Słowo tomasz ma 6 liter.\n",
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'tomasz'\n",
+    "print('Słowo', user, 'ma', len(user), 'liter.')\n",
+    "\n",
+    "print(f'Słowo {user} ma {len(user)} liter.')\n",
+    "\n",
+    "\n",
+    "print(len(str(123)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (1c)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Listy (`list`)\n",
+    " * Typ danych, który pozwala przechowywać wiele wartości.\n",
+    " * Dostęp do poszczególnych elementów jest przez indeks elementu.\n",
+    " * Indeksowanie zaczyna się od 0.\n",
+    " * Funkcja `list` zamienia obiekt na listę."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x = [] # albo równoważnie\n",
+    "y = list()\n",
+    "oceny = [5, 4, 3, 5, 5]\n",
+    "misc = [3.14, \"pi\", [\"pi\"], 3]\n",
+    "\n",
+    "list_0_9 = list(range(10))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Liczba elementów: 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [6, 7, 9, 11]\n",
+    "print('Liczba elementów:', len(numbers))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [6, 7, 9, 11]\n",
+    "\n",
+    "print(numbers[1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Dodawanie i usuwanie elementów z listy\n",
+    "\n",
+    "Istnieją dwie metody:\n",
+    " * `append(x)`: dodaje x na koniec listy\n",
+    " * `extend(x)`: rozszerza listę o każdy element z x "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['duck-duck-go', 'yahoo']\n"
+     ]
+    }
+   ],
+   "source": [
+    "engines = []\n",
+    "\n",
+    "engines.append('duck-duck-go')\n",
+    "engines.append(\"yahoo\")\n",
+    "print(engines)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['duck-duck-go', 'yahoo', 'google', 'bing']\n"
+     ]
+    }
+   ],
+   "source": [
+    "engines = ['duck-duck-go', 'yahoo']\n",
+    "searches = [\"google\", 'bing']\n",
+    "engines.extend(searches)\n",
+    "print(engines)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['duck-duck-go', 'yahoo', 'google', 'bing']\n",
+      "['duck-duck-go', 'yahoo']\n"
+     ]
+    }
+   ],
+   "source": [
+    "engines = ['duck-duck-go', 'yahoo']\n",
+    "searches = [\"google\", 'bing']\n",
+    "\n",
+    "print(engines + searches)\n",
+    "print(engines)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1, 3, 2, 3, 1, 2, 4]\n",
+      "[1, 3, 3, 1, 2, 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "liczby = [1, 2, 3, 2, 3, 1, 2, 4]\n",
+    "liczby.pop(1) # Domyślnie usuwa ostatni element z listy\n",
+    "print(liczby)\n",
+    "liczby.remove(2)\n",
+    "print(liczby)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Inne przydatne metody:\n",
+    " * `sort()`: sortuje listę rosnąco\n",
+    " * `count(x)`: zlicza wystąpienia x w  liście\n",
+    " * `index(x)`: zwraca indeks pierwszego wystąpienia x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "7\n",
+      "[1, 1, 2, 2, 2, 3, 3, 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "liczby = [1,2,3,2,3,1,2,4]\n",
+    "print(liczby.count(1))\n",
+    "print(liczby.index(4))\n",
+    "liczby.sort()\n",
+    "print(liczby)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Indeksowanie"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pierwszy element: 1\n",
+      "ostatni element: 4\n",
+      "5 pierwszych: [1, 3, 2, 3, 1]\n",
+      "5 ostatnich [2, 3, 1, 2, 4]\n",
+      "od drugiego, do piątego [3, 2, 3, 1]\n",
+      "parzyste: [3, 3, 2]\n",
+      "od tyłu [4, 2, 1, 3, 2, 3, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "oceny = [1, 3, 2, 3, 1, 2, 4]\n",
+    "print('pierwszy element:', oceny[0])\n",
+    "print('ostatni element:', oceny[-1])\n",
+    "print('5 pierwszych:', oceny[:5])\n",
+    "print('5 ostatnich', oceny[-5:])\n",
+    "print('od drugiego, do piątego', oceny[1:5])\n",
+    "print('parzyste:', oceny[1:6:2])\n",
+    "print('od tyłu', oceny[::-1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Funkcje wbudowane\n",
+    " * `len` - zwraca liczbę elementów listy.\n",
+    " * `min` - zwraca wartość najmniejszgo elementu.\n",
+    " * `max` - zwraca wartość największego elementu.\n",
+    " * `sum` - zwraca sumę elementów.\n",
+    " * `all` - zwraca `True`, gdy wszystkie elementy mają wartość `True`.\n",
+    " * `any` - Zwraca `True`, gdy przynajmniej jeden element ma wartość `True`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Liczba elementów: 6\n",
+      "Najmniejszy element: 0\n",
+      "Największy element: 32\n",
+      "Suma elementów: 74\n",
+      "False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [4, 8, 12, 18, 0,  32]\n",
+    "\n",
+    "print('Liczba elementów:', len(numbers))\n",
+    "print('Najmniejszy element:', min(numbers))\n",
+    "print('Największy element:', max(numbers))\n",
+    "print('Suma elementów:', sum(numbers))\n",
+    "\n",
+    "print(all(numbers))\n",
+    "print(any(numbers))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Krotki (`tuple`)\n",
+    "Podobnym typem do listy jest krotka (`tuple`):\n",
+    " * definiuje się ją `()` lub `tuple()`,\n",
+    " * nie można zmieniać krotki: nie można dodawać ani usuwać elementów,\n",
+    " * nie można również zmieniać elementów*,\n",
+    " * Indeksowanie identyczne jak w listach."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "numbers = (4, 5, 7)\n",
+    "\n",
+    "numbers[2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "([0, 1], [1, 2], [3, 4, 5])\n"
+     ]
+    }
+   ],
+   "source": [
+    "users = ([0], [1, 2], [3, 4, 5])\n",
+    "\n",
+    "users[0].append(1)\n",
+    "\n",
+    "print(users)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (2a, 2b, 2c)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Słowniki (`dict`)\n",
+    "Pewnego rodzaju uogólnieniem listy jest słownik (`dict`), który przechowuje dane jako `klucz`: `wartość`.\n",
+    " * Słowniki pozwala na dodawanie, usuwanie i zmianę elementów.\n",
+    " * Definiujemy jako `{}` lub `dict()`.\n",
+    " * Klucze słownika muszą być niezmienialne (haszowalne)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "store = {}\n",
+    "store = dict()\n",
+    "s_oceny = {\n",
+    "    \"Justyna\": [5,5,5],\n",
+    "    \"Bartek\": [3,4,5],\n",
+    "    \"Ola\": [3,3,3]}\n",
+    "s_oceny = dict([(\"Justyna\", [5,5,5]), (\"Bartek\", [3,4,5]), (\"Ola\", [3,3,3])])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3, 4, 5]\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "user = 'Bartek'\n",
+    "print(s_oceny[user])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3], 'Jan': [4, 4, 5]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "s_oceny['Jan'] = [4, 4, 5]\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3, 1, 4]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "s_oceny['Ola'].extend([1,4])\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "del s_oceny[\"Justyna\"]\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje\n",
+    " * Funkcja `len` zwraca liczbę elementów w słowniku.\n",
+    " * Domyślnie operacje funkcji wykonywane są na kluczach.\n",
+    " * metoda `keys()` zwraca klucze słownika, `values()` -- wartości, a `items()` -- pary (klucz, wartość). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys([1, 3, 5, 11])\n",
+      "dict_values([1, 2, 2, 3])\n",
+      "dict_items([(1, 1), (3, 2), (5, 2), (11, 3)])\n"
+     ]
+    }
+   ],
+   "source": [
+    "binary_ones = {1: 1, 3: 2, 5: 2, 11: 3}\n",
+    "max(binary_ones)\n",
+    "\n",
+    "print(binary_ones.keys())\n",
+    "print(binary_ones.values())\n",
+    "print(binary_ones.items())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,4,3]}\n",
+    "\n",
+    "print(s_oceny[\"Ola\"][1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "28\n"
+     ]
+    }
+   ],
+   "source": [
+    "users = {'ali99': {'name': 'Alice', 'age': 28}, 'bob90': {'name': 'Bob', 'age': 19}}\n",
+    "\n",
+    "print(users['ali99']['age'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (3)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Instrukcja warunkowa (`if ... elif ... else`)\n",
+    " * Pozwala na wykonanie (wciętego) fragmentu kodu w zależności od czy podany warunek jest spełniony:\n",
+    "  ```python\n",
+    "  if <warunek>:\n",
+    "    instrukcja 1\n",
+    "    ...\n",
+    " ```\n",
+    " * `elif` pozwala na sprawdzenie kolejnego warunku.\n",
+    " * `else` zostanie wykonany, gdy żaden warunek nie został spełniony.\n",
+    " * Elementy `elif` i `else` nie są obowiązkowe.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "score_theory = 40\n",
+    "score_practical = 45\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    print('------')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Jedną ważną rzeczą jest to, że kod, który następuje po instrukcji `if` jest wcięty. Dzięki temu interpreter Pythona jest w stanie określić, które instrucje wchodzą w skład bloku warunkowego, a które nie."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Blok `else` jest opcjonalny i jest wykonywany, gdy warunek zawarty w instrukcji `if` nie jest spełniony. \n",
+    "\n",
+    "Na poniższym przykładnie mamy własnie taki przypadek. Warunek w `if`ie: `score_theory + score_practical > 100` nie jest spełniony, stąd wykonają się instrukcje z bloku `else`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Nie zdobyłeś wystarczającej liczby punktów.\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "score_theory = 40\n",
+    "score_practical = 45\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    print('------')\n",
+    "else:\n",
+    "    print(\"Nie zdobyłeś wystarczającej liczby punktów.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Instrukcja warunkowa `if` pozwala na sprawdzenie wielu warunków -- służy do tego instrukcja `elif` (else if). Warunki są sprawdzane po kolei (od góry): jeżeli warunek zawarty po `if` nie jest spełniony, wtedy sprawdzany jest pierszy warunek z `elif`. Gdy żaden warunek nie jest spełniony, wtedy wykona się kod zawarty w bloku `else`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Będziesz mieć dodatkowy egzamin.\n"
+     ]
+    }
+   ],
+   "source": [
+    "score_theory = 40\n",
+    "score_practical = 45\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    print('------')\n",
+    "elif score_theory + score_practical > 80:\n",
+    "    print(\"Będziesz mieć dodatkowy egzamin.\")\n",
+    "else:\n",
+    "    print(\"Nie zdobyłeś wystarczającej liczby punktów.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Nic nie stoi na przeszkodzie, żeby zagnieżdżać instrukcje warunkowe. W poniższym przykładzie widzimy, że druga instrukcja warunkowa jest zawarta w bloku po pierwszym `if`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Zdobyłeś wystarczającą liczbę punktów.\n",
+      "Wolisz teorię od praktyki\n"
+     ]
+    }
+   ],
+   "source": [
+    "score_theory = 55\n",
+    "score_practical = 50\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    if score_theory > score_practical:\n",
+    "        print('Wolisz teorię od praktyki')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Sprawdzenie obecności w kolekcji (`in`)\n",
+    " * Słowo kluczowe `in` sprawdza czy dany element znajduje sie w kolekcji (np. lista, słownik).\n",
+    " * Jego negacja to `not in`.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Python zawiera bardzo przydatny warunek `in`, który sprawdza czy dany element jest zawarty w danej kolecji, np. w liście lub w słowniku.\n",
+    "\n",
+    "W poniższym przykładzie sprawdzamy, czy liczba `67` jest zawarta w liście."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "67 jest na liście.\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [67, 101, 303]\n",
+    "\n",
+    "if 67 in numbers:\n",
+    "    print('67 jest na liście.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W przypadku słowników (`dict`) sprawdzane jest czy istnieje w słowniku zadany klucz."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Jabłko jest składnikiem.\n"
+     ]
+    }
+   ],
+   "source": [
+    "ingredients = {'apple': 4, 'lemon': 1, 'cherry': 14}\n",
+    "\n",
+    "if 'apple' in ingredients:\n",
+    "    print('Jabłko jest składnikiem.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Możemy wykorzystać warunek `in` do sprawdzenie, czy dany tekst jest podciągiem w drugim."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Yes!\n"
+     ]
+    }
+   ],
+   "source": [
+    "my_programming_lang = \"Python\"\n",
+    "\n",
+    "if \"Pyt\" in my_programming_lang:\n",
+    "    print('Yes!')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Żeby sprawdzić czy dany element __nie występuje__ możemy wykorzystać instrukcję `not in`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Omiń alejkę ze słodyczami.\n"
+     ]
+    }
+   ],
+   "source": [
+    "shopping_list = ['apples', 'bread', 'carrots']\n",
+    "\n",
+    "if 'cookies' not in shopping_list:\n",
+    "    print('Omiń alejkę ze słodyczami.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Obiekty o wartości logicznej `False`\n",
+    " * `0`\n",
+    " * `0.0`\n",
+    " * `[]`\n",
+    " * `()`\n",
+    " * `{}`\n",
+    " * `None`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Bardzo często można spotkać się, gdy chcemy sprawdzić np. czy data lista jest pusta."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "numbers = []\n",
+    "\n",
+    "if numbers:\n",
+    "    print('średnia liczb to:', sum(numbers) / len(numbers))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (4a, 4b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Pętla typu ```for```\n",
+    " * W Pythonie pętla *for* działa jak pętla *for each* w innych językach;\n",
+    " ```python\n",
+    " for zmienna in kolekcja:\n",
+    "     instukcja 1\n",
+    "     instrukcja 2\n",
+    "     ...\n",
+    "```\n",
+    " * Pętla pozwala na zapętlenie kodu, który znajduje w wciętym bloku.\n",
+    " * Konstrukcja pętli jest następująca: po słowie `for` musimy podać nazwę zmiennej, która po kolei będzie przyjmować wartości z kolekcji, np. z listy. Pętla wykona się tyle razy, ile jest elementów w kolekcji.\n",
+    " * Funkcja `range(n)` zwraca kolekcję liczb od `0` do `n-1`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "To na co warto zwrócić uwagę to wcięcie. Kod, który ma zostać wykonany w pętli musi być wcięty."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "element apples\n",
+      "element cherries\n",
+      "element pineapple\n"
+     ]
+    }
+   ],
+   "source": [
+    "ingredients = ['apples', 'cherries', 'pineapple']\n",
+    "\n",
+    "for ingredient in ingredients:\n",
+    "    print('element', ingredient)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Funkcja `range(n)` zwraca obiekt, który możemy przekonwertowąć na listę elementów od 0 do `n-1`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 1, 2, 3, 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(list(range(5)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Bardzo często można spotkać poniżsżą kombinację funkcji `range` i `len` w kontekście pętli:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "apples\n",
+      "cherries\n",
+      "pineapple\n"
+     ]
+    }
+   ],
+   "source": [
+    "ingredients = ['apples', 'cherries', 'pineapple']\n",
+    "\n",
+    "for i in range(len(ingredients)):\n",
+    "    print(ingredients[i])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W przypadku połączenia słownika i pętli, do zmiennej przypisywane są kolejne klucze ze słownika (przykład poniżej):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "apple\n",
+      "lemon\n",
+      "cherry\n"
+     ]
+    }
+   ],
+   "source": [
+    "shopping_list = {'apple': 4, 'lemon': 1, 'cherry': 14}\n",
+    "for item in shopping_list:\n",
+    "    print(item)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Jak wcześniej wspomniałem, metoda `items()` zwraca listę krotek: `(klucz, wartość)` i możemy wykorzystać to w pętli `for`. W tym przypadku musimy podać dwie zmienne:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Buy 4 apples\n",
+      "Buy 1 lemon\n",
+      "Buy 14 cherries\n"
+     ]
+    }
+   ],
+   "source": [
+    "shopping_list = {'apples': 4, 'lemon': 1, 'cherries': 14}\n",
+    "for item, number in shopping_list.items():\n",
+    "    print('Buy', number, item)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Możemy też iterować po stringu -- znak po znaku:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "P\n",
+      "y\n",
+      "t\n",
+      "h\n",
+      "o\n",
+      "n\n"
+     ]
+    }
+   ],
+   "source": [
+    "for char in 'Python':\n",
+    "    print(char)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Ćwiczenie: czy rozumiesz kod, który był na początku zajęć?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The area of the triangle is 14.696938456699069\n"
+     ]
+    }
+   ],
+   "source": [
+    "sides = [5, 6, 7]\n",
+    "\n",
+    "# calculate the semi-perimeter\n",
+    "s = sum(sides) / 2\n",
+    "\n",
+    "# calculate the area\n",
+    "area = s\n",
+    "for side in sides:\n",
+    "    area = area * (s - side)\n",
+    "area = area ** 0.5\n",
+    "\n",
+    "print(f'The area of the triangle is {area}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Zagnieżdżając dwie pętle musimy pamiętać o dodatkowym wcięciu (tak jak w przykładzie poniżej)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "2\n",
+      "4\n",
+      "3\n",
+      "6\n",
+      "9\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(3):\n",
+    "    for j in range(i+1):\n",
+    "        print((i + 1) * (j + 1))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (5a, 5b, 5c i 5d)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Funkcje\n",
+    " * Pozwalają na uniknięcie pisania tego samego kodu za każdym razem.\n",
+    " * Pozwalają na wielokrotne wykorzystanie tego samego fragmentu kodu.\n",
+    " * Zwiększają czytelność kodu.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Definicja funkcji wygląda następująco:\n",
+    " * najpierw piszemy słowo kłuczowe `def`, następnie nazwę funkcji, później w nawiasach okrągłych listę argumentów i kończymy dwukropkiem.\n",
+    " * następnie wcięty blok to będzie kod funkcji."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello!\n"
+     ]
+    }
+   ],
+   "source": [
+    "def hello():\n",
+    "    print('Hello!')\n",
+    "\n",
+    "hello()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W powyższym przykładzie zdefiniowaliśmy funkcje `hello`, która nie przyjmuje żadnych argumentów. Wywołanie tej funkcji nie różni się od wywołań innych funkcji."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Słowo kluczowe `return` pozwala na zwrócenie wartości przez funkcję. Poniższa funkcja `get_five` zwraca liczbę pięć."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_five():\n",
+    "    return 5\n",
+    "x = get_five()\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Argumenty funkcji umieszczamy w nawiasach:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "```python\n",
+    "def nazwa_funkcji(arg_1, arg_2, arg_3):\n",
+    "    instrukcja 1\n",
+    "    instrukcja 2\n",
+    "    return jakaś wartość\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Przykład: poniższa funkcja `get_bigger` przyjmuje dwa argumenty: `a` i `b`, które rozdzielamy przecinkiem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "512\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_bigger(a, b):\n",
+    "    if a >= b:\n",
+    "        return a\n",
+    "    return b\n",
+    "print(get_bigger(56, 512))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "def srednia(lista):\n",
+    "    s = 0\n",
+    "    for item in lista:\n",
+    "        s += item\n",
+    "    return s / len(lista) \n",
+    "\n",
+    "print(srednia([7,8,9]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def count(lista, item):\n",
+    "    l = 0\n",
+    "    for i in lista:\n",
+    "        if i == item:\n",
+    "            l += 1\n",
+    "    return l"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Podczas wywoływania funkcji możemy dopowiedzieć, która argument jaką przyjmuje wartość."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "count([5,5,5,4], 5)\n",
+    "count(lista=[5,5,5,4], item=5)\n",
+    "count(item=5, lista=[5,5,5,4])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (7a i 7b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Korzystanie z bibliotek"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Python posiada bogatą kolekcję bibliotek wbudowanych, tzn. które są dostarczone wraz z interpreterem.\n",
+    "\n",
+    "Żeby móc wykorzystać daną bibliotekę, to musimy ją zaimportować. Możemy to zrobić na dwa sposoby:\n",
+    " * `import <nazwa_biblioteki>`. Dostęp do elementów jest poprzez `<nazwa_biblioteki>.nazwa_funkcji`.\n",
+    " * `from <nazwa_biblioteki> import <nazwa funkcji>`: pozwala na dołączenie elementów biblioteki, tak jakby były częścią naszego skryptu.\n",
+    " \n",
+    "Przykłady:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "posix\n",
+      "Nazwa uzytkownika: kuba\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "print(os.name)\n",
+    "\n",
+    "from os import getenv\n",
+    "print('Nazwa uzytkownika: {}'.format(getenv(\"USER\")))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "1. Importujemy bibliotekę `os`. Dostęp do stałej jest \"przez kropkę\".\n",
+    "2. Z biblioreki `os` importujemy funkcję `getenv` (zwraca wartości zmiennych systemowych)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Wystarczy, że zaimportujemy raz daną bibliotekę:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-1.0"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import math\n",
+    "math.cos(math.pi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Jeżeli nazwa biblioteki jest za długa, to możemy użyć aliasu: `import <nazwa_biblioteki> as <alias>`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "    October 2021\n",
+      "Mo Tu We Th Fr Sa Su\n",
+      "             1  2  3\n",
+      " 4  5  6  7  8  9 10\n",
+      "11 12 13 14 15 16 17\n",
+      "18 19 20 21 22 23 24\n",
+      "25 26 27 28 29 30 31\n"
+     ]
+    }
+   ],
+   "source": [
+    "import calendar as cal\n",
+    "cal.TextCalendar().prmonth(2021, 10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Ważniejsze biblioteki wbudowane:\n",
+    " * `os`, `sys`: obsługa rzeczy dt. systemu i środowiska\n",
+    " * `datetime`: wszystko co jest związane z czasem\n",
+    " * `collections`: zawiera `Counter` i `defaultdict`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (9a i 9b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Obsługa plików"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Beautiful is better than ugly.\n",
+      "Explicit is better than implicit.\n",
+      "Simple is better than complex.\n"
+     ]
+    }
+   ],
+   "source": [
+    "zen_file = open('./zen_of_python.txt')\n",
+    "zen_text = zen_file.read()\n",
+    "print(zen_text[:95])\n",
+    "\n",
+    "zen_file.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Beautiful is better than ugly.\n",
+      "Explicit is better than implicit.\n",
+      "Simple is better than complex.\n"
+     ]
+    }
+   ],
+   "source": [
+    "zen_file = open('./zen_of_python.txt')\n",
+    "\n",
+    "zen_lines = list(zen_file)\n",
+    "\n",
+    "for line in zen_lines[:3]:\n",
+    "    print(line.strip())\n",
+    "\n",
+    "\n",
+    "zen_file.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Beautiful is better than ugly.\n",
+      "Explicit is better than implicit.\n",
+      "Simple is better than complex.\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open('./zen_of_python.txt') as zen_file:\n",
+    "    print(zen_file.read()[:95])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "tree_per_sqkm = {\n",
+    "    \"Brazil\": 39542,\n",
+    "    \"Bulgaria\": 24987,\n",
+    "}\n",
+    "\n",
+    "with open('./zalesienie.txt', mode='w') as plik:\n",
+    "    for country, num_trees in tree_per_sqkm.items():\n",
+    "        plik.write(country + ',' + str(num_trees) + '\\n')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Podstawy Obiektowości\n",
+    "\n",
+    " - W Pythonie każda wartość jest obiektem, tzn. może zostać przypisana do zmiennej lub zostać\n",
+    "przekazane do funkcji.\n",
+    " - Każda wartość może mieć metody lub atrybuty."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11\n",
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datetime import date\n",
+    "\n",
+    "today = date(2022, 11, 5)\n",
+    "\n",
+    "print(today.month) # atrybut\n",
+    "print(today.weekday()) # metoda"
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Slideshow",
+  "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": 1
+}
diff --git a/zajecia1/1_prezentacja.ipynb b/zajecia1/1_prezentacja.ipynb
new file mode 100644
index 0000000..165eb3c
--- /dev/null
+++ b/zajecia1/1_prezentacja.ipynb
@@ -0,0 +1,65 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Python- charakterystyka\n",
+    "\n",
+    "- język skryptowy ogólnego zastosowania\n",
+    "- wysokopoziomowy\n",
+    "- otwartoźródłowy\n",
+    "- działa na platformach Linux, MacOS, Windows\n",
+    "- obiektowy, ale wspiera też inne paradygmaty\n",
+    "- język nterpretowany (zatem nie wymaga kompilacji)\n",
+    "- Obecnie używa się python w wersji 3, która nie jest kompatybilna z wersją 2. Python 2 nie jest dalej rozwijany\n",
+    "- Główną zaletą pythona jest czytelność kodu, co wynika z założenia że kod się cześćiej czyta niż pisze. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Zastosowania python\n",
+    "- najbardziej popularny język do analizy danych obok R\n",
+    "- najbardziej popularny język do uczenia maszynowego, w szczególności sieci neuronowych. Posiada biblioteki TensorFlow (wraz z wbudowanym Keras) oraz Pytorch\n",
+    "- inne zastosowania naukowe\n",
+    "- Tworzenie stron internetowych (Django) oraz mikroserwisów (Flask, FastApi, Bottle)\n",
+    "- skrypty, automayzacja, utrzymanie serwerów"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Uruchamianie python\n",
+    "\n",
+    "- uruchamianie skryptu *.py\n",
+    "- uruchamianie python w trybie interaktywnym przez interpreterze python lub ipython\n",
+    "- uruchamianie skryptu + tryb interaktywny\n",
+    "- jupyter notebook"
+   ]
+  }
+ ],
+ "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
+}
diff --git a/zajecia1/2_podstawy.ipynb b/zajecia1/2_podstawy.ipynb
new file mode 100644
index 0000000..e78a44b
--- /dev/null
+++ b/zajecia1/2_podstawy.ipynb
@@ -0,0 +1,2919 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Podstawy języka Python\n",
+    "\n",
+    "&nbsp;\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The area of the triangle is 14.696938456699069\n"
+     ]
+    }
+   ],
+   "source": [
+    "sides = [5, 6, 7]\n",
+    "\n",
+    "# calculate the semi-perimeter\n",
+    "s = sum(sides) / 2\n",
+    "\n",
+    "# calculate the area\n",
+    "area = s\n",
+    "for side in sides:\n",
+    "    area = area * (s - side)\n",
+    "area = area ** 0.5\n",
+    "\n",
+    "print(f'The area of the triangle is {area}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Zmienne"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user1 = \"Alicja\"\n",
+    "user2 = \"Bartosz\"\n",
+    "user3 = \"Cecylia\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user = \"t.dwojak\"\n",
+    "mail_domain = \"amu.edu.pl\"\n",
+    "\n",
+    "email = user + '@' + mail_domain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Zmienne\n",
+    " * Nazwy zmiennych muszą być unikatowe.\n",
+    " * Wielkość liter w nazwie zmiennych ma znaczenie.\n",
+    " * Brak konieczności określenia typu."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Funkcja `print`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello Python!\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Hello Python!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello\n",
+      "Python\n",
+      "Hello Python !\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Hello') \n",
+    "print('Python')\n",
+    "print('Hello', 'Python', '!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tomasz\n",
+      "Użytkownik: tomasz\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'tomasz'\n",
+    "\n",
+    "print(user)\n",
+    "print('Użytkownik:', user)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Typy liczbowe\n",
+    "\n",
+    " * liczby całkowite: `int`\n",
+    " * liczby rzeczywiste (zmiennoprzecinkowe): `float`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "year = 2021\n",
+    "pi = 3.14159"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dziś jest 17 / 10 / 2021\n"
+     ]
+    }
+   ],
+   "source": [
+    "day = 17\n",
+    "month = 10\n",
+    "year = 2021\n",
+    "\n",
+    "print('Dziś jest', day, '/', month, '/', year)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Operacje arytmetyczne na liczbach:\n",
+    " * dodawanie `+`, np. `2 + 3`\n",
+    " * odejmowanie `-`, np. `10-9`\n",
+    " * mnożenie `*`, np. `2.0 * 3.0`\n",
+    " * dzielenie `/`, np. `3 / 4` ( == 0.75)\n",
+    " * dzielenie całkowite `//`, np. `3 / 4` (0)\n",
+    " * reszta z dzielenia `%`, np. `6 % 4` (2)\n",
+    " * potęgowanie `**`, np. `10 ** 3` (1000)\n",
+    " * nawiasy `(...)`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dziś upłynęło 36840 sekund.\n"
+     ]
+    }
+   ],
+   "source": [
+    "hour = 10\n",
+    "minutes = 14\n",
+    "seconds = ((60 * 60 * hour) +  60 * minutes)\n",
+    "print(\"Dziś upłynęło\", seconds, \"sekund.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11\n"
+     ]
+    }
+   ],
+   "source": [
+    "print( 1 + (20 // 3) + (4 * -5) % 6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje na zmiennej\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x = 5\n",
+    "\n",
+    "x = x + 5\n",
+    "\n",
+    "x += 5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operatory\n",
+    "\n",
+    "Na przykład:\n",
+    " * `+=`\n",
+    " * `-=`\n",
+    " * `/=`\n",
+    " * `*=`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Konwersja typów"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-3\n",
+      "3.0\n",
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "pi_int = int(-3.14)\n",
+    "print(pi_int)\n",
+    "\n",
+    "trzy = float(3)\n",
+    "print(trzy)\n",
+    "print(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6.28\n",
+      "7.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = '3.14'\n",
+    "print(float(x) * 2)\n",
+    "\n",
+    "print(int('42') / 6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Wartości logiczne\n",
+    "\n",
+    "W Pythonie są dwie wartości logiczne:\n",
+    " * prawda (`True`),\n",
+    " * fałsz (`False`).\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = False\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "* Wszystkie liczby różne od 0 mają wartość logiczną `True`.\n",
+    "* Funkcja `bool` pozwala na konwersję do zmiennej logicznej.\n",
+    "* Do negacji służy słowo kluczowe `not`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wartość logiczna sumy: True\n",
+      "Wartość logiczna zera to:  False False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "suma = 1 + 2\n",
+    "\n",
+    "print('Wartość logiczna sumy:', bool(suma))\n",
+    "\n",
+    "print('Wartość logiczna zera to: ', bool(0), bool(0.0))\n",
+    "\n",
+    "print(not False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operatory porównania\n",
+    " * równość: `==`\n",
+    " * różne: `!=`\n",
+    " * większy: `>`\n",
+    " * większy lub równy: `>=`\n",
+    " * mniejszy: `<`\n",
+    " * mniejszy lub równy `<=`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'bob'\n",
+    "\n",
+    "print(user == 'bob')\n",
+    "\n",
+    "print(3 < 7)\n",
+    "\n",
+    "print(0 != 0.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Do łączenia warunków logicznych służą dwa słowa kluczowe:\n",
+    " * `and`: koniunkcja,\n",
+    " * `or`: alternatywa."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(True and True)\n",
+    "print(True and False)\n",
+    "print(True or False)\n",
+    "print(False or False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W Pythonie istnieje jeszcze jeden typ wartości `None`, który oznacza brak wartości lub wartość pustą. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wartość zmiennej: None\n",
+      "Wartość logiczna zmiennej: False\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = None\n",
+    "\n",
+    "print('Wartość zmiennej:', user)\n",
+    "print('Wartość logiczna zmiennej:', bool(user))\n",
+    "print(user == False)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na pierwsze zadanie (1a i 1b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Komentarze\n",
+    " * Komentarze nie są interpretowane.\n",
+    " * Komentarze w Pythonie zaczynają się od znaku '#'\n",
+    " * Istnieją komentarze wielolinijkowe tagowane potrójnym \", czyli \"\"\" \"\"\"\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bardzo ważna wiadomość\n",
+      "Mamy piękną jesień.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Bardzo ważna wiadomość\") # A to jest komentarz\n",
+    "\"\"\"\n",
+    "Komentarz\n",
+    "wielo-\n",
+    "linijkowy\n",
+    "\"\"\"\n",
+    "# print(\"Nie chcę być wydrukowanym\")\n",
+    "print(\"Mamy piękną jesień.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Ciągi znaków (łańcuchy znakowe lub stringi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "  * Możemy zdefiniować je na 3 sposoby: `''`, `\"\"` lub `str`.\n",
+    "  * Python preferuje pojedynczy cudzysłów.\n",
+    "  * Domyślne kodowanie to UTF-8."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user0 = 'John'\n",
+    "user1 = \"Alice\"\n",
+    "\n",
+    "nun_users = str(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "It's fine.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sent = \"It's fine.\"\n",
+    "\n",
+    "sent = 'It\\'s fine.'\n",
+    "\n",
+    "print(sent)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rok: 2021\n",
+      "False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "var = str(2021)\n",
+    "\n",
+    "print('rok:', var)\n",
+    "print(var == 2021)\n",
+    "print(var == '2021')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Pusty ciąg znaków\n",
+    "x = ''"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje na stringach\n",
+    " * łączenie: `+`\n",
+    " * powtórzenie: `*`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "t.dwojak@amu.edu.pl\n"
+     ]
+    }
+   ],
+   "source": [
+    "username = 't.dwojak'\n",
+    "domain = 'amu.edu.pl'\n",
+    "email = username + '@' + domain\n",
+    "print(email)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "NOOOOOOOO!\n"
+     ]
+    }
+   ],
+   "source": [
+    "big_no = 'N' + 'O' * 8 + '!'\n",
+    "print(big_no)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dziś jest 2021/10/17\n"
+     ]
+    }
+   ],
+   "source": [
+    "date = str(2021) + '/' + str(10) + '/' + str(17)\n",
+    "print('Dziś jest', date)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje na stringach, cd.\n",
+    " * długość łańcucha znakowego: `len`: np. `len('Ala') == 3`,\n",
+    " * zamiana na małe litery `lower` lub na wielkie: `upper`,\n",
+    " * zamiana liter: `replace`,\n",
+    " * usuwanie białych znaków: `strip`,\n",
+    " * sprawdzenie czy string rozpoczyna sie danych prefiksem: `startswith`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Słowo mickiewicz ma 10 liter.\n",
+      "python\n",
+      "mickiewicz\n",
+      "2021\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'mickiewicz'\n",
+    "print('Słowo', user, 'ma', len(user), 'liter.')\n",
+    "\n",
+    "print('Python'.lower())\n",
+    "\n",
+    "print(user.replace('T', 'R'))\n",
+    "\n",
+    "print('      2021     '.strip())\n",
+    "\n",
+    "print(user.startswith('mic'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Słowo tomasz ma 6 liter.\n",
+      "Słowo tomasz ma 6 liter.\n",
+      "3\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'tomasz'\n",
+    "print('Słowo', user, 'ma', len(user), 'liter.')\n",
+    "\n",
+    "print(f'Słowo {user} ma {len(user)} liter.')\n",
+    "\n",
+    "\n",
+    "print(len(str(123)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (1c)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Listy (`list`)\n",
+    " * Typ danych, który pozwala przechowywać wiele wartości.\n",
+    " * Dostęp do poszczególnych elementów jest przez indeks elementu.\n",
+    " * Indeksowanie zaczyna się od 0.\n",
+    " * Funkcja `list` zamienia obiekt na listę."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "x = [] # albo równoważnie\n",
+    "y = list()\n",
+    "oceny = [5, 4, 3, 5, 5]\n",
+    "misc = [3.14, \"pi\", [\"pi\"], 3]\n",
+    "\n",
+    "list_0_9 = list(range(10))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Liczba elementów: 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [6, 7, 9, 11]\n",
+    "print('Liczba elementów:', len(numbers))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "7\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [6, 7, 9, 11]\n",
+    "\n",
+    "print(numbers[1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Dodawanie i usuwanie elementów z listy\n",
+    "\n",
+    "Istnieją dwie metody:\n",
+    " * `append(x)`: dodaje x na koniec listy\n",
+    " * `extend(x)`: rozszerza listę o każdy element z x "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['duck-duck-go', 'yahoo']\n"
+     ]
+    }
+   ],
+   "source": [
+    "engines = []\n",
+    "\n",
+    "engines.append('duck-duck-go')\n",
+    "engines.append(\"yahoo\")\n",
+    "print(engines)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['duck-duck-go', 'yahoo', 'google', 'bing']\n"
+     ]
+    }
+   ],
+   "source": [
+    "engines = ['duck-duck-go', 'yahoo']\n",
+    "searches = [\"google\", 'bing']\n",
+    "engines.extend(searches)\n",
+    "print(engines)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['duck-duck-go', 'yahoo', 'google', 'bing']\n",
+      "['duck-duck-go', 'yahoo']\n"
+     ]
+    }
+   ],
+   "source": [
+    "engines = ['duck-duck-go', 'yahoo']\n",
+    "searches = [\"google\", 'bing']\n",
+    "\n",
+    "print(engines + searches)\n",
+    "print(engines)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1, 3, 2, 3, 1, 2, 4]\n",
+      "[1, 3, 3, 1, 2, 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "liczby = [1, 2, 3, 2, 3, 1, 2, 4]\n",
+    "liczby.pop(1) # Domyślnie usuwa ostatni element z listy\n",
+    "print(liczby)\n",
+    "liczby.remove(2)\n",
+    "print(liczby)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Inne przydatne metody:\n",
+    " * `sort()`: sortuje listę rosnąco\n",
+    " * `count(x)`: zlicza wystąpienia x w  liście\n",
+    " * `index(x)`: zwraca indeks pierwszego wystąpienia x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2\n",
+      "7\n",
+      "[1, 1, 2, 2, 2, 3, 3, 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "liczby = [1,2,3,2,3,1,2,4]\n",
+    "print(liczby.count(1))\n",
+    "print(liczby.index(4))\n",
+    "liczby.sort()\n",
+    "print(liczby)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Indeksowanie"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pierwszy element: 1\n",
+      "ostatni element: 4\n",
+      "5 pierwszych: [1, 3, 2, 3, 1]\n",
+      "5 ostatnich [2, 3, 1, 2, 4]\n",
+      "od drugiego, do piątego [3, 2, 3, 1]\n",
+      "parzyste: [3, 3, 2]\n",
+      "od tyłu [4, 2, 1, 3, 2, 3, 1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "oceny = [1, 3, 2, 3, 1, 2, 4]\n",
+    "print('pierwszy element:', oceny[0])\n",
+    "print('ostatni element:', oceny[-1])\n",
+    "print('5 pierwszych:', oceny[:5])\n",
+    "print('5 ostatnich', oceny[-5:])\n",
+    "print('od drugiego, do piątego', oceny[1:5])\n",
+    "print('parzyste:', oceny[1:6:2])\n",
+    "print('od tyłu', oceny[::-1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Funkcje wbudowane\n",
+    " * `len` - zwraca liczbę elementów listy.\n",
+    " * `min` - zwraca wartość najmniejszgo elementu.\n",
+    " * `max` - zwraca wartość największego elementu.\n",
+    " * `sum` - zwraca sumę elementów.\n",
+    " * `all` - zwraca `True`, gdy wszystkie elementy mają wartość `True`.\n",
+    " * `any` - Zwraca `True`, gdy przynajmniej jeden element ma wartość `True`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Liczba elementów: 6\n",
+      "Najmniejszy element: 0\n",
+      "Największy element: 32\n",
+      "Suma elementów: 74\n",
+      "False\n",
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [4, 8, 12, 18, 0,  32]\n",
+    "\n",
+    "print('Liczba elementów:', len(numbers))\n",
+    "print('Najmniejszy element:', min(numbers))\n",
+    "print('Największy element:', max(numbers))\n",
+    "print('Suma elementów:', sum(numbers))\n",
+    "\n",
+    "print(all(numbers))\n",
+    "print(any(numbers))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Krotki (`tuple`)\n",
+    "Podobnym typem do listy jest krotka (`tuple`):\n",
+    " * definiuje się ją `()` lub `tuple()`,\n",
+    " * nie można zmieniać krotki: nie można dodawać ani usuwać elementów,\n",
+    " * nie można również zmieniać elementów*,\n",
+    " * Indeksowanie identyczne jak w listach."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "numbers = (4, 5, 7)\n",
+    "\n",
+    "numbers[2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "([0, 1], [1, 2], [3, 4, 5])\n"
+     ]
+    }
+   ],
+   "source": [
+    "users = ([0], [1, 2], [3, 4, 5])\n",
+    "\n",
+    "users[0].append(1)\n",
+    "\n",
+    "print(users)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (2a, 2b, 2c)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Słowniki (`dict`)\n",
+    "Pewnego rodzaju uogólnieniem listy jest słownik (`dict`), który przechowuje dane jako `klucz`: `wartość`.\n",
+    " * Słowniki pozwala na dodawanie, usuwanie i zmianę elementów.\n",
+    " * Definiujemy jako `{}` lub `dict()`.\n",
+    " * Klucze słownika muszą być niezmienialne (haszowalne)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "store = {}\n",
+    "store = dict()\n",
+    "s_oceny = {\n",
+    "    \"Justyna\": [5,5,5],\n",
+    "    \"Bartek\": [3,4,5],\n",
+    "    \"Ola\": [3,3,3]}\n",
+    "s_oceny = dict([(\"Justyna\", [5,5,5]), (\"Bartek\", [3,4,5]), (\"Ola\", [3,3,3])])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3, 4, 5]\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "user = 'Bartek'\n",
+    "print(s_oceny[user])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3], 'Jan': [4, 4, 5]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "s_oceny['Jan'] = [4, 4, 5]\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3, 1, 4]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "s_oceny['Ola'].extend([1,4])\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,3,3]}\n",
+    "\n",
+    "del s_oceny[\"Justyna\"]\n",
+    "\n",
+    "print(s_oceny)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Operacje\n",
+    " * Funkcja `len` zwraca liczbę elementów w słowniku.\n",
+    " * Domyślnie operacje funkcji wykonywane są na kluczach.\n",
+    " * metoda `keys()` zwraca klucze słownika, `values()` -- wartości, a `items()` -- pary (klucz, wartość). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys([1, 3, 5, 11])\n",
+      "dict_values([1, 2, 2, 3])\n",
+      "dict_items([(1, 1), (3, 2), (5, 2), (11, 3)])\n"
+     ]
+    }
+   ],
+   "source": [
+    "binary_ones = {1: 1, 3: 2, 5: 2, 11: 3}\n",
+    "max(binary_ones)\n",
+    "\n",
+    "print(binary_ones.keys())\n",
+    "print(binary_ones.values())\n",
+    "print(binary_ones.items())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "4\n"
+     ]
+    }
+   ],
+   "source": [
+    "s_oceny = {\"Justyna\" : [5,5,5], \"Bartek\" : [3,4,5], \"Ola\": [3,4,3]}\n",
+    "\n",
+    "print(s_oceny[\"Ola\"][1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "28\n"
+     ]
+    }
+   ],
+   "source": [
+    "users = {'ali99': {'name': 'Alice', 'age': 28}, 'bob90': {'name': 'Bob', 'age': 19}}\n",
+    "\n",
+    "print(users['ali99']['age'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (3)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Instrukcja warunkowa (`if ... elif ... else`)\n",
+    " * Pozwala na wykonanie (wciętego) fragmentu kodu w zależności od czy podany warunek jest spełniony:\n",
+    "  ```python\n",
+    "  if <warunek>:\n",
+    "    instrukcja 1\n",
+    "    ...\n",
+    " ```\n",
+    " * `elif` pozwala na sprawdzenie kolejnego warunku.\n",
+    " * `else` zostanie wykonany, gdy żaden warunek nie został spełniony.\n",
+    " * Elementy `elif` i `else` nie są obowiązkowe.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "score_theory = 40\n",
+    "score_practical = 45\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    print('------')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Jedną ważną rzeczą jest to, że kod, który następuje po instrukcji `if` jest wcięty. Dzięki temu interpreter Pythona jest w stanie określić, które instrucje wchodzą w skład bloku warunkowego, a które nie."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Blok `else` jest opcjonalny i jest wykonywany, gdy warunek zawarty w instrukcji `if` nie jest spełniony. \n",
+    "\n",
+    "Na poniższym przykładnie mamy własnie taki przypadek. Warunek w `if`ie: `score_theory + score_practical > 100` nie jest spełniony, stąd wykonają się instrukcje z bloku `else`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Nie zdobyłeś wystarczającej liczby punktów.\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "score_theory = 40\n",
+    "score_practical = 45\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    print('------')\n",
+    "else:\n",
+    "    print(\"Nie zdobyłeś wystarczającej liczby punktów.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Instrukcja warunkowa `if` pozwala na sprawdzenie wielu warunków -- służy do tego instrukcja `elif` (else if). Warunki są sprawdzane po kolei (od góry): jeżeli warunek zawarty po `if` nie jest spełniony, wtedy sprawdzany jest pierszy warunek z `elif`. Gdy żaden warunek nie jest spełniony, wtedy wykona się kod zawarty w bloku `else`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Będziesz mieć dodatkowy egzamin.\n"
+     ]
+    }
+   ],
+   "source": [
+    "score_theory = 40\n",
+    "score_practical = 45\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    print('------')\n",
+    "elif score_theory + score_practical > 80:\n",
+    "    print(\"Będziesz mieć dodatkowy egzamin.\")\n",
+    "else:\n",
+    "    print(\"Nie zdobyłeś wystarczającej liczby punktów.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Nic nie stoi na przeszkodzie, żeby zagnieżdżać instrukcje warunkowe. W poniższym przykładzie widzimy, że druga instrukcja warunkowa jest zawarta w bloku po pierwszym `if`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Zdobyłeś wystarczającą liczbę punktów.\n",
+      "Wolisz teorię od praktyki\n"
+     ]
+    }
+   ],
+   "source": [
+    "score_theory = 55\n",
+    "score_practical = 50\n",
+    "\n",
+    "if score_theory + score_practical > 100:\n",
+    "    print(\"Zdobyłeś wystarczającą liczbę punktów.\")\n",
+    "    if score_theory > score_practical:\n",
+    "        print('Wolisz teorię od praktyki')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Sprawdzenie obecności w kolekcji (`in`)\n",
+    " * Słowo kluczowe `in` sprawdza czy dany element znajduje sie w kolekcji (np. lista, słownik).\n",
+    " * Jego negacja to `not in`.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Python zawiera bardzo przydatny warunek `in`, który sprawdza czy dany element jest zawarty w danej kolecji, np. w liście lub w słowniku.\n",
+    "\n",
+    "W poniższym przykładzie sprawdzamy, czy liczba `67` jest zawarta w liście."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "67 jest na liście.\n"
+     ]
+    }
+   ],
+   "source": [
+    "numbers = [67, 101, 303]\n",
+    "\n",
+    "if 67 in numbers:\n",
+    "    print('67 jest na liście.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W przypadku słowników (`dict`) sprawdzane jest czy istnieje w słowniku zadany klucz."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Jabłko jest składnikiem.\n"
+     ]
+    }
+   ],
+   "source": [
+    "ingredients = {'apple': 4, 'lemon': 1, 'cherry': 14}\n",
+    "\n",
+    "if 'apple' in ingredients:\n",
+    "    print('Jabłko jest składnikiem.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Możemy wykorzystać warunek `in` do sprawdzenie, czy dany tekst jest podciągiem w drugim."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Yes!\n"
+     ]
+    }
+   ],
+   "source": [
+    "my_programming_lang = \"Python\"\n",
+    "\n",
+    "if \"Pyt\" in my_programming_lang:\n",
+    "    print('Yes!')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Żeby sprawdzić czy dany element __nie występuje__ możemy wykorzystać instrukcję `not in`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Omiń alejkę ze słodyczami.\n"
+     ]
+    }
+   ],
+   "source": [
+    "shopping_list = ['apples', 'bread', 'carrots']\n",
+    "\n",
+    "if 'cookies' not in shopping_list:\n",
+    "    print('Omiń alejkę ze słodyczami.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Obiekty o wartości logicznej `False`\n",
+    " * `0`\n",
+    " * `0.0`\n",
+    " * `[]`\n",
+    " * `()`\n",
+    " * `{}`\n",
+    " * `None`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Bardzo często można spotkać się, gdy chcemy sprawdzić np. czy data lista jest pusta."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "numbers = []\n",
+    "\n",
+    "if numbers:\n",
+    "    print('średnia liczb to:', sum(numbers) / len(numbers))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (4a, 4b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Pętla typu ```for```\n",
+    " * W Pythonie pętla *for* działa jak pętla *for each* w innych językach;\n",
+    " ```python\n",
+    " for zmienna in kolekcja:\n",
+    "     instukcja 1\n",
+    "     instrukcja 2\n",
+    "     ...\n",
+    "```\n",
+    " * Pętla pozwala na zapętlenie kodu, który znajduje w wciętym bloku.\n",
+    " * Konstrukcja pętli jest następująca: po słowie `for` musimy podać nazwę zmiennej, która po kolei będzie przyjmować wartości z kolekcji, np. z listy. Pętla wykona się tyle razy, ile jest elementów w kolekcji.\n",
+    " * Funkcja `range(n)` zwraca kolekcję liczb od `0` do `n-1`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "To na co warto zwrócić uwagę to wcięcie. Kod, który ma zostać wykonany w pętli musi być wcięty."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "element apples\n",
+      "element cherries\n",
+      "element pineapple\n"
+     ]
+    }
+   ],
+   "source": [
+    "ingredients = ['apples', 'cherries', 'pineapple']\n",
+    "\n",
+    "for ingredient in ingredients:\n",
+    "    print('element', ingredient)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Funkcja `range(n)` zwraca obiekt, który możemy przekonwertowąć na listę elementów od 0 do `n-1`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 1, 2, 3, 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(list(range(5)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Bardzo często można spotkać poniżsżą kombinację funkcji `range` i `len` w kontekście pętli:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "apples\n",
+      "cherries\n",
+      "pineapple\n"
+     ]
+    }
+   ],
+   "source": [
+    "ingredients = ['apples', 'cherries', 'pineapple']\n",
+    "\n",
+    "for i in range(len(ingredients)):\n",
+    "    print(ingredients[i])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W przypadku połączenia słownika i pętli, do zmiennej przypisywane są kolejne klucze ze słownika (przykład poniżej):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "apple\n",
+      "lemon\n",
+      "cherry\n"
+     ]
+    }
+   ],
+   "source": [
+    "shopping_list = {'apple': 4, 'lemon': 1, 'cherry': 14}\n",
+    "for item in shopping_list:\n",
+    "    print(item)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Jak wcześniej wspomniałem, metoda `items()` zwraca listę krotek: `(klucz, wartość)` i możemy wykorzystać to w pętli `for`. W tym przypadku musimy podać dwie zmienne:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Buy 4 apples\n",
+      "Buy 1 lemon\n",
+      "Buy 14 cherries\n"
+     ]
+    }
+   ],
+   "source": [
+    "shopping_list = {'apples': 4, 'lemon': 1, 'cherries': 14}\n",
+    "for item, number in shopping_list.items():\n",
+    "    print('Buy', number, item)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Możemy też iterować po stringu -- znak po znaku:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "P\n",
+      "y\n",
+      "t\n",
+      "h\n",
+      "o\n",
+      "n\n"
+     ]
+    }
+   ],
+   "source": [
+    "for char in 'Python':\n",
+    "    print(char)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Ćwiczenie: czy rozumiesz kod, który był na początku zajęć?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The area of the triangle is 14.696938456699069\n"
+     ]
+    }
+   ],
+   "source": [
+    "sides = [5, 6, 7]\n",
+    "\n",
+    "# calculate the semi-perimeter\n",
+    "s = sum(sides) / 2\n",
+    "\n",
+    "# calculate the area\n",
+    "area = s\n",
+    "for side in sides:\n",
+    "    area = area * (s - side)\n",
+    "area = area ** 0.5\n",
+    "\n",
+    "print(f'The area of the triangle is {area}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Zagnieżdżając dwie pętle musimy pamiętać o dodatkowym wcięciu (tak jak w przykładzie poniżej)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "2\n",
+      "4\n",
+      "3\n",
+      "6\n",
+      "9\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(3):\n",
+    "    for j in range(i+1):\n",
+    "        print((i + 1) * (j + 1))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (5a, 5b, 5c i 5d)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Funkcje\n",
+    " * Pozwalają na uniknięcie pisania tego samego kodu za każdym razem.\n",
+    " * Pozwalają na wielokrotne wykorzystanie tego samego fragmentu kodu.\n",
+    " * Zwiększają czytelność kodu.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Definicja funkcji wygląda następująco:\n",
+    " * najpierw piszemy słowo kłuczowe `def`, następnie nazwę funkcji, później w nawiasach okrągłych listę argumentów i kończymy dwukropkiem.\n",
+    " * następnie wcięty blok to będzie kod funkcji."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello!\n"
+     ]
+    }
+   ],
+   "source": [
+    "def hello():\n",
+    "    print('Hello!')\n",
+    "\n",
+    "hello()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "W powyższym przykładzie zdefiniowaliśmy funkcje `hello`, która nie przyjmuje żadnych argumentów. Wywołanie tej funkcji nie różni się od wywołań innych funkcji."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Słowo kluczowe `return` pozwala na zwrócenie wartości przez funkcję. Poniższa funkcja `get_five` zwraca liczbę pięć."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_five():\n",
+    "    return 5\n",
+    "x = get_five()\n",
+    "print(x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Argumenty funkcji umieszczamy w nawiasach:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "```python\n",
+    "def nazwa_funkcji(arg_1, arg_2, arg_3):\n",
+    "    instrukcja 1\n",
+    "    instrukcja 2\n",
+    "    return jakaś wartość\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Przykład: poniższa funkcja `get_bigger` przyjmuje dwa argumenty: `a` i `b`, które rozdzielamy przecinkiem."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "512\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_bigger(a, b):\n",
+    "    if a >= b:\n",
+    "        return a\n",
+    "    return b\n",
+    "print(get_bigger(56, 512))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "def srednia(lista):\n",
+    "    s = 0\n",
+    "    for item in lista:\n",
+    "        s += item\n",
+    "    return s / len(lista) \n",
+    "\n",
+    "print(srednia([7,8,9]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def count(lista, item):\n",
+    "    l = 0\n",
+    "    for i in lista:\n",
+    "        if i == item:\n",
+    "            l += 1\n",
+    "    return l"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Podczas wywoływania funkcji możemy dopowiedzieć, która argument jaką przyjmuje wartość."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 72,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "count([5,5,5,4], 5)\n",
+    "count(lista=[5,5,5,4], item=5)\n",
+    "count(item=5, lista=[5,5,5,4])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (7a i 7b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Korzystanie z bibliotek"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Python posiada bogatą kolekcję bibliotek wbudowanych, tzn. które są dostarczone wraz z interpreterem.\n",
+    "\n",
+    "Żeby móc wykorzystać daną bibliotekę, to musimy ją zaimportować. Możemy to zrobić na dwa sposoby:\n",
+    " * `import <nazwa_biblioteki>`. Dostęp do elementów jest poprzez `<nazwa_biblioteki>.nazwa_funkcji`.\n",
+    " * `from <nazwa_biblioteki> import <nazwa funkcji>`: pozwala na dołączenie elementów biblioteki, tak jakby były częścią naszego skryptu.\n",
+    " \n",
+    "Przykłady:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "posix\n",
+      "Nazwa uzytkownika: kuba\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "print(os.name)\n",
+    "\n",
+    "from os import getenv\n",
+    "print('Nazwa uzytkownika: {}'.format(getenv(\"USER\")))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "1. Importujemy bibliotekę `os`. Dostęp do stałej jest \"przez kropkę\".\n",
+    "2. Z biblioreki `os` importujemy funkcję `getenv` (zwraca wartości zmiennych systemowych)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Wystarczy, że zaimportujemy raz daną bibliotekę:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-1.0"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import math\n",
+    "math.cos(math.pi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Jeżeli nazwa biblioteki jest za długa, to możemy użyć aliasu: `import <nazwa_biblioteki> as <alias>`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "    October 2021\n",
+      "Mo Tu We Th Fr Sa Su\n",
+      "             1  2  3\n",
+      " 4  5  6  7  8  9 10\n",
+      "11 12 13 14 15 16 17\n",
+      "18 19 20 21 22 23 24\n",
+      "25 26 27 28 29 30 31\n"
+     ]
+    }
+   ],
+   "source": [
+    "import calendar as cal\n",
+    "cal.TextCalendar().prmonth(2021, 10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Ważniejsze biblioteki wbudowane:\n",
+    " * `os`, `sys`: obsługa rzeczy dt. systemu i środowiska\n",
+    " * `datetime`: wszystko co jest związane z czasem\n",
+    " * `collections`: zawiera `Counter` i `defaultdict`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Czas na zadanie (9a i 9b)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "## Obsługa plików"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Beautiful is better than ugly.\n",
+      "Explicit is better than implicit.\n",
+      "Simple is better than complex.\n"
+     ]
+    }
+   ],
+   "source": [
+    "zen_file = open('./zen_of_python.txt')\n",
+    "zen_text = zen_file.read()\n",
+    "print(zen_text[:95])\n",
+    "\n",
+    "zen_file.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Beautiful is better than ugly.\n",
+      "Explicit is better than implicit.\n",
+      "Simple is better than complex.\n"
+     ]
+    }
+   ],
+   "source": [
+    "zen_file = open('./zen_of_python.txt')\n",
+    "\n",
+    "zen_lines = list(zen_file)\n",
+    "\n",
+    "for line in zen_lines[:3]:\n",
+    "    print(line.strip())\n",
+    "\n",
+    "\n",
+    "zen_file.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Beautiful is better than ugly.\n",
+      "Explicit is better than implicit.\n",
+      "Simple is better than complex.\n"
+     ]
+    }
+   ],
+   "source": [
+    "with open('./zen_of_python.txt') as zen_file:\n",
+    "    print(zen_file.read()[:95])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "tree_per_sqkm = {\n",
+    "    \"Brazil\": 39542,\n",
+    "    \"Bulgaria\": 24987,\n",
+    "}\n",
+    "\n",
+    "with open('./zalesienie.txt', mode='w') as plik:\n",
+    "    for country, num_trees in tree_per_sqkm.items():\n",
+    "        plik.write(country + ',' + str(num_trees) + '\\n')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Podstawy Obiektowości\n",
+    "\n",
+    " - W Pythonie każda wartość jest obiektem, tzn. może zostać przypisana do zmiennej lub zostać\n",
+    "przekazane do funkcji.\n",
+    " - Każda wartość może mieć metody lub atrybuty."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "11\n",
+      "5\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datetime import date\n",
+    "\n",
+    "today = date(2022, 11, 5)\n",
+    "\n",
+    "print(today.month) # atrybut\n",
+    "print(today.weekday()) # metoda"
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Slideshow",
+  "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": 1
+}
diff --git a/zajecia1/zadania/zadanie_0.py b/zajecia1/zadania/zadanie_0.py
new file mode 100644
index 0000000..38d368e
--- /dev/null
+++ b/zajecia1/zadania/zadanie_0.py
@@ -0,0 +1,8 @@
+"""
+Uruchom ten skrypt i sprawdź czy skrypt uruchomił się poprawnie.
+"""
+
+
+print("Ten napis powinien wyświetlić się w konsoli na dole.")
+
+
diff --git a/zajecia1/zadania/zadanie_1a.py b/zajecia1/zadania/zadanie_1a.py
new file mode 100644
index 0000000..ce9f3ba
--- /dev/null
+++ b/zajecia1/zadania/zadanie_1a.py
@@ -0,0 +1,7 @@
+
+"""
+ * stwórz zmienną o nazwie `pi` i o wartości 3.14.
+ * stwórz zmienną o nazwie `promien` i o wartości 12.
+ * oblicz pole koła i przypisz wynik do zmniennej `pole`. P = pi * r ** 2
+ * wyświetl wynik na ekran.
+""" 
diff --git a/zajecia1/zadania/zadanie_1b.py b/zajecia1/zadania/zadanie_1b.py
new file mode 100644
index 0000000..5e11aa0
--- /dev/null
+++ b/zajecia1/zadania/zadanie_1b.py
@@ -0,0 +1,11 @@
+
+"""
+Zamień typ zmiennych `a`, `b` i `c` na typy liczbowe (int lub float) i oblicz ich sumę.
+Wynik zapisz do zmiennej `wynik` i wyświetl go na ekranie
+""" 
+
+# zmienne do zadania
+a = "12"
+b = "35.5"
+c = True
+
diff --git a/zajecia1/zadania/zadanie_1c.py b/zajecia1/zadania/zadanie_1c.py
new file mode 100644
index 0000000..8668e08
--- /dev/null
+++ b/zajecia1/zadania/zadanie_1c.py
@@ -0,0 +1,17 @@
+"""
+ * Stwórz 2 zmiennie: firstname i surname, które będą zawierać Twoje imię i nazwisko.
+ * Połącz te zmiennie w takim sposób, żeby było rozdzielone spacją i zapisz wynik do zmiennej fullname.
+ * Wykorzystaj f-string i wyświetl na ekran zawartość zmiennej fullname, w taki sposób, żeby zawartość zmiennej była poprzedzona słowami "Nazywam się ".
+ * Wyświetl sumaryczną długość zmiennych firstname i surname. 
+"""
+
+firstname = "Tomasz"
+surname = "Dwojak"
+
+print(f"Nazywam się {firstname} {surname}.")
+
+print(firstname.lower())
+
+print("Nazywam się %s %s" % (firstname, surname))
+
+
diff --git a/zajecia1/zadania/zadanie_2a.py b/zajecia1/zadania/zadanie_2a.py
new file mode 100644
index 0000000..00aaadb
--- /dev/null
+++ b/zajecia1/zadania/zadanie_2a.py
@@ -0,0 +1,14 @@
+"""
+Poniżej znajduje się lista `websites`. 
+ * Pod jakim indeksem znajduje się wartość 'pinterest.com'?
+ * Zamień wartość piątego elementu na 'yahoo.com'.
+ * Dodaj na koniec listy nowy element: 'bing.com'
+ * Korzytając z indeksowania stwórz podlistę składającą się z elementów 'facebook.com', 'twitter.com'. Wynik przypisz do zmniennej `social_networks`.
+ * Rozszerz listę `websites` o elementy z listy `polish_websites`.
+ * Ile elementów liczy teraz lista `websites`?
+"""
+
+
+websites = ['google.com', 'facebook.com', 'twitter.com', 'pinterest.com', 'python.org']
+
+polish_websites = ['onet.pl', 'interia.pl', 'wp.pl']
diff --git a/zajecia1/zadania/zadanie_2b.py b/zajecia1/zadania/zadanie_2b.py
new file mode 100644
index 0000000..d87d038
--- /dev/null
+++ b/zajecia1/zadania/zadanie_2b.py
@@ -0,0 +1,10 @@
+"""
+Korzystając z listy numbers:
+* wyświetl na ekranie drugi element.
+* zlicz ile elementów listy ma wartosc 7 (użyj metody `count`).
+* ile elementów zawiera lista?
+* jak sprawdzisz jaka jest największa wartosc zawarta w liscie?
+"""
+
+
+numbers = [1, 8, 6, 6, 6, 7, 2, 0, 3, 0, 2, 3, 7, 0, 7, 2, 0, 3, 9, 4]
\ No newline at end of file
diff --git a/zajecia1/zadania/zadanie_2c.py b/zajecia1/zadania/zadanie_2c.py
new file mode 100644
index 0000000..140eb66
--- /dev/null
+++ b/zajecia1/zadania/zadanie_2c.py
@@ -0,0 +1,16 @@
+"""
+Lista iris_setosa zawiera informacje o 4 egzemplarzach kosacieca szczecinkowego.
+Pierwszy indeks to długość kwiata.
+Drugi indeks to szerokość kwiata.
+Trzeci indeks to długość liścia.
+Czwarty indeks to szerokość liścia.
+
+* Oblicz średnią szerokość kwiata.
+* Dodaj do listy dane o nowym egzemplarzu: (5.4, 3.9, 1.7, 0.4)
+"""
+
+iris_setosa  = [
+    [5.1, 3.5, 1.4, 0.2],
+    [4.9, 3, 1.4, 0.2],
+    [4.7, 3.2, 1.3, 0.2],
+]
diff --git a/zajecia1/zadania/zadanie_3.py b/zajecia1/zadania/zadanie_3.py
new file mode 100644
index 0000000..e469edf
--- /dev/null
+++ b/zajecia1/zadania/zadanie_3.py
@@ -0,0 +1,25 @@
+"""
+Korzystając ze poniższego słownika, który zawiera informacje z WikiData nt. Adama Mickiewiecza wykonaj następujące zadania:
+* Wyświetl miejsce urodzenia (place of birth) A. Mickiewicza.
+* Oblicz ile lat żył A. Mickiewicz.
+* Dodaj nowy klucz `place of death` o wartości `Istanbul`.
+* Zamień wartość klucza `place of birth` na `Zaosie`.
+* Dodaj nowy klucz `spouse`, a którego wartością niech będzie słownik `cecylia_data`.
+* Wyświetl liczbę elementów listy, która znajduje się pod kluczem `occupation`.
+* Wyświetl nazwiko żony A. Mickiewicza.
+"""
+
+data = {
+    'name': 'Adam',
+    'surname': 'Mickiewicz',
+    'native language': 'polish',
+    'year of birth': 1798,
+    'place of birth': 'Zavosse',
+    'year of death': 1855,
+    'occupation': ['poet', 'professor', 'playwright']
+}
+
+cecylia_data = {
+    'name': 'Cecylia',
+    'surname': 'Szymanowska'.
+}
diff --git a/zajecia1/zadania/zadanie_4a.py b/zajecia1/zadania/zadanie_4a.py
new file mode 100644
index 0000000..22b1589
--- /dev/null
+++ b/zajecia1/zadania/zadanie_4a.py
@@ -0,0 +1,6 @@
+"""
+Sprawdź czy tekst 'aAaAaA' znajduje się w tablicy passwords.
+W zależności czy znajduje się czy też nie, wyświetl na ekranie odpowiedni komunikat.
+"""
+
+passwords = ['aaAaa', 'aAAAaa', 'aaaaaaA', 'aaaAAAAA', 'aaAAAaa', 'aAaAaA', 'aAaAaAA']
\ No newline at end of file
diff --git a/zajecia1/zadania/zadanie_4b.py b/zajecia1/zadania/zadanie_4b.py
new file mode 100644
index 0000000..24a963f
--- /dev/null
+++ b/zajecia1/zadania/zadanie_4b.py
@@ -0,0 +1,14 @@
+"""
+Niech x oznacza liczbę uzyskanych punktów. Standardowa skala ocen jest następująca:
+* x >= 90 -- 5.0
+* 90 > x >= 80 -- 4.5
+* 80 > x >= 70 -- 4.0
+* 70 > x >= 60 -- 3.5
+* 60 > x >= 50 -- 3.0
+* x < 50 -- 2.0
+
+Zmienna `points` zawiera liczbę uzyskanych punktów przez studenta.
+Napisz instrukcję warunką, która wyświetli ocenę studenta w zależności od liczby punktów.
+"""
+
+points = 85
diff --git a/zajecia1/zadania/zadanie_5a.py b/zajecia1/zadania/zadanie_5a.py
new file mode 100644
index 0000000..72390cd
--- /dev/null
+++ b/zajecia1/zadania/zadanie_5a.py
@@ -0,0 +1,4 @@
+"""
+Oblicz sumę  liczb od 1 do 678.
+"""
+
diff --git a/zajecia1/zadania/zadanie_5b.py b/zajecia1/zadania/zadanie_5b.py
new file mode 100644
index 0000000..68833fe
--- /dev/null
+++ b/zajecia1/zadania/zadanie_5b.py
@@ -0,0 +1,23 @@
+
+"""
+Słownik `oceny` zawiera oceny kilku osób. Kluczami są imiona dzieci, a wartosciami -- ich oceny.
+Uzupełnij słownik `rozklad`, którego kluczami są oceny, a wartosciami -- listy... 
+"""
+
+oceny = {
+    'Albert': 4.5,
+    'Beata': 5,
+    'Cecylia': 4,
+    'Dariusz': 4,
+    'Eliza': 3,
+    'Feliks': 5,
+    'Grzegorz': 4.5,
+    'Izabela': 4.5
+}
+
+rozklad = {
+    5: [],
+    4.5: [],
+    4: [],
+    3: []
+}
diff --git a/zajecia1/zadania/zadanie_5c.py b/zajecia1/zadania/zadanie_5c.py
new file mode 100644
index 0000000..88398b9
--- /dev/null
+++ b/zajecia1/zadania/zadanie_5c.py
@@ -0,0 +1,33 @@
+
+"""
+Poniżej znajdują się 2 słowniki z danymi o liczbie przejazdów rowerami miejskimi w Montrealu w 2018 z podziałem na miesiące (od kwietnia do listopada).
+Pierwszy słownik zawiera informacje o przejazdach wykonanych przez posiadaczy abonamentu, a drugi przez ludzi, którzy
+nie mają wykupionego abonamentu. Dane pochodzą ze strony https://montreal.bixi.com/en/open-data. 
+
+a) Stwórz trzeci słownik `all_rides`, w którym zliczysz łączną liczbę przejazdów w każdym z podanych miesięcy.
+b) Oblicz sumę zarejestrowanych przejazdów od kwietnia do listopada.
+c) Wyswietl jaki procent wszystkich przejazdów odbyło się w sierpniu (August).
+
+"""
+
+members = {
+    'April': 211819,
+    'May': 682758,
+    'June': 737011,
+    'July': 779511,
+    'August': 673790,
+    'September': 673790,
+    'October': 444177,
+    'November': 136791,
+}
+
+occasionals = {
+    'April': 32058,
+    'May': 147898,
+    'June': 171494,
+    'July': 194316,
+    'August': 206809,
+    'September': 140492,
+    'October': 53596,
+    'November': 10516,
+}
diff --git a/zajecia1/zadania/zadanie_5d.py b/zajecia1/zadania/zadanie_5d.py
new file mode 100644
index 0000000..638fa77
--- /dev/null
+++ b/zajecia1/zadania/zadanie_5d.py
@@ -0,0 +1,23 @@
+"""
+Poniższy słownik zawiera dane z kilku wybranych krajów nt. liczby drzew na kilometr kwadratowy.
+ a) Wypisz na ekran nazwy tych krajów, dla których współczynnik ten jest większy niż 20000.
+ b) Wypisz na ekran nazwy tych krajów, dla których współczynnik ten jest większy niż 10000, ale mniejszy niż 20000.
+"""
+
+tree_per_sqkm = {
+    "Brazil": 39542,
+    "Bulgaria": 24987,
+    "Canada": 36388,
+    "Denmark": 6129,
+    "Finland": 90652,
+    "France": 24436,
+    "Greece": 24323,
+    "India": 11109,
+    "Japan": 49894,
+    "Russia": 41396,
+    "Saudi Arabia": 1,
+    "Syria": 534,
+    "United States": 23513,
+    "Taiwan": 69593,
+    "Turkey": 11126,
+}
diff --git a/zajecia1/zadania/zadanie_6a.py b/zajecia1/zadania/zadanie_6a.py
new file mode 100644
index 0000000..fbd7e85
--- /dev/null
+++ b/zajecia1/zadania/zadanie_6a.py
@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Napisz kod, który zwraci tzw. "Big 'NO!'" (zob. http://tvtropes.org/pmwiki/pmwiki.php/Main/BigNo)
+dla zadanej liczby tj. napis typu "NOOOOOOOOOOOOO!", gdzie liczba 'O' ma być
+równa wartości zmniennej `number_of_o`. Jeśli argument jest mniejszy niż 5, ma być zwracany napis "It's not a Big 'No!'".
+Wyświetl ten napis na ekran.
+"""
+
+number_of_o = 6
diff --git a/zajecia1/zadania/zadanie_6b.py b/zajecia1/zadania/zadanie_6b.py
new file mode 100644
index 0000000..409a4b7
--- /dev/null
+++ b/zajecia1/zadania/zadanie_6b.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+"""
+ * Podziel zmienną `text` na słowa, korzystając z metody split.
+ * Dodaj do listy `oov`, wszystkie słowa (bez powtórzeń), które nie są zawarte w liście `vocab`.
+"""
+
+
+
+text = "this is a string , which i will use for string testing"
+vocab = [',', 'this', 'is', 'a', 'which', 'for', 'will', 'i']
+
+oov = []
diff --git a/zajecia1/zadania/zadanie_7a.py b/zajecia1/zadania/zadanie_7a.py
new file mode 100644
index 0000000..5f8925d
--- /dev/null
+++ b/zajecia1/zadania/zadanie_7a.py
@@ -0,0 +1,9 @@
+"""
+1. Napisz rekurencyjną funkcję, która zwróci n-ty wyraz ciągu Fibonacciego.
+2. Napisz funkcję, która obliczy n-ty wyroz ciągu Fibonacciego nie korzystając z rekurencji.
+Np. możesz wykorzystać listę do obliczania kolejnych wartości ciągu.
+
+Ciąg Fibonacciego:
+a[0] = 1, a[1] = 1, a[n] = a[n-1] + a[n-2] dla n>=2
+
+"""
diff --git a/zajecia1/zadania/zadanie_7b.py b/zajecia1/zadania/zadanie_7b.py
new file mode 100644
index 0000000..6bab0b4
--- /dev/null
+++ b/zajecia1/zadania/zadanie_7b.py
@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Napisz funkcję sum_div35(n), która zwraca sumę wszystkich liczb podzielnych
+przez 3 lub 5 mniejszych niż n.
+"""
+
+def sum_div35(n):
+    pass
+
+input = 100
+# dla n =100 poprawna odpowiedź to 2318
diff --git a/zajecia1/zadania/zadanie_8.py b/zajecia1/zadania/zadanie_8.py
new file mode 100644
index 0000000..ebae6bf
--- /dev/null
+++ b/zajecia1/zadania/zadanie_8.py
@@ -0,0 +1,6 @@
+"""
+Otwórz plik `zen_of_python.txt` i zlicz liczbę linii i słów w tym pliku. 
+Następnie przerób kod na funkcję, która jako argument będzie przyjmować ściężkę do pliku i będzie zwracać 
+słownik z dwoma kluczami: `liczba_linii` i `liczba_slow`.
+"""
+
diff --git a/zajecia1/zadania/zadanie_9a.py b/zajecia1/zadania/zadanie_9a.py
new file mode 100644
index 0000000..407460d
--- /dev/null
+++ b/zajecia1/zadania/zadanie_9a.py
@@ -0,0 +1,19 @@
+"""
+Zadania: Zaimportuj bibliotekę statistics, która zawiera funckje do obliczenia podstawych wielkości statystycznych (średnia, mediana, moda):
+    statistics.mean -- obliczenie średniej
+    statistics.median -- obliczenie mediany
+    statistics.variance -- obliczenie wariancji
+    statistics.stdev -- obliczenie odchylenia standardowego Oblicz te wielkości dla wartości z poniższego słownika.
+Każda z tych funkcji przyjmuje jeden argument: listę wartości.
+"""
+
+members = {
+    'April': 211819,
+    'May': 682758,
+    'June': 737011,
+    'July': 779511,
+    'August': 673790,
+    'September': 673790,
+    'October': 444177,
+    'November': 136791,
+}
diff --git a/zajecia1/zadania/zadanie_9b.py b/zajecia1/zadania/zadanie_9b.py
new file mode 100644
index 0000000..12536de
--- /dev/null
+++ b/zajecia1/zadania/zadanie_9b.py
@@ -0,0 +1,10 @@
+"""
+Biblioteka random posiada funkcję random, która zwraca losową licznę z przedziału [0, 1) (nie przyjmuje żadnych argumentów).
+Biblioteka math posiada funkcję hypot, która oblicza odległość punktu od środka układu współrzędnych (punktu [0, 0]) i przyjmuje dwa argumenty: współrzędne punktu.
+* Zaimportuj biblioteki random i math
+* korzystając z funkcji random wylosuj dwie liczby i przypisz wyniki do zmniennych x i y.
+* Korzystając z funkcji hypot oblicz odległość punktu o współrzednych (x,y).
+* Dodaj pętlę, która będzie wykonywać te czynności n = 10 razy i będzie zliczać ile razy obliczona odległość jest mniejsza od 1.
+* Oblicz stosunek liczby punktów, dla których odległość wynosiła mniej niż 1 do całkowitej liczby punktów. Pomnóż tę wartocść przez 4.
+* Podstaw za n wartości 100, 1000, 1000000. Do jakiej wartości zbiegają wartości?
+"""
diff --git a/zajecia1/zalesienie.txt b/zajecia1/zalesienie.txt
new file mode 100644
index 0000000..60e937d
--- /dev/null
+++ b/zajecia1/zalesienie.txt
@@ -0,0 +1,2 @@
+Brazil,39542
+Bulgaria,24987
diff --git a/zajecia1/zen_of_python.txt b/zajecia1/zen_of_python.txt
new file mode 100644
index 0000000..255ecb9
--- /dev/null
+++ b/zajecia1/zen_of_python.txt
@@ -0,0 +1,19 @@
+Beautiful is better than ugly.
+Explicit is better than implicit.
+Simple is better than complex.
+Complex is better than complicated.
+Flat is better than nested.
+Sparse is better than dense.
+Readability counts.
+Special cases aren't special enough to break the rules.
+Although practicality beats purity.
+Errors should never pass silently.
+Unless explicitly silenced.
+In the face of ambiguity, refuse the temptation to guess.
+There should be one-- and preferably only one --obvious way to do it.
+Although that way may not be obvious at first unless you're Dutch.
+Now is better than never.
+Although never is often better than *right* now.
+If the implementation is hard to explain, it's a bad idea.
+If the implementation is easy to explain, it may be a good idea.
+Namespaces are one honking great idea -- let's do more of those!