{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block\" style=\"text-align: center; background-color: lightgrey; font-weight: bold;\">\n",
    "<h1> Algorytmy i programowanie </h1>\n",
    "<h2> <i>Podstawowe struktury danych: listy</i></h2> \n",
    "<h3></h3>\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listy\n",
    "\n",
    "Lista jest uporządkowaną oraz modyfikowalną sekwencją wartości, które mogą być dowolnego typu. Wartości te nazywamy elementami listy.\n",
    "\n",
    "Jedną z najprostszych metod utworzenia listy w Pythonie jest podanie jej elementów w nawiasach kwadratowych. Elementy te należy oddzielić przecinkami.\n",
    "\n",
    "Natomiast w celu wyświetlenia zawartości listy wystarczy zastosować funkcję `print()`, gdzie w miejsce argumentu tej funkcji wpisujemy nazwę listy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "['cyjan', 'magenta', 'żółty', 'czarny']\n"
     ]
    }
   ],
   "source": [
    "cyfry = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "kolory_cmyk = [\"cyjan\", \"magenta\", \"żółty\", \"czarny\"]\n",
    "print(cyfry)\n",
    "print(kolory_cmyk)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listę pustą deklarujemy poprzez `[ ]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "pusta_lista = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementami listy mogą być wartości dowolnego typu, w tym inne listy lub wyrażenia. Co więcej, elementy jednej listy mogą być różnych typów. Zatem dopuszczalne są następujące struktury."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['słowo', True, 3.14, 5, 'aaaaa', [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W celu dostępu do elementów listy używa się operatora w postaci nawiasów kwadratowych. Zatem składnia dostępu do elementu stojącego na pozycji `k` jest następująca: `nazwa_listy[k]`.\n",
    "Wyrażenie wewnątrz nawiasów określa indeks. Indeksy w listach w Pythonie zaczynają się od 0. Zatem `nazwa_listy[0]` zwraca pierwszy element tej listy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "słowo\n",
      "True\n",
      "3.14\n",
      "5\n",
      "aaaaa\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "print(roznosci[0])\n",
    "print(roznosci[1])\n",
    "print(roznosci[2])\n",
    "print(roznosci[3])\n",
    "print(roznosci[4])\n",
    "print(roznosci[5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jeżeli nie znamy indeksu ostatniego elementu w liście, możemy posłużyć się funkcją `len()`, która zwraca długość listy, czyli liczbę jej elementów. Wówczas ostatni element listy `lista` znajduje się w polu o indeksie `len(lista)-1`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ostatni element listy roznosci to: [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(\"Ostatni element listy roznosci to:\", roznosci[len(roznosci)-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listy są zmienne tzn. możemy zmieniać elementy z listy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['słowo', False, 3.14, 5, 'aaaaa', [1, 2, 3]]\n",
      "['słowo', False, 3.14, 5, 'aaaaa', 'brak listy']\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "roznosci[1] = False\n",
    "print(roznosci)\n",
    "\n",
    "roznosci[5] = \"brak listy\"\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W szczególności aby zamienić miejscami dwa pola listy, np. pola o indeksach \\\\\\(i\\\\\\) i \\\\\\(j\\\\\\), możemy wprowadzić pomocniczą zmienną \\(zwyczajowo nazywa się ją `temp` od słowa _temporary_\\), w której przechowujemy wartość pola listy, które zostaje nadpisane nową wartością znajdującą się w innym polu. To znaczy w pomocnicznej zmiennej zapisujemy wartość pola znajdującego się pod indeksem \\\\\\(i\\\\\\), następnie w to pole wpisujemy wartość pola znajdującego się pod indeksem \\\\\\(j\\\\\\). Gdybyśmy tego nie zrobili, po nadpisaniu stracilibyśmy informację o tym, co znajdowało się w polu o indeksie \\\\\\(i\\\\\\) i nie moglibyśmy wpisać tej wartości w pole o indeksie \\\\\\(j\\\\\\).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['słowo', False, 3.14, 5, 'aaaaa', 'brak listy']\n",
      "[False, 'słowo', 3.14, 5, 'aaaaa', 'brak listy']\n"
     ]
    }
   ],
   "source": [
    "print(roznosci)\n",
    "temp = roznosci[0]          # aby zamienić miejscami dwa pola listy wprowadzamy pomocniczą zmienną temp\n",
    "roznosci[0] = roznosci[1]\n",
    "roznosci[1] = temp\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Uwaga:** Każde wyrażenie będące liczbą całkowitą może być użyte jako indeks w liście. Należy jednak pamiętać, że podanie zbyt dużej liczby może wywołać błąd, \n",
    "jeśli lista nie będzie zawierała elementu o takim indeksie. Natomiast podanie liczby ujemnej jako indeks spowoduje obliczanie indeksu od końca listy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "słowo\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1,2,3]]\n",
    "print(roznosci[-1])\n",
    "print(roznosci[-6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Podstawowe operacje na listach\n",
    "\n",
    "Do list możemy stosować operator dodawania i mnożenia, które odpowiednio oznaczają konkatenację \\(czyli sklejenie\\) dwóch list oraz powtórzenie listy zadaną liczbę razy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[0, 1, 0, 1, 0, 1]\n"
     ]
    }
   ],
   "source": [
    "lista1 = [1, 2, 3] + [4, 5, 6]\n",
    "print(lista1)\n",
    "\n",
    "lista2 = [0, 1]*3\n",
    "print(lista2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy również pobrać wycinek listy i wyświetlić go lub przypisać w miejsce nowej zmiennej. W celu uzyskania wycinka listy należy użyć składni: `moja_lista[n:m]`, \n",
    "której wywołanie zwróci elementy listy `moja_lista` od pozycji o indeksie `n`, do pozycji o indeksie `m-1`. \n",
    "\n",
    "Co więcej, jeśli indeks przed dwukropiem nie zostanie podany, to automatycznie wycięcie nastąpi od pierwszego elementu w liście. Brak indeksu po dwukropku spowoduje zakończenie wycinania na ostatnim elemencie z listy. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, 3.14, 5]\n",
      "['słowo', True, 3.14, 5]\n",
      "[3.14, 5, 'aaaaa']\n",
      "[3.14, 5, 'aaaaa', [1, 2, 3]]\n",
      "['słowo', True, 3.14, 5, 'aaaaa', [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "print(roznosci[1:4])\n",
    "print(roznosci[:4])\n",
    "print(roznosci[2:-1])\n",
    "print(roznosci[2:])\n",
    "print(roznosci[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, False, 'Pi', [1, 2, 3], [4, 5]]\n"
     ]
    }
   ],
   "source": [
    "roznosci[1:3] = [False, \"Pi\"]\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W celu dodania lub usunięcia elementu z list w Pythonie zostały zostały stworzone odpowiednie **metody**. W Pythonie wszystkie zmienne są w rzeczywistości **obiektami**. \n",
    "Na przykład zmienna typu `int` jest w rzeczywistości obiektem klasy `int`. **Klasa** definiuje typ danych \\(i jego metody\\), natomiast obiekt jest instancją \\(przypadkiem\\) klasy.\n",
    "Najważniejsze co musimy na tym etapie wiedzieć o obiektach to to, że każdy obiekt składa się z danych oraz metod. \n",
    "\n",
    "Tak jest też w przypadku list. Danymi w tym wypadku jest sekwencja wartości. Każda lista jako obiekt ma również wiele metod, które wymienione są np. tutaj https://docs.python.org/3/tutorial/datastructures.html. \n",
    "Najważniejszymi na ten moment są metody: \n",
    "\n",
    "- `append()`, która dodaje element podany jako argument na koniec listy,\n",
    "- `pop()`, która usuwa z listy element stojący na pozycji podanej jako argument tej metody, zwraca ona usunięty element,\n",
    "- `remove()`, która usuwa element z listy, który został podany jako argument metody \\(argumentem musi być wartość elementu, a nie jego indeks\\).\n",
    "\n",
    "W celu wywołania danej metody używamy składni `nazwa_listy.nazwa_metody(argument)`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['słowo', True, 3.14, 5, 'aaaaa', [1, 2, 3], [4, 5]]\n",
      "[True, 3.14, 5, 'aaaaa', [1, 2, 3], [4, 5]]\n",
      "[True, 3.14, 'aaaaa', [1, 2, 3], [4, 5]]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "\n",
    "roznosci.append([4, 5])\n",
    "print(roznosci)\n",
    "roznosci.pop(0)           # można użyc print(roznosci.pop(0)) lub nowa_zmienna = roznosci.pop(0)\n",
    "print(roznosci)\n",
    "roznosci.remove(5)\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Istnieje również instrukcja `del`, która nie jest już metodą, ale jej działania jest podobne do `pop()`. Nie zwraca ona jednak żadnej konkretnej wartości  (dokładniej zwraca `None`), ale za to pozwala usuwać całe wycinki listy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, 3.14, 5, 'aaaaa', [1, 2, 3]]\n",
      "[True, 'aaaaa', [1, 2, 3]]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "\n",
    "del(roznosci[0])       nie wystarczy podać samego indeksu, bo to nie jest metoda\n",
    "print(roznosci)\n",
    "del(roznosci[1:3])\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Poruszanie się po listach\n",
    "\n",
    "Jednym ze sposobów na sprawdzenie po kolei wszystkich elementów danej listy jest użycie pętli `for`. Może nam się to przydać np. w momencie gdy chcemy wypisać po kolei elementy danej listy, każdy w kolejnej linii."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "słowo\n",
      "True\n",
      "3.14\n",
      "5\n",
      "aaaaa\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "for element in roznosci :\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n",
      "5\n",
      "aaaaa\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "for element in roznosci[2:] :\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Powyższe rozwiązanie sprawdza się w sytuacji, gdy musimy tylko odczytać elementy z listy. Natomiast jeśli chcemy ją zmodyfikować, to potrzebujemy przeglądania listy po indeksach. W takiej sytuacji potrzebna jest znajomość rozmiaru listy, którą uzyskuje się za pomocą przytoczonej już funckji `len()`. Przypomnijmy, że zwraca ona jako wartość liczbę elementów w liscie.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "print(len(roznosci))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kiedy znamy już rozmiar listy, to możemy do jej przejrzenia użyć instrukcji `while` w następujący sposób."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "słowo\n",
      "True\n",
      "3.14\n",
      "5\n",
      "aaaaa\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "i = 0\n",
    "while i < len(roznosci) :\n",
    "    print(roznosci[i])\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy wówczas dowolnie modyfikować listę, np. wpisując jakąś ustaloną wartość na pozycjach o indeksie nieparzystym."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['słowo', None, 3.14, None, 'aaaaa', None]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "i = 0\n",
    "while i < len(roznosci) :\n",
    "    if i % 2 == 1 :\n",
    "        roznosci[i] = None\n",
    "    i = i + 1\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jednak w sytuacjach, gdy kolejne iteracje pętli wykonywane są dla pewnej zmiennej, która w kolejnych iteracjach zmienia się w ten sam sposób (w powyższym przypadku zwiększa się o 1), \n",
    "stosuje się znacznie częściej instrukcję `for` w połączeniu z funkcją `range()`. Funkcję `range()` możemy wywołać w następujących konfiguracjach:\n",
    " - `range(stop)` zwraca ciąg liczb *0, 1, 2,... , stop-1*,\n",
    " - `range(start, stop)` zwraca ciąg liczb *start, start+1, start+2, ..., stop-1*,\n",
    " - `range(start, stop, step)` zwraca ciąg arytmetyczny liczb nieprzekraczających *stop* o wyrazie początkowym *start* i różnicy *step*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wypisywanie po kolei wszystkich elementów listy możemy zatem przeprowadzić w jeszcze inny sposób, tzn. tak jak poniżej."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "słowo\n",
      "True\n",
      "3.14\n",
      "5\n",
      "aaaaa\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "for i in range(len(roznosci)) :\n",
    "    print(roznosci[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy również łatwo zmodyfikować tylko elementy o nieparzystych indeksach bez użycia dodatkowej instrukcji `if`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['słowo', None, 3.14, None, 'aaaaa', None]\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "for i in range(1, len(roznosci), 2) :\n",
    "    roznosci[i] = None\n",
    "print(roznosci)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W miejsce trzeciego argumentu funkcji `range()` możemy również wstawiać liczby ujemne, co pozwala np. łatwo wyświetlić listę w odwrotnej kolejności."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "aaaaa\n",
      "5\n",
      "3.14\n",
      "True\n",
      "słowo\n"
     ]
    }
   ],
   "source": [
    "roznosci = [\"słowo\", True, 3.14, 2+3, \"a\"*5, [1, 2, 3]]\n",
    "for i in range(len(roznosci)-1, -1, -1) :\n",
    "    print(roznosci[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listy zagnieżdżone\n",
    "\n",
    "Zauważmy, że powyższe metody traktują listy będące elementami innej listy jako pojedyncze elementy. Co jednak jeśli mielibyśmy listę, której elementami są inne listy, i chcielibyśmy zmodyfikować elementy tych zagnieżdżonych list? Wówczas rozwiązaniem jest użycie pętli wewnątrz pętli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 \n",
      "0 0 0 \n",
      "-1 3 \n"
     ]
    }
   ],
   "source": [
    "A = [[1, 2, 3, 4], [0, 0, 0], [-1, 3]]\n",
    "for i in range(len(A)) :\n",
    "    for j in range(len(A[i])) :         # A[i] jest listą więc len() zwraca jej długość\n",
    "        print(A[i][j], end=\" \")         # A[i][j] zwraca element lężący na j-tej pozycji na liście A[i], czyli liście będącej i-tym elementem listy A\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Uwaga:** Funkcja `print()` domyślnie kończy wypisywanie swoich argumentów za pomocą przejścia do nowej linii. Jeśli chcemy to zmienić możemy użyć dodatkowego argumentu `end=\"znak_koncowy\"`\n",
    "który spowoduje, że podany `znak_koncowy` pojawi się po wypisaniu każdego elementu podanego w argumencie funkcji `print()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jak wczytywać listy?\n",
    "\n",
    "W wielu przypadkach będziemy chcieli stworzyć listę na podstawie danych podanych przez użytkownika lub wczytanych z pliku. Przyda nam się do tego metoda `split()`, która dzieli dany obiekt typu `string` tworząc z niego listę. Domyślnie elementy listy są od siebie odseparowane spacją."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['To', 'jest', 'przykładowy', 'tekst']\n"
     ]
    }
   ],
   "source": [
    "tekst = \"To jest przykładowy tekst\"\n",
    "nowa_lista = tekst.split()\n",
    "print(nowa_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcja `split()` umożliwia też dzielenie tekstu względem wybranego przez nas separtora, czyli znaku lub ciągu znaków, które mają oddzielać od siebie kolejne elementy listy. Wówczas podajemy ten seprator jako argument funkcji `split()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n"
     ]
    }
   ],
   "source": [
    "cyfry = \"0, 1, 2, 3, 4, 5, 6, 7, 8, 9\"\n",
    "cyfry_lista = cyfry.split(\", \")\n",
    "print(cyfry_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W powyższym przykładzie wczytany tekst zostaje zamieniony na listę elementów typu `string`. To oznacza, że każdy z elementów tak utworzonej listy jest tekstem. Gdybyśmy jednak chcieli uzyskać listę obiektów innego typu, np. listę liczb całkowitych, wówczas możemy zastosować poznaną już funkcję `int()`, która rzutuje obiekt typu `string` na obiekt typu `int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "cyfry = \"0, 1, 2, 3, 4, 5, 6, 7, 8, 9\"\n",
    "cyfry_lista = cyfry.split(\", \")\n",
    "for i in range(len(cyfry_lista)):\n",
    "    cyfry_lista[i] = int(cyfry_lista[i])\n",
    "print(cyfry_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nie jest to specjalnie elegancki sposób wczytania i przekonwertowania danych. Możemy zrobić to prościej.  Aby wykonać jednoczesne rzutowanie wszystkich elementów listy posłużymy się funkcją `map()`, która przyjmuje dwa argumenty: funkcję `funkcja` i obiekt iterowalny `kolekcja_danych` (np. listę), a następnie stosuje funkcję `funkcja` do wszystkich elementów obiektu `kolekcja_danych`. Musimy jeszcze zastosować do wyniku tej operacji funkcję `list()`, która wyprodukuje nam końcową listę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "cyfry = \"0, 1, 2, 3, 4, 5, 6, 7, 8, 9\"\n",
    "cyfry_lista = list(map(int, cyfry.split(\", \")))\n",
    "print(cyfry_lista)"
   ]
  },
  {
   "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": []
  },
  {
   "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": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}