Y03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Низови симбола (*стрингови* или *ниске*)\n",
    "\n",
    "У овој глави ћемо\n",
    "\n",
    "1. упознати стрингове као низове карактера\n",
    "2. видети како се приступа елементима стринга и како се издвајају делови стринга, и\n",
    "3. упознати основне операције са стринговима."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1. Стрингови (ниске)\n",
    "\n",
    "Иако су настали као машине за обраду нумеричких података рачунари су доживели врхунац свог успеха када се схватило да они могу да обрађују и *симболичке* податке. Обрада симболичких података данас представља доминантан начин употребе рачунара.\n",
    "\n",
    "*Стринг* је реч књижевног енглеског језика (енгл. *string*) чије основно значење је \"објекти исте врсте нанизани на нит\". Зато се стрингови често на српском зову и *ниске*. У Пајтону стринг је низ симбола. На пример, ово су стрингови:\n",
    "\n",
    "    \"Zdravo! Kako si?\"\n",
    "    'Основна школа \"Јован Јовановић-Змај\"'\n",
    "    \":-)\"\n",
    "    ''\n",
    "    \"\"\n",
    "\n",
    "Видимо да се стрингови пишу тако што се између апострофа или наводника (свеједно је) наведе произвољан низ симбола. Последња два примера нам показују како изгледа *празан стринг*, односно, стринг који нема ниједно слово. Други пример нам показује како да се снађемо ако стринг треба да садржи наводнике: просто га оградимо апострофима.\n",
    "\n",
    "Број симбола у стрингу се зове *дужина стринга*. Дужине стрингова из претходног примера су, редом, 16, 36, 3, 0 и 0.\n",
    "\n",
    "Стрингове додељујемо променљивим као што смо и навикли, исписујемо их командом `print`, а учитавамо командом `input`. Команда `input` сачека да корисник унесе низ симбола и да на крају притисне [ENTER]. Она потом врати све симболе које је корисник унео као један низ симбола (такорећи *стринг*). На пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Unesi svoje ime, prvo u nominativu pa onda u vokativu\")\n",
    "ime = input(\"nominativ: \")\n",
    "ime_v = input(\"vokativ: \")\n",
    "print(\"Aha! Znao sam!\")\n",
    "print(\"Ti se zoveš\", ime)\n",
    "print(\"Zdravo,\", ime_v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Уграђена функција `len` враћа дужину стринга и користи се овако:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ti se zoveš\", ime, \"i tvoje ime ima\", len(ime), \"slova\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** Написати Пајтон програм који утврђује колико пута се неки симбол јавља у унетом стрингу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Utvrdjujemo koliko puta se neki simbol javlja u unetom stringu\")\n",
    "c = input(\"Unesi simbol: \")\n",
    "s = input(\"Unesi string: \")\n",
    "broj = 0\n",
    "for x in s:\n",
    "    if x == c:\n",
    "        broj += 1\n",
    "print(\"Simbol\", c, \"se u unetom stringu javlja\", broj, \"puta\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Конструкција `for x in s` прође кроз цео стринг `s` слово по слово, па за свако појављивање симбола `c` увећамо бројач за 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** Написати Пајтон програм који утврђује да ли је у датом стрингу број отворених заграда `(` једнак броју затворених заграда `)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = input(\"Unesi string: \")\n",
    "br_otvorenih = 0\n",
    "br_zatvorenih = 0\n",
    "for x in s:\n",
    "    if x == \"(\": br_otvorenih += 1\n",
    "    if x == \")\": br_zatvorenih += 1\n",
    "if br_otvorenih == br_zatvorenih:\n",
    "    print(\"isti je broj otvorenih i zatvorenih zagrada\")\n",
    "else:\n",
    "    print(\"nije isti broj otvorenih i zatvorenih zagrada\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2. Приступање елементима стринга и деловима стринга"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пошто је стринг низ симбола могуће је приступити појединачним симболима у стрингу, али и деловима стринга.\n",
    "\n",
    "![Indeksiranje stringa](slike/Y103.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Стринг је, дакле, низ кућица. У сваку кућицу је уписан таћно један симбол и свака кућица има кућни број. Као и раније, кућни бројеви крећу од нуле. На пример, ако ставимо"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Popokatepetl\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "онда је"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "док је"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Инересантно је (а касније ћемо видети да је и корисно!) то што низови у Пајтону имају и негативне коефицијенте. Последња кућица у низу има индекс -1 (\"први од краја\"), претпоследња -2 (\"други од краја\") и тако даље. Зато је:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Из стринга можемо лако да издвојимо његове делове употребом конструкције:\n",
    "$$\n",
    "  \\mathtt{s[} m : n \\mathtt{]}\n",
    "$$\n",
    "која издваја део стринга који почиње од кућице са редним бројем $m$ и завршава се са кућицом чији редни број је $n - 1$ (*обрати пажњу: не иде до $n$, већ до кућице пре*). На ово ћемо морати мало да се привикнемо. На пример,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Дакле, из стринга s смо издвојили симболе s[2], s[3] и s[4], односно, кренули смо од кућице број 2 и завршили *непосредно пре 5. кућице*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ако желимо да издвојимо део стринга који креће од 6. кућице и иде до краја стринга, написаћемо"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[6:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С друге стране, ако желимо да издвојимо део стринга који креће од пошетка стринга и иде до 6. кућице (укљућујући и њу) написаћемо:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:7]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Не смемо заборавити да се кућица чији кућни број је наведен иза двотачке не укључује у сегмент!*\n",
    "\n",
    "Издвајање делова стринга у комбинацији са негативним индексима нам омогућује да концизно запишемо веома корисне конструкције. Рецимо, последња четири елемента стринга добијамо овако:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-4:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "што је концизан запис за део стринга \"од -4. кућице па до краја\". С друге стране, \"све осим последња два\" можемо да запишемо овако:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** Написати Пајтон функцију `prebroj_podstr(p, s)` која утврђује колико пута се стринг `p` јавља као подстринг стринга `s.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prebroj_podstr(p, s):\n",
    "    broj = 0\n",
    "    n = len(p)\n",
    "    for i in range(len(s) - n + 1):\n",
    "        if p == s[i:i+n]:\n",
    "            broj += 1\n",
    "    return broj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Да погледамо како функција ради:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prebroj_podstr(\"bana\", \"oprobana torta od banana\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** У сваком рачунарском систему се подаци пакују у *фајлове* (или *датотеке*) и од самих почетака рачунарске ере постоји обичај да се име фајла организује тако да последњих неколико симбола у имену фајла означава тип података који је у том фајлу похрањен. Тај део имена фајла се обично одвоји тачком од остатка имена фајла и зове се *екстензија*. Рецимо:\n",
    "\n",
    "|  Екстензија | Тип података |\n",
    "|-------------|--------------|\n",
    "| .txt        |  текстуална датотека             |\n",
    "| .log        |  текстуална датотека             |\n",
    "| .png        |  слика                           |\n",
    "| .jpg        |  слика                           |\n",
    "| .bmp        |  слика                           |\n",
    "| .mpg        |  видео                           |\n",
    "| .mp3        |  звук                            |\n",
    "\n",
    "Написати Пајтон програм који од корисника учитава име фајлса и на основу горње табеле одређује тип података који је података који је у њему похрањен. У случају да се екстензија имена фајла не налази у овој табели програм треба да пријави да се ради о непознатом типу података."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fajl = input(\"Unesi ime fajla: \")\n",
    "ekstenzija = fajl[-4:] # uzimamo poslednja 4 simbola imena\n",
    "if ekstenzija in [\".txt\", \".log\"]:\n",
    "    print(\"tekstualni fajl\")\n",
    "elif ekstenzija in [\".png\", \".jpg\", \".bmp\"]:\n",
    "    print(\"slika\")\n",
    "elif ekstenzija == \".mpg\":\n",
    "    print(\"video\")\n",
    "elif ekstenzija == \".mp3\":\n",
    "    print(\"zvuk\")\n",
    "else:\n",
    "    print(\"Ovaj format mi nije poznat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** Написати Пајтон функцију `broj_reci(s)` која у датом стрингу броји речи. Реч је непрекидан низ слова."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def broj_reci(s):\n",
    "    n = len(s)\n",
    "    broj = 0\n",
    "    for i in range(n-1):\n",
    "        if s[i].isalpha() and not s[i+1].isalpha():\n",
    "            broj += 1\n",
    "    if s[n-1].isalpha():\n",
    "        broj += 1\n",
    "    return broj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Напоменимо пре свега да уграђена функција `isalpha()` проверава да ли је нешто слово (\"припадник неког алфабета\").\n",
    "\n",
    "Функција `broj_reci(s)` се ослања на једноставну идеју: када са слова пређемо на симбол који није слово, то је сигуран знак да смо управо детектовали једну реч и онда бројач увећавамо за 1. Ова стратегија ради за све речи у стрингу осим за последњу јер нам у том случају недостаје слово које је \"окидач\" за детектовање краја речи. Зато последња `if` наредба проверава да ли је последњи симбол у стрингу слово, како би и последња реч била урачуната.\n",
    "\n",
    "Ево неколико примера:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broj_reci(\"Ovo je samo primer\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broj_reci(\"Proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broj_reci(\"!!!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3. Операције са стринговима\n",
    "\n",
    "У Пајтону, као и у већини модерних програмских језика, стрингови су *непроменљиви* (то својство се на енглеском зове *immutability*). На пример, нека је"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Banana\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ако покушамо да променимо прво слово стринга на мало слово `b` добићемо грешку:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0] = \"b\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Зато трансформације са стринговима увек своде на то да се од старог стринга изгради нови стринг који има својства која желимо. Једна од основних операција коју при томе користимо је *надовезивање стрингова* или *конкатенација*. Операција надовезивања стрингова се означава знаком `+`. На пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Novi\"\n",
    "t = \"Beograd\"\n",
    "s + t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Важно је напоменути да надовезивање стрингова ради на најједноставнији могући начин: просто дода један стринг на крај оног другог, без уметања празнина или неке друге врсте мудровања.\n",
    "\n",
    "Користећи операцију надовезивања можемо стрингу додати неки други стринг на почетак или на крај. На пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"bana\"\n",
    "s = \"opro\" + s\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"bana\"\n",
    "s = s + \"na\"\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Још једна интересантна операција је множење стринга бројем. На пример,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Mir! \" * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** Исписати (за казну :-)) 100 пута: \"Ученици не смеју да се гађају кредом!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Ученици не смеју да се гађају кредом!\" * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** Написати Пајтон функцију која обрће стринг."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def obrni_string(s):\n",
    "    novi = \"\"\n",
    "    for x in s:\n",
    "        novi = x + novi\n",
    "    return novi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ова функција од стринга `s` у променљивој `novi` изгради нови стринг који садржи иста слова као и стринг `s`, али у обрнутом редоследу. На почетку поставимо стринг `novi` на празан стринг. Потом у циклусу слова стринга `s` додајемо на стринг `novi`, али једно по једно на почетак стринга `novi`. Тако прво слово стринга `s` постаје последње слово стринга `novi`, док последње слово стринга `s` на крају буде прво слово стринга `novi`. Другим речима, у стрингу `novi` изградимо слово по слово обрнуту верзију стринга `s`.\n",
    "\n",
    "Погледајмо на пар примера како ова функција ради:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obrni_string(\"Proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obrni_string(\"ana voli milovana\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Пример.** Написати Пајтон програм који проверава да ли је дата реченица палиндром. Приликом провере треба игнорисати празинине и величину слова. На пример, следеће реченице су палиндроми:\n",
    "\n",
    "    Ана воли Милована!\n",
    "    Сир има мирис?\n",
    "    Сава зидар ради за вас\n",
    "    Маја са Недом оде на сајам.\n",
    "\n",
    "*Решење.* У решењу овог примера ћемо користити уграђену функцију `isaplha()` која проверава да ли је нешто слово, као и уграђену функцију `lower()` која од стринга прави нови у коме су сва слова мала."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = input(\"Unesi string: \")\n",
    "novi = \"\"\n",
    "obrnut = \"\"\n",
    "for x in s.lower():\n",
    "    if x.isalpha():\n",
    "        novi = novi + x\n",
    "        obrnut = x + obrnut\n",
    "if novi == obrnut:\n",
    "    print(\"jeste palindrom\")\n",
    "else:\n",
    "    print(\"nije palindrom\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4. Задаци"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задатак 1.** Написати Пајтон програм који од корисника учитава стринг и онда утврђује број самогласника и број сугласника у том стрингу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задатак 2.** Написати Пајтон функцију `poslednja_rec(s)` која из датог стринга издваја последњу реч која је наведена у стрингу. Ако у стрингу не постоји ниједно слово функција треба да врати празан стринг. (Напомена: реч је непрекидан низ слова.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задатак 3.** Написати пајтон функцију `ispravi_interpunkciju(s)` која у датом стрингу додаје по једну празнину иза сваког знака интерпункције, *али само ако је то потребно*. На пример, за стринг\n",
    "\n",
    "    \"Halo?Da? Ne.Ko je to?\"\n",
    "\n",
    "функција треба да врати:\n",
    "\n",
    "    \"Halo? Da? Ne. Ko je to?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задатак 4.** Написати Пајтон функцију `obrni_reci(s)` која од датог стринга прави нови у коме су речи послагане од последње према првој. На пример, за стринг\n",
    "\n",
    "    \"Napisati program koji ispisuje reci unetog teksta u obrnutom poretku\"\n",
    "\n",
    "функција треба да врати:\n",
    "\n",
    "    \"poretku obrnutom u teksta unetog reci ispisuje koji program Napisati\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задатак 5*.** Написати Пајтон функцију која проверава да ли су у датом стрингу заграде ( и ) *балансиране*. То значи да у стрингу имамо исти број отворених и затоврених заграда, и да не постоји почетни сегмент стринга у коме је број затворених заграда већи од броја отворених."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задатак 6.** Написати Пајтон функцију `razmeni(s, din_za_1_eur)` која конвертује дати износ из динара у евре и обрнуто. Стринг `s` садржи износ записан у облику $\\langle \\mathrm{broj} \\rangle \\langle \\mathrm{valuta} \\rangle$, на пример овако:\n",
    "\n",
    "    125 DIN\n",
    "    217.50 EUR\n",
    "    1527.99 DIN\n",
    "    50 EUR\n",
    "\n",
    "док аргумент `din_za_1_eur` представља вредност једног евра у динарима. Функција треба да врати стринг који има облик $\\langle \\mathrm{broj} \\rangle \\langle \\mathrm{valuta} \\rangle$. При томе ти могу од користи бити уграђене функције `float` и `str`. За неки стринг `p` функција `float(p)` враћа број који је записан стрингом `p` игноришући при том празнине које се можда јављају у стрингу. На пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(\"  123.4 \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С друге стране, функција `str` од неког броја прави стринг који садржи његов запис. На пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(2.89)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функција `razmeni` треба да ради овако:\n",
    "\n",
    "    razmeni(\"124.99 EUR\", 117.90)\n",
    "    '14736.321‬ DIN'\n",
    "\n",
    "    razmeni(\"12000 DIN\", 117.90)\n",
    "    '‭101.7811704 EUR'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}