commit f9a78c4675a27f0de1a2c644317351ad94cd8f07
Author: kubapok <jakub.pokrywka@gmail.com>
Date:   Sun Nov 17 12:18:54 2024 +0100

    zajecia 1

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..4858705
--- /dev/null
+++ b/README.md
@@ -0,0 +1,78 @@
+# Analiza i wizualizacja danych w Pythonie
+
+Materiały do zajęć Analiza i wizualizacja danych w Pythonie prowadzone na Wydziale Matematyki i Informatyki UAM w ramach studiów podyplomowych Przetwarzanie danych - Big Data. Kurs 2024/2025
+
+
+## Informacja o przedmiocie
+
+Prowadzący:
+- dr inż. Jakub Pokrywka. Kontakt przez komunikator MS TEAMS lub mailowy (jakub.pokrywka@amu.edu.pl).
+- mgr Anna Kaluba
+
+
+## Materiały do przedmiotu
+
+Program jest cześciowo 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:
+* [https://docs.python.org/3/](Dokumentacja pythona)
+* 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.
+* [Automate the boring stuff with python](https://automatetheboringstuff.com/)
+
+## Ogólny Plan zajęć
+
+- Zajęcia 1 - Wprowadzenie do python 1/2
+- Zajęcia 2 - Wprowadzenie do python 2/2
+- Zajęcia 3 - pandas
+- Zajęcia 4 - numpy
+- Zajęcia 5 - scikit-learn
+- Zajęcia 6 - przetwarzanie tekstu w python
+- Zajęcia 7 - przetwarzanie obrazów w python
+- Zajęcia 8 -  zajęcia z analizy wizualizacji danych
+- Zajęcia 9 - zajęcia z analizy wizualizacji danych
+- Zajęcia 10 - zajęcia z analizy wizualizacji danych
+- Zajęcia 11 - Zaliczenie
+
+
+## Zaliczenie przedmiotu
+
+### Forma
+- 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ć 12 minut przy pomocy powerpoint lub jupyter notebook
+- Zachęcam do stworzenia bardziej rozbudowanego projektu bazującego na Państwa zainteresowaniach 
+- Proszę uwzględnić, że dodatkowo należy będzie pokazać repozytorium kodu
+
+### Zadania
+- Należy wybrać interesujący zbiór danych (akceptacja grup oraz zbioru danych przez prowadzącego na drugich lub trzecich zajęciach). Np. dane tabularyczne (conajmniej 15 kolumn jeżeli jedna tabelka, może być również kilka tabelek), moga być również dane tekstowe lub obrazkowe. 
+- zaprezentować analizę tego zbioru danych (tabelki, wykresy, wnioski) w max 12 minut- zaliczenie na ocenę 
+- 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
+
+### Skala ocen
+3 - kod i  environment.yml w repozytorium, omówienie zbioru, ogólna analiza, statystki opisowe (wskaźniki + tabelki), conajmniej 3 różne wizualizacje (np. barplot, scatterplot, violinplot- powinny być poprawne wzgledem danej zmiennej)
+4 - to co na 4 oraz conajmniej 5 różnych wizualizacje (np. barplot, scatterplot, violinplot, heatmapa, w tym choć jeden bardziej zaawansowany), model uczenia maszynowego w sklearn
+5 - to co na 5 oraz conajmniej  2 zaawansowane wykresy/raporty w quarto
+
+Termin oddania zadań do będzie jeszcze podany.
+
+## Dodatkowe materiały
+### jupyter notebook
+- https://noteable.io/blog/jupyter-notebook-shortcuts-boost-productivity/
+
+### bash
+- https://www.earthdatascience.org/courses/intro-to-earth-data-science/open-reproducible-science/bash/
+- https://www.educative.io/blog/bash-shell-command-cheat-sheet
+
+### git
+- https://git.wmi.amu.edu.pl/
+- https://www.freecodecamp.org/news/learn-the-basics-of-git-in-under-10-minutes-da548267cc91/
+- https://git-scm.com/docs/gittutorial
+- https://git-scm.com/book/en/v2
+
+### pycharm tutorial:
+- https://www.jetbrains.com/guide/python/tutorials/getting-started-pycharm/
diff --git a/zajecia1/1_wprowadzenie_do_python.ipynb b/zajecia1/1_wprowadzenie_do_python.ipynb
new file mode 100644
index 0000000..ca8c958
--- /dev/null
+++ b/zajecia1/1_wprowadzenie_do_python.ipynb
@@ -0,0 +1,398 @@
+{
+ "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 (np. funkcyjny)\n",
+    "- język dynamicznie typowany (x = 5 zamiast int x = 5)\n",
+    "- zarządzanie pamięcia poprzez garbage collector\n",
+    "- wcięcia (tabulacje lub spacje) zamiast nawiasów\n",
+    "- język interpretowany (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 cześciej się czyta niż pisze. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Zastosowania python\n",
+    "- najbardziej popularny język do analizy i wizualizacji danych obok R\n",
+    "- najbardziej popularny język do uczenia maszynowego, w szczególności sieci neuronowych. Posiada biblioteki TensorFlow (wraz z wbudowanym Keras), Pytorch, Jax\n",
+    "- inne zastosowania naukowe\n",
+    "- tworzenie stron internetowych (Django) oraz mikroserwisów (Flask, FastApi, Bottle, Django)\n",
+    "- skrypty, automayzacja, administracja serwerów"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Uruchamianie python\n",
+    "\n",
+    "- uruchamianie skryptu *.py wprost z wiersza poleceń\n",
+    "- uruchamianie python w trybie interaktywnym przez interpreterze python lub ipython\n",
+    "- uruchamianie skryptu + tryb interaktywny\n",
+    "- jupyter notebook, google colab\n",
+    "- IDE (np Pycharm, Microsoft Visual Studio)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Menadżery pakietów\n",
+    "- pip\n",
+    "- virtualenv\n",
+    "- conda"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/anaconda3/anaconda3/bin/python\n"
+     ]
+    }
+   ],
+   "source": [
+    "!which python"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### virtualenv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install virtualenv # instalacja"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!virtualenv myenv # tworzenie środowiska o nazwie myenv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!source myenv/bin/activate # uruchamianie środowiska na linux"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!myenv\\Scripts\\activate # uruchamianie środowiska na linux na windows"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!which python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!which pip"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!deactivate deaktywowanie środowiska"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install requests # instalacja pakietów za pomocą python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!rm -rf myenv # usuwanie środowiska"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/bin/bash: line 1: virtualenv: command not found\n"
+     ]
+    }
+   ],
+   "source": [
+    "!virtualenv --help"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/bin/bash: line 1: virtualenv: command not found\n"
+     ]
+    }
+   ],
+   "source": [
+    "!virtualenv --version"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### zadanie virtualenv\n",
+    "Proszę stworzyć środowisko o nazwie myscikitlearnenv, spróbować zaimportować sklearn:\n",
+    "\n",
+    "import sklearn # powinno się nie udać\n",
+    "\n",
+    "Następnie zainstalować w nim scikit-learn i ponownie spróbować zaimportować sklearn (tym razem powinno się udać)\n",
+    "\n",
+    "Następnie deaktywować środowisko i usunąć je."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## conda (anaconda, miniconda, miniforge)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# najpierw - instalacja anconda"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "! tail -n30 ~/.bashrc # conda uruchamia się w ~/.bashrc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda create --name myenv # tworzenie nowego środowiska"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda create --name myenv python=3.9 # tworzenie nowego środowiska dla python w wersji 3.9"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda activate myenv # aktywowanie środowiska"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!which python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda deactivate # deaktywowanie środowiska"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda env list # wylistowanie dostępnych środowisk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda install requests # instalacja pakietu za pomocą conda"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda install nodejs # instalacja nodejs (coś zupełnie poza środowiskiem pythona)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install requests # instalacja pakietu za pomocą pip\n",
+    "!pip install scikit-learn # instalacja pakietu za pomocą pip"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda env export > environment.yml # eksport środowiska"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda env create -f environment.yml # import środowiska"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda list # wylistowanie zainstalowanych pakietów"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda --help"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!conda --version"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "!conda remove --name nazwa_srodowiska --all # usuwanie środowiska- albo wystarczy wprost usunąć pliki środowiska\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### zadanie conda\n",
+    "1. Proszę zrobić te same kroki jak w poprzednim zadaniu\n",
+    "2. Proszę zrobić to co w punkcie 1. tylko, że przed usunięciem środowiska zapisać je do environment.yml, a po usunięciu odtworzyć"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/zajecia1/2_podstawy.ipynb b/zajecia1/2_podstawy.ipynb
new file mode 100644
index 0000000..9aa02b8
--- /dev/null
+++ b/zajecia1/2_podstawy.ipynb
@@ -0,0 +1,2911 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Podstawy języka Python\n",
+    "\n",
+    "&nbsp;\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "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": 7,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user1 = \"Alicja\"\n",
+    "user2 = \"Bartosz\"\n",
+    "user3 = \"Cecylia\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "user = \"jakub.pokrywka\"\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": 9,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hello Python!\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Hello Python!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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": 1,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "jakub\n",
+      "Użytkownik: jakub\n"
+     ]
+    }
+   ],
+   "source": [
+    "user = 'jakub'\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": 12,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "year = 2021\n",
+    "pi = 3.14159"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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,
+    "jupyter": {
+     "outputs_hidden": 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": 5,
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "j.pokrywka@amu.edu.pl\n"
+     ]
+    }
+   ],
+   "source": [
+    "username = 'j.pokrywka'\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": 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 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/zajecia1/zadania/.ipynb_checkpoints/zadanie_0-checkpoint.py b/zajecia1/zadania/.ipynb_checkpoints/zadanie_0-checkpoint.py
new file mode 100644
index 0000000..38d368e
--- /dev/null
+++ b/zajecia1/zadania/.ipynb_checkpoints/zadanie_0-checkpoint.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_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..0023ee9
--- /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 = "Jakub"
+surname = "Pokrywka"
+
+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..29767f2
--- /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!