zajecia/dzien2_czesc1_sterowanie_i_kolekcje.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sterowanie skryptem i kolekcje\n",
    "\n",
    "Julian Zubek, 2015, [DELab UW](http://www.delab.uw.edu.pl/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instrukcje warunkowe\n",
    "\n",
    "Nie wszystkie instrukcje w przepisie kulinarnym wykonuje się za każdym razem tak samo; czasem przepis zawiera wskazówki postępowania w konkretnych sytuacjach, np:\n",
    "\n",
    "    Jeśli potrawka zrobiła się zbyt gęsta, dolej wody.\n",
    "    \n",
    "W Pythonie taką rolę pełnią instrukcje warunkowe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "if a > 0:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Słowo dłuższe niż 8 znaków.\n"
     ]
    }
   ],
   "source": [
    "t = \"defenestracja\"\n",
    "if len(t) > 8:\n",
    "    print(\"Słowo dłuższe niż 8 znaków.\")\n",
    "else:\n",
    "    print(\"Słowo krótsze niż 8 znaków.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kolejny tydzień pracy...\n",
      "Weekend!\n",
      "Weekend już niedługo.\n",
      "Weekend już niedługo.\n"
     ]
    }
   ],
   "source": [
    "def kiedy_weekend(dzien):\n",
    "    if dzien == \"sobota\" or dzien == \"niedziela\":\n",
    "        print(\"Weekend!\")\n",
    "    elif dzien == \"poniedziałek\":\n",
    "        print(\"Kolejny tydzień pracy...\")\n",
    "    elif dzien == \"wtorek\":\n",
    "        print(\"Uff, przynajmniej poniedziałek za nami.\")\n",
    "    elif dzien == \"środa\":\n",
    "        print(\"Już środek tygodnia...\")\n",
    "    else:\n",
    "        print(\"Weekend już niedługo.\")\n",
    "        \n",
    "kiedy_weekend(\"poniedziałek\")\n",
    "kiedy_weekend(\"sobota\")\n",
    "kiedy_weekend(\"piątek\")\n",
    "\n",
    "kiedy_weekend(\"szabat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenie\n",
    "\n",
    "Trener uniwersyteckiej drużyny koszykówki przeprowadza rekrutację nowych zawodników. Przeprowadza wstępną selekcję na podstawie danych z ankiety personalnej zawierającej następujące pola:\n",
    "* imię\n",
    "* wzrost\n",
    "* waga\n",
    "* kolor oczu\n",
    "\n",
    "Dane o zawodnikach znajdują się w pliku \"koszykarze.csv\" (wczytujemy go do pamięcy przy pomocy pandas.read_csv). Sprawdź, czy pierwszy z kandydatów spełnia podstawowe kryteria. Jeśli ma wzrost powyżej 180 cm i BMI pomiędzy 18 a 30, wypisz jego nazwisko. Dodatkowo, jeśli ma niebieskie oczy, wypisz przy nazwisku wykrzyknik \"!\". Jeśli nie spełnia kryteriów wzrostu i BMI, wypisz jedynie pojedynczy symbol dywizu \"-\" (niezależnie od koloru oczu).\n",
    "\n",
    "$$BMI = \\frac{waga}{wzrost^2}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Jan Kowalski', 78, 190, 'brązowe')"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = pd.read_csv(\"../dane/koszykarze.csv\")\n",
    "\n",
    "(data[\"imię\"][0], data[\"waga\"][0], data[\"wzrost\"][0], data[\"kolor oczu\"][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ćwiczenie\n",
    "\n",
    "Zaimplementuj funkcję Ackermanna:\n",
    "\n",
    "<img src=\"grafika/ackermann.png\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pętle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Pętla for\n",
    "\n",
    "Nieraz zdarza się, że ten sam zestaw instrukcji trzeba powtórzyć wielokrotnie, dla różnych składników. Przykładowo:\n",
    "\n",
    "    Cebulę, marchew i paprykę pokrój w kostkę. Następnie podsmaż każdy z tych składników\n",
    "    osobno na patelni.\n",
    "   \n",
    "W składni Pythona, zakładając że mamy zdefiniowane odpowiednie zmienne i funkcje, moglibyśmy to zapisać w następujący sposób:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pokroj(cebula)\n",
    "pokroj(marchew)\n",
    "pokroj(papryka)\n",
    "\n",
    "podsmaz(cebula)\n",
    "podsmaz(marchew)\n",
    "podsmaz(papryka)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zauważmy, że operacje wykonywane na różnych warzywach są od siebie całkowicie niezależne -- można wykonywać je w dowolnej kolejności. Jedyne, o czym należy pamiętać, to że warzywo musi być pokrojone przed podsmażeniem. Zamienimy więc kolejność powyższych instrukcji:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pokroj(cebula)\n",
    "podsmaz(cebula)\n",
    "\n",
    "pokroj(papryka)\n",
    "podsmaz(papryka)\n",
    "\n",
    "pokroj(marchew)\n",
    "podsmaz(marchew)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Całą tę frazę można zapisać krócej używając pętli **for**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for warzywo in (cebula, papryka, marchew):\n",
    "    pokroj(warzywo)\n",
    "    podsmaz(warzywo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Pętla **for** służy do wykonywania operacji na kolejnych elementach z dostarczonego zbioru (np. krotki). Zachowana zostaje ścisła kolejność:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in 1, 2, 3, 4, 5:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Istnieje szereg pomocniczych funkcji, wygodnych do używania wraz z pętlą **for**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "\n",
      "cebula\n",
      "marchew\n",
      "papryka\n",
      "\n",
      "0 cebula\n",
      "1 marchew\n",
      "2 papryka\n",
      "\n",
      "Dzisiejszy dzień sponsorują: jabłko, cebula\n",
      "Dzisiejszy dzień sponsorują: gruszka, marchew\n",
      "Dzisiejszy dzień sponsorują: banan, papryka\n"
     ]
    }
   ],
   "source": [
    "num_iterations = 5\n",
    "for i in range(num_iterations):\n",
    "    print(i)\n",
    "print(\"\")\n",
    "    \n",
    "warzywa = (\"cebula\", \"marchew\", \"papryka\")\n",
    "for x in warzywa:\n",
    "    print(x)\n",
    "print(\"\")\n",
    "\n",
    "for i, x in enumerate(warzywa):\n",
    "    print(str(i) + \" \" + x)\n",
    "print(\"\")\n",
    "\n",
    "owoce = (\"jabłko\", \"gruszka\", \"banan\")\n",
    "for a, b in zip(owoce, warzywa):\n",
    "    print(\"Dzisiejszy dzień sponsorują: \" + a + \", \" + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenie\n",
    "\n",
    "Napisz funkcję, która zwraca sumę liczb od 1 do x, gdzie x jest parametrem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pętla while\n",
    "\n",
    "Bardziej ogólnym rodzajem pętli jest pętla **while**. Polega na powtarzaniu czynności tak długo, dopóki spełniony jest określony warunek. Odpowiada ona przykładowemu sformułowaniu z przepisu kulinarnego:\n",
    "\n",
    "    Gotować na małym ogniu pod przykryciem, dopóki papryka jest twarda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "while wciaz_twarda(papryka):\n",
    "    gotuj()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pętla **while** przydaje się wtedy, kiedy nie umiemy z góry powiedzieć, ile iteracji będzie potrzebnych do osiągnięcie pożądanego rezultatu. Przykładowo, fragment kodu poniżej znajduje najmniejszą potęgę 2 większą od 1000:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 2\n",
    "while a < 1000:\n",
    "    a *= 2\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Można z powodzeniem symulować działanie pętli **for** przy pomocy pętli **while**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cebula\n",
      "marchew\n",
      "papryka\n",
      "\n",
      "cebula\n",
      "marchew\n",
      "papryka\n",
      "\n",
      "cebula\n",
      "marchew\n",
      "papryka\n"
     ]
    }
   ],
   "source": [
    "warzywa = (\"cebula\", \"marchew\", \"papryka\")\n",
    "\n",
    "for x in warzywa:\n",
    "    print(x)\n",
    "print(\"\")\n",
    "    \n",
    "for i in range(len(warzywa)):\n",
    "    print(warzywa[i])\n",
    "print(\"\")\n",
    "    \n",
    "i = 0\n",
    "while i < len(warzywa):\n",
    "    print(warzywa[i])\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenie\n",
    "\n",
    "Napisz kod znajdujący największą potęgę 2 mniejszą od 1000 (zmodyfikuj kod podany wyżej)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kolekcje\n",
    "\n",
    "Do tej pory rozważaliśmy pojedyncze wartości (liczby, napisy, wartości logiczne) oraz złączenia kilku wartości w formie krotki. Każdy z takich składników stanowi pewnego rodzaju zamkniętą całość. Osobnym rodzajem składników są kolekcje: otwarte pojemniki, do których można wkładać i wyjmować elementy w trakcie działania programu.\n",
    "\n",
    "### Listy\n",
    "\n",
    "Lista to prosta kolekcja uporządkowanych wartości."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "lista = [1, 2, True, \"tak\"]\n",
    "print(lista[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jeśli krotkę wyobrazimy sobie jako wykonane na wymiar pudełko, w którym przechowujemy z góry określone elementy, lista to długi i elastyczny sznur do wieszania bielizny, do którego możemy przy pomocy spinaczy przypiąć dowolny element w dowolnym miejscu.\n",
    "\n",
    "Krotka jako pudełko:\n",
    "\n",
    "<img src=\"grafika/krotka_jako_pudelko.png\" />\n",
    "\n",
    "Lista jako sznur:\n",
    "\n",
    "<img src=\"grafika/lista_jako_sznur.png\" />\n",
    "\n",
    "Przyjrzyjmy się podstawowym różnicom w użytkowaniu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cebula', 'marchew', 'papryka']\n",
      "['cebula', 'burak', 'papryka']\n",
      "['cebula', 'burak', 'papryka', 'pietruszka']\n"
     ]
    }
   ],
   "source": [
    "# Lista\n",
    "warzywa = [\"cebula\", \"marchew\", \"papryka\"]\n",
    "print(warzywa)\n",
    "warzywa[1] = \"burak\"\n",
    "print(warzywa)\n",
    "warzywa.append(\"pietruszka\")\n",
    "print(warzywa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('cebula', 'marchew', 'papryka')\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-d1337b2e20f9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mwarzywa\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"cebula\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"marchew\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"papryka\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mwarzywa\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mwarzywa\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"burak\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Krotka\n",
    "warzywa = (\"cebula\", \"marchew\", \"papryka\")\n",
    "print(warzywa)\n",
    "warzywa[1] = \"burak\"\n",
    "print(warzywa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-374a40f0d6b1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mwarzywa\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"cebula\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"marchew\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"papryka\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mwarzywa\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"pietruszka\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mwarzywa\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "warzywa = (\"cebula\", \"marchew\", \"papryka\")\n",
    "warzywa.append(\"pietruszka\")\n",
    "warzywa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jak widać, zawartość listy może zostać zmodyfikowana po jej utworzeniu, podczas gdy zawartość krotki pozostaje niezmienna.\n",
    "\n",
    "Możemy przeglądać listę sekwencyjnie korzystając z pętli **for**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cebula\n",
      "marchew\n",
      "papryka\n"
     ]
    }
   ],
   "source": [
    "for x in [\"cebula\", \"marchew\", \"papryka\"]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy też dynamicznie konstruować listę, dodając kolejne elementy. Przykładowo, poniższy kod tworzy listę, zawierającą wszystkie liczby naturalne podzielne przez 7 mniejsze od 100:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]\n"
     ]
    }
   ],
   "source": [
    "l = []\n",
    "for i in range(1, 100):\n",
    "    if i % 7 == 0:\n",
    "        l.append(i)\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listy można ze sobą sklejać:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cebula', 'marchew', 'papryka', 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [\"cebula\", \"marchew\", \"papryka\"] + [1, 2, 3, 4]\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zakres elementów ze środka:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['papryka', 1]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [\"cebula\", \"marchew\", \"papryka\"] + [1, 2, 3, 4]\n",
    "a[2:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeksowanie od końca:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "['papryka', 1, 2]\n"
     ]
    }
   ],
   "source": [
    "a = [\"cebula\", \"marchew\", \"papryka\"] + [1, 2, 3, 4]\n",
    "print(a[-1])\n",
    "print(a[-2])\n",
    "print(a[2:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wstawianie elementów w środku listy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 4]\n",
    "a.insert(2, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenie\n",
    "\n",
    "Napisz funkcję, która przyjmuje jako parametr listę liczb i zwraca zmodyfikowaną listę, w której każde dwie sąsiadujące liczby nieparzyste zostały rozdzielone elementem \"!\". Napisz funkcję w dwóch wersjach: modyfikującą listę podaną jako parametr i pozostawiającą ją niezmienioną.\n",
    "\n",
    "Przykład: [1, 2, 4, 5, 7, 2, 9, 11, 13] -> [1, 2, 4, 5, \"!\", 7, 2, 9, \"!\", 11, \"!\", 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenie\n",
    "\n",
    "Napisz funkcję, która przyjmuje jako parametr listę liczb naturalnych mniejszych niż 10 i zwraca listę tych samych list pogrupowanych krotki, w których suma elementów nie przekracza 10.\n",
    "Przykład: [3, 5, 7, 2, 1, 4, 9] -> [(3, 5), (7, 2, 1), (4,), (9,)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Słowniki\n",
    "\n",
    "Lista jest strukturą danych, którą możemy indeksować przy pomocy liczb naturalnych.\n",
    "Możemy sobie wyobrazić, że jest to proste przyporządkowanie -- kolejnym liczbom\n",
    "naturalnym przyporządkowujemy określone wartości. Do bardziej złożonych przyporządkowań\n",
    "służą nam słowniki. Słownik składa się z par klucz-wartość."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d = {\"a\": 1, \"b\": 2, 3: \"abc\", (\"a\", 1): 5.4, 1.2: 2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wyobraźmy sobie, że przetwarzamy odpowiedzi zebrane przez ankieterów w prostej ankiecie.\n",
    "Jedna z kolumn zawiera odpowiedzi na proste pytanie; możliwe odpowiedzi to Tak, Nie, Nie wiem.\n",
    "Możliwy jest też brak odpowiedzi albo odpowiedź nieczytelna oznaczane przez \"-\".\n",
    "Niestety ankieterzy byli niestaranni i zebrane wartości wyglądają następująco:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "column = [\"N\", \"T\", \"-\", \"Tak\", \"Y\", \"Nie\", \"NW\", \"tak\", \"n\", \"nie\", \"nie wiem\", \"Nie wiem\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naszym zadaniem jest znormalizowanie odpowiedzi. Możemy skorzystać z instrukcji warunkowych:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Nie',\n",
       " 'Tak',\n",
       " '-',\n",
       " 'Tak',\n",
       " 'Tak',\n",
       " 'Nie',\n",
       " 'Nie wiem',\n",
       " 'Tak',\n",
       " 'Nie',\n",
       " 'Nie',\n",
       " 'Nie wiem',\n",
       " 'Nie wiem']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_column = []\n",
    "for x in column:\n",
    "    if x == \"N\" or x == \"Nie\" or x == \"nie\" or x == \"n\":\n",
    "        new_column.append(\"Nie\")\n",
    "    elif x == \"Y\" or x == \"Tak\" or x == \"tak\" or x == \"T\":\n",
    "        new_column.append(\"Tak\")\n",
    "    elif x == \"nie wiem\" or x == \"Nie wiem\" or x == \"NW\":\n",
    "        new_column.append(\"Nie wiem\")\n",
    "    else:\n",
    "        new_column.append(\"-\")\n",
    "new_column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Możemy też skorzystać ze słownika:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Nie',\n",
       " 'Tak',\n",
       " '-',\n",
       " 'Tak',\n",
       " 'Tak',\n",
       " 'Nie',\n",
       " 'Nie wiem',\n",
       " 'Tak',\n",
       " 'Nie',\n",
       " 'Nie',\n",
       " 'Nie wiem',\n",
       " 'Nie wiem']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dictionary = {\"N\": \"Nie\", \"nie\": \"Nie\", \"n\": \"Nie\", \"T\": \"Tak\", \"Y\": \"Tak\", \"tak\": \"Tak\", \"Nie wiem\": \"Nie wiem\",\n",
    "              \"nie wiem\": \"Nie wiem\", \"nw\": \"Nie wiem\", \"Tak\": \"Tak\", \"Nie\": \"Nie\", \"NW\": \"Nie wiem\"}\n",
    "new_column = []\n",
    "for x in column:\n",
    "    if x in dictionary:\n",
    "        new_column.append(dictionary[x])\n",
    "    else:\n",
    "        new_column.append(\"-\")\n",
    "new_column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zawartość słownika, podobnie jak listy, może być modyfikowana w trakcie wykonywania\n",
    "programu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 2}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\"a\": 1}\n",
    "d[\"a\"] = 2\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kluczami w słowniku mogą być tylko niezmienne wartości: liczby, napisy, wartości logiczne, krotki.\n",
    "Nie można użyć jako klucza kolekcji -- listy lub słownika. Wartościami mogą być dowolne obiekty\n",
    "(w tym listy i inne słowniki)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ćwiczenie\n",
    "\n",
    "Wyobraźmy sobie ankietę, która zwiera bardzo dużo pytań Tak/Nie/Nie wiem takich, jak powyżej. Wypełniający ankietę może odpowiedzieć na tyle kolejnych pytań, na ile ma ochotę. Jeśli chce przerwać wypełnianie, może wpisać przy kolejnym pytaniu odpowiedź \"Koniec\" i od tego momentu wszystkie kolejne pola traktowane są jako puste (\"-\"). Zmodyfikuj powyższy kod normalizujący odpowiedzi, dostosowując go do takiej sytuacji.\n",
    "\n",
    "Przykład:\n",
    "[\"Tak\", \"N\", \"nie\", \"NW\", \"-\", \"Koniec\", \"Tak\", \"nie wiem\", \"y\", \"n\"] -> [\"Tak\", \"Nie\", \"Nie\", \"Nie wiem\", \"-\", \"Koniec\", \"-\", \"-\", \"-\", \"-\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obiekty\n",
    "\n",
    "Zaznaczyliśmy wcześniej różnicę w składni pomiędzy funkcją a metodą. Można powiedzieć, że metoda\n",
    "jest specjalną funkcją, która została zapakowana do specjalnej kolekcji zwanej obiektem. Obiekty\n",
    "posiadają pola z określonymi nazwami, które mogą zawierać zarówno funkcje, jak i proste wartości\n",
    "czy inne obiekty. Typy, które poznaliśmy wcześniej, zarówno typy proste, jak i kolekcje, również\n",
    "bywają obiektami i mają swoje metody. W trakcie tego szkolenia nie będziemy wnikać głębiej\n",
    "w zagadnienia obiektowości."
   ]
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}