02.Python_Wprowadzenie_2z2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warsztaty Python w Data Science"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Blok 1 - Wprowadzenie\n",
    "## Python (2 z 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dlaczego Python a nie R ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Krótka odpowiedź: ... bo coś trzeba wybrać \n",
    "\n",
    "## Dłuższa odpowiedź:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "![thylacine](img/thylacine0.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "## Wilk workowaty († _Thylacinus cynocephalus_)\n",
    "\n",
    "- Największy drapieżny torbacz czasów współczesnych.\n",
    "- Drapieżnik alfa (na szczycie piramidy ekologicznej)\n",
    "- Zwierzę nocne. \n",
    "- Polowało na kangury i wombaty – ale również na owce\n",
    "- Długość: 100-110 cm, wysokość ok. 60 cm, waga ok. 30 kg\n",
    "- Uzębienie typowe dla drapieżników"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "![thylacine](img/thylacine.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "![thylacine](img/wolf.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Źródła zdjęć: wikipedia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# No dobra, ale co to ma wspólnego z Pythonem ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Podobne problemy wymagają podobnych rozwiązań"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## To z czego korzystać ?\n",
    "\n",
    "### Opowiedź: Nie ma znaczenia. Każda technologia jest okazją do nauki :)\n",
    "  - z **R** naucz się jak przygotowywać dane\n",
    "  - z **Pythona** naucz się jak organizować kod\n",
    "  - ze **Scali** - jak pisać funkcjonalnie w sposób skalowalny\n",
    "  - z **Javy** - jak (nie) dzielić projekt na mniejsze częsci\n",
    "  - etc. etc.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zadanie 1\n",
    "\n",
    "Napisać funkcję co policzy ilość wystąpień na liście\n",
    "Przykład\n",
    "\n",
    "zlicz( [1, 2, 3, 4, 1, 2, 1] )\n",
    "\n",
    "{ 1: 3, 2: 2, 3: 1, 4: 1 }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zlicz(lista):\n",
    "    ilosc_wystapien = {}\n",
    "    for x in lista:\n",
    "        ilosc = ilosc_wystapien.get(x, 0)\n",
    "        ilosc = ilosc + 1\n",
    "        ilosc_wystapien[x] = ilosc\n",
    "    return ilosc_wystapien"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 1}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zlicz([1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 3}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zlicz([1, 1, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 2, 2: 1}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zlicz([1, 2, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 3, 2: 2, 3: 1, 4: 1}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zlicz( [1, 2, 3, 4, 1, 2, 1] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zadanie 2"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Napisać funkcję co wypisze choinkę o odpowiedniej wysokości\n",
    "\n",
    "choinka(7)\n",
    "\n",
    "\n",
    "       *\n",
    "      ***\n",
    "     *****\n",
    "    *******\n",
    "   *********\n",
    "  ***********\n",
    " *************\n",
    "       *\n",
    "      ***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choinka(poziom):\n",
    "    S=\" \"\n",
    "    G=\"*\"\n",
    "    for i in range(1,poziom+1):\n",
    "        print ( S*(poziom-i) + G*(2*i-1) )\n",
    "    print( S*(poziom-1) + G )\n",
    "    print( S*(poziom-2) + G*3 )    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      *\n",
      "     ***\n",
      "    *****\n",
      "   *******\n",
      "  *********\n",
      " ***********\n",
      "*************\n",
      "      *\n",
      "     ***\n"
     ]
    }
   ],
   "source": [
    "choinka(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  *\n",
      " ***\n",
      "*****\n",
      "  *\n",
      " ***\n"
     ]
    }
   ],
   "source": [
    "choinka(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           *\n",
      "          ***\n",
      "         *****\n",
      "        *******\n",
      "       *********\n",
      "      ***********\n",
      "     *************\n",
      "    ***************\n",
      "   *****************\n",
      "  *******************\n",
      " *********************\n",
      "***********************\n",
      "           *\n",
      "          ***\n"
     ]
    }
   ],
   "source": [
    "choinka(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zadanie 3"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Napisać funkcję co wypiszę liczbę naturalną słownie dla liczb od 0 do 999999.\n",
    "\n",
    "slownie(1984)\n",
    "'tysiąc dziewięćset osiemdziesiąt cztery'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do999(n):\n",
    "    nazwy_jednosci = { 0: \"\", 1: \"jeden\", 2: \"dwa\", 3: \"trzy\", 4: \"cztery\", 5: \"pięć\", 6: \"sześć\", 7: \"siedem\", 8: \"osiem\", 9: \"dziewięć\"}\n",
    "    nazwy_nastki = { 11: \"jedenaście\", 12: \"dwanaście\", 13: \"trzynaście\", 14: \"czternaście\", 15: \"piętnaście\", 16: \"szesnaście\", 17: \"siedemnaście\", 18: \"osiemnaście\", 19: \"dziewietnaście\"}\n",
    "    nazwy_dziesiatki = { 0: \"\", 10: \"dziesięć\", 20: \"dwadzieścia\", 30: \"trzydzieści\", 40: \"czterdzieści\", 50: \"pięćdziesiąt\", 60: \"sześćdziesiąt\", 70: \"siedemdziesiąt\", 80: \"osiemdziesiąt\", 90: \"dziewięćdziesiąt\"}\n",
    "    nazwy_setki = { 0: \"\", 100: \"sto\", 200: \"dwieście\", 300: \"trzysta\", 400: \"czterysta\", 500: \"pięćset\", 600: \"sześćset\", 700: \"siedemset\", 800: \"osiemset\", 900: \"dziewięćset\"}\n",
    "    \n",
    "    wynik = [n] \n",
    "    \n",
    "    jednosci = n % 10\n",
    "    wynik =  [ (jednosci,nazwy_jednosci[jednosci]) ]\n",
    "    \n",
    "    n = n - jednosci\n",
    "    dziesiatki = n % 100\n",
    "    \n",
    "    if dziesiatki == 10 and jednosci > 0:\n",
    "        suma = dziesiatki+jednosci\n",
    "        wynik = [ (suma, nazwy_nastki[suma]) ]\n",
    "    else:\n",
    "        wynik = [ (dziesiatki,nazwy_dziesiatki[dziesiatki]) ]  + wynik\n",
    "        \n",
    "    n = n - dziesiatki\n",
    "    setki = n % 1000\n",
    "    wynik= [ (setki,nazwy_setki[setki]) ] + wynik\n",
    "    \n",
    "    return wynik"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, ''), (0, ''), (0, '')]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "do999(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, ''), (30, 'trzydzieści'), (7, 'siedem')]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "do999(37)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(200, 'dwieście'), (30, 'trzydzieści'), (1, 'jeden')]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "do999(231)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(200, 'dwieście'), (11, 'jedenaście')]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "do999(211)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(100, 'sto'), (12, 'dwanaście')]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "do999(112)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dodaj_jednostke(lista, formy):\n",
    "    wartosc = 0\n",
    "    for i in lista:\n",
    "        wartosc += i[0] \n",
    "        \n",
    "    if wartosc==0:\n",
    "        return lista\n",
    "\n",
    "    if wartosc==1:\n",
    "        lista = [ (0, formy[0]) ]\n",
    "    elif lista[-1][0] in [2,3,4]:\n",
    "        lista.append( (lista[-1][0], formy[1]))\n",
    "    else:\n",
    "        lista.append( (lista[-1][0], formy[2]))\n",
    "    return lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(100, 'sto'), (12, 'dwanaście'), (12, 'jabłek')]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dodaj_jednostke([(100, 'sto'), (12, 'dwanaście')], ['jabłko', 'jabłka', 'jabłek'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(100, 'sto'), (12, 'dwanaście'), (12, 'jabłek')]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dodaj_jednostke(do999(112), ['jabłko', 'jabłka', 'jabłek'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, ''), (0, ''), (2, 'dwa'), (2, 'jabłka')]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dodaj_jednostke(do999(2), ['jabłko', 'jabłka', 'jabłek'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, ''), (0, ''), (5, 'pięć'), (5, 'jabłek')]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dodaj_jednostke(do999(5), ['jabłko', 'jabłka', 'jabłek'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sklej(lista):\n",
    "    wynik = \"\"\n",
    "    S = \" \"\n",
    "    for i in lista:\n",
    "        if len(i[1])>0:\n",
    "            wynik += S + i[1]\n",
    "    return wynik.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pięć jabłek'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sklej(dodaj_jednostke(do999(5), ['jabłko', 'jabłka', 'jabłek']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'siedemdziesiąt dwa jabłka'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sklej(dodaj_jednostke(do999(72), ['jabłko', 'jabłka', 'jabłek']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sto dwadzieścia jeden jabłek'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sklej(dodaj_jednostke(do999(121), ['jabłko', 'jabłka', 'jabłek']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jabłko'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sklej(dodaj_jednostke(do999(1), ['jabłko', 'jabłka', 'jabłek']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _slownie(n):\n",
    "    wynik = do999(n%1000)\n",
    "    if n>999:\n",
    "        n=n//1000\n",
    "        wynik = dodaj_jednostke(do999(n%1000), ['tysiąc', 'tysiące', 'tysięcy']) + wynik\n",
    "    if n>999:\n",
    "        n=n//1000\n",
    "        wynik = dodaj_jednostke(do999(n%1000), ['milion', 'miliony', 'milionów']) + wynik\n",
    "    if n>999:\n",
    "        n=n//1000\n",
    "        wynik = dodaj_jednostke(do999(n%1000), ['miliard', 'miliardy', 'miliardów']) + wynik\n",
    "        \n",
    "    return wynik"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'tysiąc'), (900, 'dziewięćset'), (80, 'osiemdziesiąt'), (4, 'cztery')]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_slownie(1984)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(300, 'trzysta'),\n",
       " (60, 'sześćdziesiąt'),\n",
       " (9, 'dziewięć'),\n",
       " (9, 'miliardów'),\n",
       " (0, ''),\n",
       " (17, 'siedemnaście'),\n",
       " (17, 'milionów'),\n",
       " (0, ''),\n",
       " (0, ''),\n",
       " (2, 'dwa'),\n",
       " (2, 'tysiące'),\n",
       " (0, ''),\n",
       " (11, 'jedenaście')]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_slownie(369017002011)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "do999 -------------\\\n",
    "                    ------> _slownie -----> sklej -----> slownie \n",
    "dodaj_jednostke ---/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def slownie(n):\n",
    "    lista = _slownie(n)\n",
    "    wynik = sklej(lista)\n",
    "    return wynik.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tysiąc dziewięćset osiemdziesiąt cztery'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slownie(1984)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'miliard'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slownie(1000000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'trzysta sześćdziesiąt dziewięć miliardów siedemnaście milionów dwa tysiące jedenaście'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slownie(369017002011)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Język Python - wprowadzenie (2. spotkanie)\n",
    "- ### Argumenty Funkcji\n",
    "- ### Instrukcje sterujące cd. \n",
    "- ### Struktury danych cd.\n",
    "    - ### Zbiory\n",
    "    - ### List comprehension\n",
    "    - ### Sortowanie\n",
    "---\n",
    "## Argumenty Funkcji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"10\", base=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wiecej(x, ile_razy=2):\n",
    "    return ile_razy*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wiecej(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wiecej(100, ile_razy=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _slownie(n, jednostki=None):\n",
    "    if jednostki:\n",
    "        wynik = dodaj_jednostke(do999(n%1000), jednostki)\n",
    "    else:\n",
    "        wynik = do999(n%1000)\n",
    "    \n",
    "    if n>999:\n",
    "        n=n//1000\n",
    "        wynik = dodaj_jednostke(do999(n%1000), ['tysiąc', 'tysiące', 'tysięcy']) + wynik\n",
    "    if n>999:\n",
    "        n=n//1000\n",
    "        wynik = dodaj_jednostke(do999(n%1000), ['milion', 'miliony', 'milionów']) + wynik\n",
    "    if n>999:\n",
    "        n=n//1000\n",
    "        wynik = dodaj_jednostke(do999(n%1000), ['miliard', 'miliardy', 'miliardów']) + wynik\n",
    "        \n",
    "    return wynik\n",
    "\n",
    "def slownie(n, jednostki= None):\n",
    "    lista = _slownie(n, jednostki)\n",
    "    wynik = sklej(lista)\n",
    "    return wynik.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tysiąc dziewięćset osiemdziesiąt cztery'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slownie(1984)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tysiąc dziewięćset osiemdziesiąt cztery złote'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zlote=['złoty', 'złote', 'złotych']\n",
    "\n",
    "slownie(1984, zlote)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def choinka(poziom, separator=\" \", znak=\"*\"):\n",
    "    S=separator\n",
    "    G=znak\n",
    "    for i in range(1,poziom+1):\n",
    "        print ( S*(poziom-i) + G*(2*i-1) )\n",
    "    print( S*(poziom-1) + G )\n",
    "    print( S*(poziom-2) + G*3 )  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      *\n",
      "     ***\n",
      "    *****\n",
      "   *******\n",
      "  *********\n",
      " ***********\n",
      "*************\n",
      "      *\n",
      "     ***\n"
     ]
    }
   ],
   "source": [
    "choinka(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      #\n",
      "     ###\n",
      "    #####\n",
      "   #######\n",
      "  #########\n",
      " ###########\n",
      "#############\n",
      "      #\n",
      "     ###\n"
     ]
    }
   ],
   "source": [
    "choinka(znak='#', poziom=7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_var_args(farg, *args):\n",
    "    print (\"formal arg:\", farg)\n",
    "    print(args)\n",
    "    for arg in args:\n",
    "        print (\"another arg:\", arg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "formal arg: 1\n",
      "('two', 3)\n",
      "another arg: two\n",
      "another arg: 3\n"
     ]
    }
   ],
   "source": [
    "test_var_args(1, \"two\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_var_kwargs(farg, **kwargs):\n",
    "    print (\"formal arg:\", farg)\n",
    "    for key in kwargs:\n",
    "        print (\"another keyword arg: %s: %s\" % (key, kwargs[key]))\n",
    "    print (kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "formal arg: 1\n",
      "another keyword arg: myarg2: two\n",
      "another keyword arg: myarg3: 3\n",
      "{'myarg2': 'two', 'myarg3': 3}\n"
     ]
    }
   ],
   "source": [
    "test_var_kwargs(farg=1, myarg2=\"two\", myarg3=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instrukcje sterujące"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nie zero'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 1\n",
    "napis = \"\"\n",
    "if n==0:\n",
    "    nazwa = \"zero\"\n",
    "else:\n",
    "    nazwa = \"nie zero\"\n",
    "    \n",
    "nazwa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nie zero'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nazwa = \"zero\" if n==0 else \"nie zero\"\n",
    "nazwa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n -= 1\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "while n > 0:\n",
    "    n -= 1\n",
    "    print(n)\n",
    "    if n==2: \n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = list(range(7))\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "while lista:\n",
    "    print(lista.pop())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zbiory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "zbior = set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zbior.add(3)\n",
    "zbior.add(4)\n",
    "zbior.add(3)\n",
    "zbior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "zbior = {3, 4, 5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4, 5, 7}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zbior.add(3)\n",
    "zbior.add(4)\n",
    "zbior.add(7)\n",
    "zbior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension\n",
    "\n",
    "### Generator Expressions"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "x for x in range(10)\n",
    "\n",
    "x*x for x in range(10)\n",
    "\n",
    "(x*y for x in range(10) for y in range(x))\n",
    "\n",
    "x*x for x in range(10) if x % 2 == 0\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "List + Generator Expression\n",
    "           =     \n",
    "    List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ x for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ x*x for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ x*x for x in range(10) if x % 2 == 0 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 2: 4, 4: 16, 6: 36, 8: 64}"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{ x:x*x for x in range(10) if x % 2 == 0 }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x0000023322E3B548>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x*y for x in range(10) for y in range(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 0, 0),\n",
       " (2, 0, 0),\n",
       " (2, 1, 2),\n",
       " (3, 0, 0),\n",
       " (3, 1, 3),\n",
       " (3, 2, 6),\n",
       " (4, 0, 0),\n",
       " (4, 1, 4),\n",
       " (4, 2, 8),\n",
       " (4, 3, 12)]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, y, x*y) for x in range(5) for y in range(x)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sortowanie list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = list(range(10, 0, -1))\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.sort()\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.sort(reverse=True)\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20']\""
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [ str(i) for i in range(21)]\n",
    "str(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"['0', '1', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '2', '20', '3', '4', '5', '6', '7', '8', '9']\""
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.sort()\n",
    "str(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def int_val(s):\n",
    "    return int(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20']\""
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista.sort(key=int_val)\n",
    "str(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '-1', '-2', '-3', '-4', '-5', '-6', '-7', '-8', '-9', '-10', '-11', '-12', '-13', '-14', '-15', '-16', '-17', '-18', '-19', '-20']\""
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dluga_lista = [ str(i) for i in range(21)] + [ str(i) for i in range(-1, -21, -1)]\n",
    "str(dluga_lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Zadanie 1 - łatwe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Posortować `dluga_lista` po wartości bezwględnej elementów listy interpretowanych jako wartość całkowita "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zadanie 2 - średnie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wygenerować listę liczb z zakresu `1-1000` które nie są podzielne przez żadną cyfrę od `2` do `9`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zadanie 3 - trudne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stworz funkcję która usunie \"wyplaszczy\" zagnieżdzone listy\n",
    "\n",
    "`l = [4, 1, [ 2, [7] ], 3]`\n",
    "\n",
    "`wyplaszcz(l)`\n",
    "\n",
    "`[4, 1, 2, 7, 3]`"
   ]
  }
 ],
 "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.7.5"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}