Warsztat 1-02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warsztat 2 - typy i struktury danych<a id=top></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font size=2>Przed pracą z notatnikiem polecam wykonać kod w ostatniej komórce (zawiera html i css), dzięki czemu całość będzie bardziej estetyczna :)</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Cały warsztat będzie poświęcony typom i strukturom danych, które są podstawowymi magazynami informacji dla Pythona."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#Typy-danych'>Typy danych</a>\n",
    "<ol>\n",
    "<li><a href='#Typ-tekstowy'>Typ tekstowy</a></li>\n",
    "<li><a href='#Typ-całkowity'>Typ całkowity</a></li>\n",
    "<li><a href='#Typ-zmiennoprzecinkowy'>Typ zmiennoprzecinkowy</a></li>\n",
    "<li><a href='#Typ-logiczny'>Typ logiczny</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#Struktury-danych'>Struktury danych</a>\n",
    "<ol>\n",
    "<li><a href='#Listy'>Listy</a></li>\n",
    "<li><a href='#Słowniki'>Słowniki</a></li>\n",
    "<li><a href='#Krotki'>Krotki</a></li>\n",
    "<li><a href='#Zestawy'>Zestawy</a></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typy danych "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Przejdziemy teraz przez podstawowe typy danych dostępne w Pythonie. Dzięki nim, będzie możliwe przechowywanie (prawie) wszystkich informacji, jakie mogą okazać się potrzebne. Python nie wymaga dosłownego deklarowania typu zmiennej podczas jej tworzenia (co pojawia się w niektórych językach programowania), ale wynika ze sposobu wprowadzania informacji (użycie cudzysłowu, liczba ze znakiem oddzielającym część całkowitą od ułamkowej).<br><br>\n",
    "Należy jednak pamiętać, że typ danych ciągle ma ogromne znaczenie podczas wykonywania programu i często mogą pojawić się błędy powiązane z próbą wykonania operacji niezgodnych z typem danej zmiennej (np. dzielenie jednej zmiennej tekstowej przez drugą). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Typ tekstowy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pierwszym podstawowym typem danych jest zmienna przechowująca dane tekstowe (z ang. string). Jak sama nazwa wskazuje, będzie można zapisać w niej dowolny ciąg znaków, który będzie traktowany przez Pythona jak zwykły tekst. Można będzie w nim zapisać praktycznie dowolny znak używany na świecie do tworzenia tekstów. Jest to możliwe dzięki implementacji w Pythonie kodowania Unicode. Sam Python bazuje na alfabecie łacińskim, więc z jego zapisem nie ma najmniejszego problemu. Wykorzystanie innych znaków (np. polskich znaków diakrytycznych, alfabetów niełacińskich) wymaga jednak dodatkowych operacji. Po więcej szczegółów warto jest zajrzeć do <a href='https://docs.python.org/2/howto/unicode.html'>oficjalnego poradnika Pythona</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"mój tekst\"\n",
    "string "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Żeby upewnić się, jakiego typu jest dana zmienna, możemy wykorzystać funkcję <b>type( )</b>, która wypisze na konsoli interesującą nas informację."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pewnym problemem, może okazać się sytuacja, kiedy będziemy chcieli w zmiennej tekstowej użyć znaku cudzysłowu lub apostrofu. Najprostszym rozwiązaniem jest użycie do tego drugiego możliwego symbolu do tworzenia stringów. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_cu = 'Oto \"słowo\" w cudzysłowie.'\n",
    "print (string_cu)\n",
    "string_apo = \"Tutaj zdanie z apo'strofem.\"\n",
    "print (string_apo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bardziej uniwersalnym podejściem będzie użycie znaku <b>\\</b> przed symbolem, który chcemy wstawić, dzięki czemu interpreter Pythona wie, że należy ten element traktować jako zwykły znak graficzny a nie symbol tworzący zmienną tekstową. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_all = \"Tutaj mamy zarówno \\\"cudzysłów\\\" jak i apo\\'strof\"\n",
    "print (string_all) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tym samym sposobem możemy wstawić inne nietypowe znaki do danej tekstówej. Możecie je znaleźć pod tym <a href=\"https://docs.python.org/2.0/ref/strings.html\">linkiem</a>.<br>\n",
    "Najbardziej przydatne będą jednak znaki na nową linię <b>\\n</b> oraz wcięcie <b>\\t</b>. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"linia pierwsza\\nlinia druga \\ti wcięcie\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możliwe jest szybkie łączenie dwóch stringów poprzez użycie operatora + (niestety, z innych operacji artymetycznych działa jeszcze mnożenie, reszta jest niedostępna dla zmiennych tekstowych). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string2 = ' taki długi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (string+string2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (string * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stringi można też sprawnie dzielić na mniejsze części za pomocą metody <b>.split( )</b>. W swojej podstawowej wersji dzieli tekst według spacji i z każdej części tworzy kolejne elementy jednej listy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print (string_all.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jeśli podamy mu jako argument inny znak czy string, metoda podzieli wskazany string wedle niego."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (string_all.split('a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Kodowanie znaków niestandardowych "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poniżej możemy zobaczyć przykład stringu zakodowanego w Unicode, który Python będzie w stanie poprawnie wyśwetlić jako pismo japońskie (wymieszane wszystkie 3 istniejące tam alfabety). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (u'\\u306f\\u6700\\u9ad8\\u306e\\u30d7\\u30ed\\u30b0\\u30e9\\u30de')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tabelę z kodami dla poszczególnych znaków można znaleźć <a href='http://unicode-table.com/en/'>na przykład tutaj</a>.<br>\n",
    "Wygodnym rozwiązaniem może być też wpisanie odpowiednich znaków bezpośrednio do kodu (należy jednak pamiętać, że może on nie być czytelny dla innych użytkowników oraz do jego zobaczenia użytkownik końcowy musi posiadać adekwatne czcionki).<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print ('は最高のプログラマ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Typ całkowity "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ty całkowity (ang. integer), służy do przechowywania liczb całkowitych (zarówno dodatnich jak i ujemnych). Choć oczywiście zmienne tego typu mogą służyć do wykonywania obliczeń matematycznych, wykorzystywane są również np. do indeksowania zawartości różnych struktur danych czy do iteracji (wykonywania jakiejś operacji określoną ilość razy).<br>\n",
    "Poniżej jeszcze raz możemy zobaczyć jak tworzy się zmienne liczbowe typu całkowitego, razem ze sposobami ich pokazania na konsoli. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cyfra = 6\n",
    "liczba = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (cyfra)\n",
    "print (liczba)\n",
    "print (cyfra, liczba)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (cyfra+liczba)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (cyfra/liczba)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W kontekście indeksowania i iteracji, bardzo często wykorzystuje się funkcję <b>range()</b>, dzięki której możemy tworzyć ciągli liczb całkowitych (przechowywanych w formie listy).<br>\n",
    "Składnia:<br>\n",
    "range(liczba1) &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;- tworzy ciąg od 1 do liczba1<br>\n",
    "range(liczba1, liczba2) &emsp;&emsp;&emsp; &emsp; &emsp; - tworzy ciąg od liczba1 do liczba2<br>\n",
    "range(liczba,1, liczba2, liczba3) &emsp;&emsp; - tworzy ciąg od liczba1 do liczba2, wybierając kolejne liczby w odstępie liczba3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(3,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(3,20,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Typ zmiennoprzecinkowy "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Innym typem liczbowym jest typ zmiennoprzecinkowy, który razem z częścią całkowitą zawiera w sobie część ułamkową liczby. Szczególnie przy liczbach zawierających dużo cyfr (zarówno bardzo dużych liczbach całkowitych czy liczb zmiennoprzecinkowych o długim rozwinięciu dziesiętnym) należy pamiętać, że są one przechowywane w pamięci komputera z określoną dokładnością np. 32 bitów. Dzięki czemu nie zawsze będą one idealnie odwzorowane, ale tylko do pewnego stopnia przybliżone<br>\n",
    "Dla przykładu, <b>liczba 2.675</b> będzie wyłącznie zaokrągleniem do 3 miejsca po przecinku liczby, która jest bardzo blisko, ale jednak różna od 2.675 (wynika to ze specyfiki zapisu binarnego liczb - poprawnie reprezentowane będą tylko wielokrotności potęg dwójki, np. $0.5 = 2^{-1}$). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from decimal import Decimal\n",
    "Decimal(2.675)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dlatego też zaokrąglenie liczby 2.675 do drugiego miejsca po przecinku da 2.67 a nie 2.68 (jak powinno być zgodnie z konwencją matematyczną), ponieważ w istocie nasza liczba jest odrobinę mniejsza, więc zaokrąglana jest w dół. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(2.675,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python rozpoznaje automatycznie typ zmiennej liczbowej podczas jej tworzenia. Automatycznie również zachodzi proces konwersji typu integer do float, kiedy próbujemy wykonać operacje na obu tych typach naraz.<br>\n",
    "Poniżej możemy zobaczyć jak wynikiem działania z oboma typami są obiekty typu zmiennoprzecinkowego (bo integer może być zamieniony bezstratnie na float, ale w drugą stronę już nie jest to możliwe)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flot = 2.\n",
    "intek = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (flot+intek)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (flot/intek)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (flot//intek)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Typ logiczny "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zmienne typu logicznego przechowują wartości zgodne z zasadami klasycznego rachunku zdań (prawda, fałsz lub pusty zbiór). Podobnie jak w KRZ (Klasycznym rachunku zdań), możliwe jest wykonywanie na tych zmiennych operacji zebranych w formie <a href=\"https://pl.wikipedia.org/wiki/Algebra_Boole%E2%80%99a\">Algebry Boole'a</a>.<br>\n",
    "Podstawowe operacje dostępne dla zmiennych logicznych: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Operacja | Symbol |\n",
    "|:-:|:-:|\n",
    "| Suma | or, l |\n",
    "| Iloczyn | and, & |\n",
    "| Negacja | not | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "logika = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not logika"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " True and False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zmienne logiczne same w sobie nie są przesadnie interesujące, stanowią jednak podstawę wszystkich metod porównujących inne zmienne czy oceniających przebieg operacji w programie. Będzie można za ich pomocą np. sterować przebiegiem programu w zależności od spełnienia określonych warunków (zwracających wartość True)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Struktury danych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listy tworzymy poprzez nawiasy kwadratowe [ ].<br>\n",
    "Lista jest uporządkowaną strukturą danych - posiada element początkowy i określoną kolejność pozostałych elementów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = ['jeden','dwa','trzy','cztery']\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dzięki posiadaniu uporządkowania, można dotrzeć do każdego elementu listy podając numer jego indeksu.<br>\n",
    "Należy przy tym pamiętać, że w większości przypadków w Pythonie indeks <b>zaczyna się od 0</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (lista[0])\n",
    "print (lista[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeksowanie może odbywać się również w kierunku odwrotnym za pomocą indeksów ujemnych.<br>\n",
    "Wtedy pierwszy element od końca będzie miał <b>indeks -1</b> (indeks 0 jest już bowiem zarezerwowany)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (lista[-1])\n",
    "print (lista[-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lista może się składać z elementów dowolnego typu (które zachowują swój typ):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_random = ['jeden', 2, 3.0, True]\n",
    "print (lista_random)\n",
    "print (type(lista_random[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Co więcej, elementem listy może być inna lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista2 = ['one','two','three','four']\n",
    "lista3 = [lista, lista2]\n",
    "print (lista3)\n",
    "print (type(lista3[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zagnieżdżanie list nie blokuje możliwości dotarcia do poszczególnych elementów znajdujących się wewnątrz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (lista3[1][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Ciekawostka</b>: zmienne tekstowe zachwoują się bardzo podobnie do list - de facto są to listy pojedynczych znaków."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (lista3[1])\n",
    "print (lista3[1][0])\n",
    "print (lista3[1][0][2])\n",
    "print (type(lista3[1][0][2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Widzimy, że string składa się z ciągu mniejszych stringów - pojedynczych liter.<br>\n",
    "Możemy wymusić na pythonie zamianę stringa na prawdziwą listę za pomocą funkcji <b>list( )</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (list(lista[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listy można \"ciąć\" w taki sposób, żeby wybrać tylko interesujące elementy. Dzieje się to, kiedy zamiast pojedynczego indeksu podamy cały zakres.<br>\n",
    "Konwencja jest następująca [początek : koniec : krok]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cyfr=list(range(10))\n",
    "print (lista_cyfr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cyfr[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kiedy zostawimy puste miejsce, zostanie ono uzupełnione przez element skrajny (pierwszy albo ostatni element listy)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cyfr[6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cyfr[:-6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trzecia wartość - \"krok\", pozwala wybierać elementy nie po kolei, ale np. co drugi, trzeci itp."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cyfr[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funkcje list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Istnieje pewna grupa funkcji przeznaczona do pracy z listami (a więc także ze zmiennymi tekstowymi).<br>\n",
    "Używa ich się poprzez przywołanie ich razem z nazwą listy w nawiasie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>len( )</b> - pozwala określić długość listy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (len(lista_cyfr))\n",
    "print (len(lista))\n",
    "print (lista[0])\n",
    "print (len(lista[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>min( ) i max( )</b> pozwalają znaleźć najmniejszy i największy element w liście"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (min(lista_cyfr))\n",
    "print (max(lista_cyfr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To samo możemy wykonać dla listy tekstowej, wtedy funkcje zwrócą elementy o najniższej i najwyżej wartości znaku w kodowaniu ASCII.<br> W przypadku, kiedy pierwsze litery będą identyczne, pod uwagę zostaną wzięte znaki numer dwa, potem trzy itd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (min(lista))\n",
    "print (max(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Czasem chcielibyśmy jednak wiedzieć, który element listy jest najdłuższy (ma najwięcej znaków).<br> Jest to możliwe poprzez dodanie parametru <b>key=len</b> do poszczególnych funkcji (działa wyłącznie z obiektami tekstowymi)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (min(lista, key=len))\n",
    "print (max(lista, key=len))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W miejscu <b>len</b> może pojawić się dowolna funkcja wbudowana w pythona albo stworzona przez użytkownika."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W celu połączenia dwóch list w jedną (ale bez zagnieżdżania) możemy użyć operatora <b>+</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (lista + lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcja <b>count( )</b> umożliwa podliczenie ile danego typu elementów znajduje się w liście."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.count('jeden')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jeśli chcemy ustalić wartość indeksu danego elementu listy, możemy do tego użyć funkcji <b>index( )</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.index('trzy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dodawanie i odejmowanie elementów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = ['jeden','dwa','trzy','cztery']\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dodanie elementu do listy może się odbyć za pomocą funkcji <b>append(  )</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.append('five')\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W ten sposób można dołączyćdo listy dowolny element, tekst, liczbę, wartość logiczną, ale również inną listę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.append(lista2)\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jeśli jednak nie chcemy zagnieżdżać drugiej listy w pierwszej, możemy użyć funkcji <b>extend( )</b>, która połączy nam dwie listy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.extend(lista2)\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możliwe jest także wsunięcie nowego elementu pomiędzy te, które już istnieją w liście.<br> W tym celu posługujemy się funkcją <b>insert(x,y)</b>, gdzie x jest równe docelowemu indeksowi, y natomiast to element, który chcemy dodać do listy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.insert(0, \"zero\")\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Powyższa funkcja dodaje element pod wskazanym adresem, przesuwając dotychczasowy i następne elementy o jeden indeks wyżej. Żeby zmienić element na nowy, bez jakiegokolwiek przesuwania, możemy bezpośrednio zmodyfikować wartość danego elementu listy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista[0]=\"inne zero\"\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcja <b>pop( )</b> służy usuwaniu ostatniego elementu znajdującego się w liście. Jeśli jednak w nawiasie wpiszemy wartość istniejącego indeksu to wyrzucimy z listy element o tym indeksie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.pop()\n",
    "print (lista)\n",
    "lista.pop(1)\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jeśli znamy wartość elementu do usunięcia, ale nie znamy jego indeksu, możemy użyć funkcji <b>remove( )</b>.<br> Jeśli dany element pojawia się więcej niż raz w liście, usunięty zostanie ten o najniższym indeksie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.remove(\"trzy\")\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kolejną metodą na usuwanie elementów listy jest funkcja <b>del</b>.<br> Wykorzystywana jest tutaj metoda slicingu, dzięki czemu możemy usunąć z listy więcej niż jeden element na raz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del lista[2:]\n",
    "print (lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Organizacja listy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możliwe jest odwrócenie kolejności elementów w liście za pomocą funkcji <b>reverse( )</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_cyfr.reverse()\n",
    "print (lista_cyfr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Komenda <b>sort( )</b> powoduje uporządkowanie elementów w kolejności rosnącej.<br>\n",
    "Dodanie w nawiasie parametru reverse=True spowoduje sortowanie od nawiększej do najmniejszej wartości."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista2.sort()\n",
    "print (lista2)\n",
    "lista2.sort(reverse=True)\n",
    "print (lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do sortowania możemy także użyć innych parametrów (np. wykrzystanego wcześniej len)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista2.sort(key=len)\n",
    "print (lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kopiowanie listy powinno się odbywać poprzez przypisanie do nowej zmiennej wszystkich wartości starej zmiennej listowej.<br>\n",
    "Zwykłe przypisanie listy do nowej zmiennej nie wykona kopii a jedynie \"wskaźnik\" - odwołanie do oryginalnej listy.<br><br>\n",
    "zatem: lista3 = lista2 to nie jest dobre rozwiązanie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (lista2)\n",
    "lista3 = lista2\n",
    "lista2.pop()\n",
    "print (lista3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista3 = lista2[:]\n",
    "lista2.pop()\n",
    "print (lista3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenia z list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stwórz pustą listę \"walizka\". Do walizki włóż koszulę, skarpety, poster, liczbę 43 oraz prawdopobieństwo równe 0.01.<br>\n",
    "Dodaj jeszcze przedział ufności 0.95 oraz Prawdę.<br>\n",
    "Stwórz pustą listę \"bagaznik\".<br>\n",
    "Do bagażnika włóż walizkę, buty trekkingowe, styropian i śledzie.<br>\n",
    "Upewnij się, że bagażnik znajduje się w samochodzie. We wnętrzu samochodu powinien być również promotor, teściowa i Puszek. Idąc za głosem rozsądku podmień Puszka na transporter, w którym znajduje się Puszek, karma oraz pluszowy szczur. Upewnij się, że wnętrze trasportera jest uporządkowane.<br>\n",
    "Rozmyśl się i wyrzuć w walizki trzeci przedmiot. Za to w bagażniku jako drugi element ustaw walizkę promotora. Niech ma.<br>\n",
    "Dodaj do wnętrza samochodu płytę z największymi przebojami Krzysztofa Krawczyka. Następnie wydrukuj na konsoli widok całego pojazdu.<br>\n",
    "Dopiero teraz zauważ, że Ciebie tam nie ma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za pomocą funkcji range( ), utwórz listę pierwszych 100 liczb całkowitych i przypisz ją do zmiennej 'liczby'.<br>\n",
    "Wypisz na konsolę siódmy element tej listy oraz trzynasty element od końca.<br>\n",
    "Z listy 'liczby' wybierz tylko te elementy, które dzielą się przez 3 i zapisz je w zmiennej 'liczby3'.<br>\n",
    "Z listy 'liczby' wybierz tylko te elementy, które dzielą się przez 7 i zapisz je w zmiennej 'liczby7'.<br>\n",
    "Wypisz na konsolę najmniejszy element 'liczby3' i największy 'liczby7'.<br>\n",
    "Wypisz na konsolę różnicę pomiędzy ilością liczb podzielnych przez 3 i 7.<br><br>\n",
    "\n",
    "Nadpisz zmienną 'liczby7' jej odwrotnością. Następnie odjemij od 3 elementu tej listy 5 element listy 'liczby3' i wypisz wynik na konsoli.<br>\n",
    "Teraz połącz obie listy, zapisując je pod zmienną 'liczby37'. Nowoutworzoną listę posortuj.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Słowniki"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Słownik jest strukturą danych, w której każdy element (ang. value) ma swój indeks (lub klucz, ang. key), dzięki czemu całość zorganizowana jest w formie danych połączonych w pary.<br>\n",
    "Inicjujemy słownik, albo poprzez puste nawiasy { }, albo przez funkcję dict( )."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "slownik = {}\n",
    "slownik2 = dict()\n",
    "print (slownik, slownik2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Słownik ma następującą postać <b>{ 'klucz' : wartość }</b>; do jego utworzenia możemy użyć jednego z kilku sposobów.<br>\n",
    "Należy przy tym zwrócić uwagę, że słownik jest strukturą nieuporządkowaną, dlatego poszczególne pary nie posiadają numerycznego indeksu (jak listy), natomiast zorganizowane są według kluczy (za pomocą których możemy dotrzeć do konkretnych wartości). Oznacza to też, że python może wyświetlać elementy słownika w dowolnej kolejności."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = dict(one=1, two=2, three=3)\n",
    "b = {'one': 1, 'two': 2, 'three': 3}\n",
    "c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))\n",
    "d = dict([('two', 2), ('one', 1), ('three', 3)])\n",
    "e = dict({'three': 3, 'one': 1, 'two': 2})\n",
    "\n",
    "print (a,'\\n',b,'\\n',c,'\\n',d,'\\n',e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Można także dodawać pozycje do słownika pojedynczo, bezpośrednio wskazując klucz i wartość mu przypisaną. Tym samym sposobem można nadpisywać wartość przypisaną do klucza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "slownik['jeden']=1\n",
    "print (slownik)\n",
    "slownik['jeden']=2\n",
    "print (slownik)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "slownik['dwa']=3\n",
    "slownik['trzy']=4\n",
    "slownik['cztery']=5\n",
    "slownik['piec']=6\n",
    "print (slownik)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W celu wypisania wszystkich wartości zapisanych w słowniku, używamy metody <b>values( )</b>.<br>\n",
    "Analogicznie, metoda <b>keys( )</b> wyświetli nam wszystkie dostępne klucze."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (slownik.values())\n",
    "print (slownik.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda <b>items( )</b> zwróci natomiast listę par klucz-wartość."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (slownik.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobnie jak przy listach, metoda <b>pop( )</b> usunie nam parę klucz-wartość poprzez podanie w nawiasie odpowiedniego klucza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "slownik.pop('dwa')\n",
    "print (slownik)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (slownik)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z kolei metoda <b>clear( )</b> usunie ze słownika wszystkie elementy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "slownik.clear()\n",
    "print (slownik)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='#top' style='float: right; font-size: 13px;'>Do początku</a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenia ze słowników"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stwórz słownik \"ksiegarnia\".<br>\n",
    "Niech zawiera na początku trzy pozycje (klucze) we wskazanych ilościach (wartości):<br>\n",
    "Trainspotting - sztuk 19;<br>\n",
    "Mahabharata - sztuk 10;<br>\n",
    "Hobbit - sztuk 30.<br>\n",
    "Zorientuj się, że Hobbit dotarł w specjalnej trzytomowej wersji, więc jest go tak naprawdę 3 razy mniej. Popraw zapisaną ilość sztuk tej pozycji.<br>\n",
    "Wypisz na konsoli zsumowaną ilość wszystkich książek.<br>\n",
    "Uznaj, że brakuje książek naukowych, dodaj do księgarni pozycję '50 odcieni Gleju' - 20 sztuk.<br>\n",
    "Odbierz telefon od ministerstwa kultury, które żąda spisu wszystkich sprzedawanych książek. Ich listę zapisz w zmiennej 'jeszcze_legalne'.<br>\n",
    "Odbierz drugi telefon z ministerstwa niedługo później. W konsekwencji opróżnij księgarnię."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Krotki "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Krotka (ang. tuple) jest bardzo podobnym konstruktem do listy. Kluczową różnicą jest tutaj <b>niemodyfikowalność</b> krotek, które raz stworzone, nie będą mogły mieć modyfikowanej zawartości.<br>\n",
    "Tworzenie krotki polega na umieszczeniu dowolnych elementów w zwykłych nawiasach. Same elementy powinny być od siebie oddzielone przecinkami. Jeśli chcemy stworzyć krotkę o tylko jednym elemencie, musimy umieścić po nim przecinek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "krotka = (1, 'jeden', False)\n",
    "print (krotka)\n",
    "print (type(krotka))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy też przekształcić listę w krotkę za pomocą funkcji <b>tuple( )</b>. Oczywiście możliwa jest też operacja odwrotna za pomocą poznanej wcześniej funkcji **list( )**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista =[1,2,3,4,5,6,7]\n",
    "print (tuple(lista))\n",
    "print (list(tuple(lista)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Krotki będą zatem przydatne, jeśli chcemy mieć pewność, że raz stworzony zbiór danych nie zostanie przypadkiem zmodyfikowany podczas działania programu.<br>\n",
    "Ważnym miejscem wykorzystywania krotek jest wywoływanie funkcji (w ten sposób do funkcji będą przekazywane argumenty). Często też różne funkcje będą zwracać krotki jako efekt swojego działania. Szczególnie, jeśli zwracany będzie zbiór różnych elementów rozdzielonych przecinkami, to całość zostanie domyślnie zinterpretowana jako krotka."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poza wskazanymi powyżej różnicami, krotki podobnie jak listy są uporządkowane, zatem można dotrzeć do ich elementów wykorzystując indeksy. Działa również slicing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "krotka=tuple(lista)\n",
    "print (krotka[4])\n",
    "print (krotka[2:5])\n",
    "print (krotka[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Choć modyfikacja krotek jest niemożliwa, możemy tworzyć nowe krotki przy użyciu już istniejących (a także slicingu)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "krotka2 = krotka + krotka\n",
    "krotka3 = krotka[::2] + krotka[::3]*2\n",
    "print (krotka2)\n",
    "print (krotka3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zestawy "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zestaw (ang. set) jest specjalnym typem listy, którego cechą charakterystyczną jest <b>niepowtarzalność</b> elementów. Oznacza to, że wszelkie dodatkowe wystąpienia tego samego elementu początkowego zostaną usunięte podczas tworzenia zestawu.<br>\n",
    "Do utworzenia zestawu będziemy używać nawiasów klamrowych <b>{ }</b> albo funkcji <b>set( )</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = {'q','w','e','r','t','y','u','i','o','p'}\n",
    "z = set([9,8,7,6,5,4,3,2,1,2,3,4,5,6,7,8,9])\n",
    "print (y, z)\n",
    "print (type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Widzimy też od razu, że całość zestwu jest uporządkowana alfabetycznie, przez co kolejność wprowadzania elementów do zestwu nie ma żadnego znaczenia. Dlatego też zestawy nie posiadają indeksowania i związanych z tym możliwości wyboru elementów. Możemy oczywiście wydrukować na konsoli całą zawartość zestawu, ale możemy także sprawdzać obecność elementu w zestawie za pomocą operatora <b>in</b> (co możliwe jest również dla list, krotek i kluczy w słownikach)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 in z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zestawy sprawdzają się dobrze do porównywania grup elementów, łączenia ich i porządkowania.<br>\n",
    "Zobaczmy jak to działa na przykładzie dwóch list gości z popularnych krakowskich klubów."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "goscie_prozac = {'Albert', 'Renata', 'Roman', 'Jessica', 'Karol', 'Norbert', 'Maria'}\n",
    "goscie_frantic = {'Norbert', 'Renata', 'Albert', 'Jessica', 'Maria', 'Karol', 'Tomasz'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sprawdźmy najpierw, które osoby mogą wejść na obie imprezy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "goscie_prozac.intersection(goscie_frantic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy też wyłuskać osoby, które mają prawo wstępu tylko na jedną z tych imprez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "goscie_frantic.symmetric_difference(goscie_prozac)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na koniec możemy stworzyć własną listę zbiorczą gości i wpuszczać na naszą imprezę tylko tych, którzy są tolerowani przez inne kluby."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nasi_goscie=goscie_frantic.union(goscie_prozac)\n",
    "print (nasi_goscie)\n",
    "print ('Marcin' in nasi_goscie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\r\n",
       "@import url(http://fonts.googleapis.com/css?family=Titillium+Web:400,700,800,400italic&subset=latin-ext,latin);\r\n",
       "@import url(http://fonts.googleapis.com/css?family=Anonymous+Pro:400,700,800,400italic&subset=latin-ext,latin);\r\n",
       "\r\n",
       ".filename {\r\n",
       "    font-family: Titillium Web;\r\n",
       "    font-variant: small-caps;\r\n",
       "    letter-spacing: 0.1em;\r\n",
       "}\r\n",
       "\r\n",
       "b {\r\n",
       "    color: #cc0000;\r\n",
       "}\r\n",
       "\r\n",
       "em {\r\n",
       "    color:#0000cc;\r\n",
       "}\r\n",
       "\r\n",
       "ul {\r\n",
       "\tlist-style-type: square !important;\r\n",
       "}\r\n",
       "\r\n",
       ".rendered_html ul li {\r\n",
       "\tfont-size: 8px;\r\n",
       "}\r\n",
       "\r\n",
       "li span {\r\n",
       "\tfont-size: 14px;\r\n",
       "}\r\n",
       "\r\n",
       "/* tekst w markdown */\r\n",
       ".rendered_html {\r\n",
       "    font-family: Titillium Web, serif;\r\n",
       "    }\r\n",
       "\r\n",
       ".rendered_html p {\r\n",
       "    font-size: 16px;\r\n",
       "    text-align: justify;\r\n",
       "    text-decoration: none;\r\n",
       "    }\r\n",
       "\r\n",
       ".rendered_html :link {\r\n",
       "    text-decoration: none;\r\n",
       "    }\r\n",
       "\r\n",
       ".rendered_html :visited {\r\n",
       "    text-decoration: none;\r\n",
       "    }\r\n",
       "    \r\n",
       "/* tekst w code cell */\r\n",
       ".code_cell {\r\n",
       "    font-family: Anonymous Pro, monospace;\r\n",
       "    font-size: 14px;\r\n",
       "    }\r\n",
       "\r\n",
       "code, pre, .CodeMirror {\r\n",
       "    font-family: Anonymous Pro, monospace;\r\n",
       "    font-size: 14px;\r\n",
       "}\r\n",
       "\r\n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "from urllib.request import urlopen\n",
    "HTML(urlopen(\"https://raw.githubusercontent.com/mkoculak/Warsztat-programowania/master/ipython.css\").read().decode(\"utf-8\"))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}