EN_1_uvod.ipynb

{
  "metadata": {
    "kernelspec": {
      "name": "python",
      "display_name": "Python (Pyodide)",
      "language": "python"
    },
    "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.9.13"
    }
  },
  "nbformat_minor": 4,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "source": "<img src=\"hs.png\" width=\"200\">",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "# Basics of Python (1 to 3)\n\nWe will se the Python 3 language and a copious amount of examples and illustrations. Also, you will learn step by tep how Python program code looks like, and we will be glad if this is also an incentive for you t learn Python, which is extremely useful in todays's world.\n\n\nThis notebook  consists of text cells and Python code cells. Read the text cells (and refine and supplement them as desired), and execute the Python cells. To do this, you click on the next cell (where it says \"**In[   ]**\"), and press *Shift+Enter(Return)*. Wait until it says \"**In[\\*]**\" an until you see \"**In[1]**\", which means the calculation is complete. You should get \"Hello, world!\" as a result.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "print(\"Hello, world!\")",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "This brings us to the two basic building blocks of Python:\n\n* built-in functionw: **print(---)**\n* strings: **\"Hello, world!\"**\n\n## Python built-in functions\n\nBuilt-in functions are functions that do not need to be defined, but are availble with Python during instaččation. These are all standard functions such as arithmetic, logical, printing, openening fiels and similar. More specificalyy, in Python 3 these are the functions (if it seems like a lot to you, consider that you will use maybe 10 of them, the rest are very specific, but it's important see them):\n\n<table class=\"docutils\" border=\"1\">\n<colgroup>\n<col width=\"21%\">\n<col width=\"19%\">\n<col width=\"20%\">\n<col width=\"18%\">\n<col width=\"22%\">\n</colgroup>\n<thead valign=\"bottom\">\n<tr class=\"row-odd\"><th class=\"head\"></th>\n<th class=\"head\"></th>\n<th class=\"head\">Built-in Functions</th>\n<th class=\"head\"></th>\n<th class=\"head\"></th>\n</tr>\n</thead>\n<tbody valign=\"top\">\n<tr class=\"row-even\"><td><a class=\"reference internal\" href=\"#abs\" title=\"abs\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">abs()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-dict\"><code class=\"docutils literal\"><span class=\"pre\">dict()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#help\" title=\"help\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">help()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#min\" title=\"min\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">min()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#setattr\" title=\"setattr\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">setattr()</span></code></a></td>\n</tr>\n<tr class=\"row-odd\"><td><a class=\"reference internal\" href=\"#all\" title=\"all\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">all()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#dir\" title=\"dir\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">dir()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#hex\" title=\"hex\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">hex()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#next\" title=\"next\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">next()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#slice\" title=\"slice\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">slice()</span></code></a></td>\n</tr>\n<tr class=\"row-even\"><td><a class=\"reference internal\" href=\"#any\" title=\"any\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">any()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#divmod\" title=\"divmod\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">divmod()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#id\" title=\"id\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">id()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#object\" title=\"object\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">object()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#sorted\" title=\"sorted\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">sorted()</span></code></a></td>\n</tr>\n<tr class=\"row-odd\"><td><a class=\"reference internal\" href=\"#ascii\" title=\"ascii\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">ascii()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#enumerate\" title=\"enumerate\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">enumerate()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#input\" title=\"input\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">input()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#oct\" title=\"oct\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">oct()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#staticmethod\" title=\"staticmethod\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">staticmethod()</span></code></a></td>\n</tr>\n<tr class=\"row-even\"><td><a class=\"reference internal\" href=\"#bin\" title=\"bin\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">bin()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#eval\" title=\"eval\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">eval()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#int\" title=\"int\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">int()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#open\" title=\"open\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">open()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-str\"><code class=\"docutils literal\"><span class=\"pre\">str()</span></code></a></td>\n</tr>\n<tr class=\"row-odd\"><td><a class=\"reference internal\" href=\"#bool\" title=\"bool\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">bool()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#exec\" title=\"exec\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">exec()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#isinstance\" title=\"isinstance\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">isinstance()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#ord\" title=\"ord\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">ord()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#sum\" title=\"sum\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">sum()</span></code></a></td>\n</tr>\n<tr class=\"row-even\"><td><a class=\"reference internal\" href=\"#bytearray\" title=\"bytearray\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">bytearray()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#filter\" title=\"filter\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">filter()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#issubclass\" title=\"issubclass\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">issubclass()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#pow\" title=\"pow\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">pow()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#super\" title=\"super\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">super()</span></code></a></td>\n</tr>\n<tr class=\"row-odd\"><td><a class=\"reference internal\" href=\"#bytes\" title=\"bytes\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">bytes()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#float\" title=\"float\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">float()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#iter\" title=\"iter\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">iter()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#print\" title=\"print\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">print()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-tuple\"><code class=\"docutils literal\"><span class=\"pre\">tuple()</span></code></a></td>\n</tr>\n<tr class=\"row-even\"><td><a class=\"reference internal\" href=\"#callable\" title=\"callable\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">callable()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#format\" title=\"format\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">format()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#len\" title=\"len\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">len()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#property\" title=\"property\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">property()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#type\" title=\"type\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">type()</span></code></a></td>\n</tr>\n<tr class=\"row-odd\"><td><a class=\"reference internal\" href=\"#chr\" title=\"chr\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">chr()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-frozenset\"><code class=\"docutils literal\"><span class=\"pre\">frozenset()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-list\"><code class=\"docutils literal\"><span class=\"pre\">list()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-range\"><code class=\"docutils literal\"><span class=\"pre\">range()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#vars\" title=\"vars\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">vars()</span></code></a></td>\n</tr>\n<tr class=\"row-even\"><td><a class=\"reference internal\" href=\"#classmethod\" title=\"classmethod\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">classmethod()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#getattr\" title=\"getattr\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">getattr()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#locals\" title=\"locals\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">locals()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#repr\" title=\"repr\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">repr()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#zip\" title=\"zip\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">zip()</span></code></a></td>\n</tr>\n<tr class=\"row-odd\"><td><a class=\"reference internal\" href=\"#compile\" title=\"compile\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">compile()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#globals\" title=\"globals\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">globals()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#map\" title=\"map\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">map()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#reversed\" title=\"reversed\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">reversed()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#__import__\" title=\"__import__\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">__import__()</span></code></a></td>\n</tr>\n<tr class=\"row-even\"><td><a class=\"reference internal\" href=\"#complex\" title=\"complex\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">complex()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#hasattr\" title=\"hasattr\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">hasattr()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#max\" title=\"max\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">max()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#round\" title=\"round\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">round()</span></code></a></td>\n<td>&nbsp;</td>\n</tr>\n<tr class=\"row-odd\"><td><a class=\"reference internal\" href=\"#delattr\" title=\"delattr\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">delattr()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#hash\" title=\"hash\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">hash()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-memoryview\"><code class=\"docutils literal\"><span class=\"pre\">memoryview()</span></code></a></td>\n<td><a class=\"reference internal\" href=\"#func-set\"><code class=\"docutils literal\"><span class=\"pre\">set()</span></code></a></td>\n<td>&nbsp;</td>\n</tr>\n</tbody>\n</table>",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "## Types\n\n**Strings** (tag: str) are a sequence of characters that we don't want Python to interpret as a command, but to treat as text. Strings are enclosed in semiquotes 'strin1' or quotes \"string2\". They can be witten wither way. **An empty string** is written as \"\" or as ''\n\nthe second basic data type are **integers** (int), and they are written as -2,-1,0,1,2,... The third are the **decimal numbers** (float) and they must always be written with period. For example 1.0 instead of just 1.\n\nStrings and integers are data, but they are of different **types**. For example \"1\" as a string and 1 are not the same. try executing the cell below:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "\"1\"==1",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Try replacing it so it's the same (1==1 ili \"1\"==\"1\") then try again, and also notice how equality is written in Python. Try the cell below now:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "\"1\"!=1",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "The symbol != means \"not equal\". \n\n**== means \"equal\", a != means \"not equal\"**.\n\nOther data types are lists, dictionaries, apirs, sets and some less common ones. You will learn about other types of data in the next notebook. Try executing the cell below:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "1.0==1",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Here we see that Python does not know how to convert  **str** to **int** (\"1\"!=1), but it knows how to convert **float** into **int**. This conversion from one type to another type of the sa, data is called *casting*. Python, if it knows how, automatically *casts* one type into another. Try executing the cell below: ",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "\"Dobio sam \" + 5",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Python throws an error that says it doesn't want to convert a number to a string without fuss. It says this because when a number is converted to a string, it loses the ability to be treated as a number (to be added and multiplied with), but instead becomes an ordinary character such as \"G\". Execute the cell below:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "\"1\"+\"1\"",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Python interprets + as a string concatenation if it occurs between string (this is called **concatenation**), and as addition if it occurs between numbers. What if it comes between a number and a string? Let's look:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "\"1\"+5",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "We see again the same error as above. Python could theoretically say \"when one is already a string, then I'll treat the other as a string and return \"15\" because I can't add string\". That's how Java works, but Python tries to warn us not to sneak a bug, because there is a chance that we wanted to add and accidentally conerted one of the numerators into a string. This is especially often the case when in complex programs, not pure data, but a variable is passed. \n\nTo solve the problem we can do either:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "\"1\"+str(5)",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Or, if we wanted add up:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "int(\"1\")+5",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "And that's it. \n\nGood job, we are half way through it.",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "## Complex functions\nIt is possible to stack complex functions from predefined functions (prss Shift+Enter on the bottom cell):\n",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def take_one_away(varaible):                 #the first line of code\n    print(\"I got: \" + str(variable))    #the second one...\n    return \"I give back: \" + str(variable - 1)\ntake_away_one(53)",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "let's look at the anatomy of this code, beacuse all (however) complex functions are built the same way. Let's analyze by lines:\n\n1. The First line, function definition:\n  * the expression **def**: it serves to let Python know thst we want to define  a function, it always starts with this.\n  * expression **substruct_one(variable)**: The first part, **substruct_one** is the name of our function. We can choose a name, but every time we need that function we have to call it with that name. It's important not to name things the way Python's inernals are named, eg \"list\" or \"max\". As an informal rule, if you use Croatian words, everything will be fine. The second part **(variable)** is the part where Python will expect some value, and the *varaible* will \"save its place\". This is called  *argument* and it is the same as x in the mathematical notation of some function f(x)=56x+3 . Inside the function, when we want to talk about the object that the function recevies, we use the name that was assigned to it during the definition of the function.\n  * colon\n  * end comment: comments in Python start with #, and last until the end of the line. A comment is similar to a string in that Python doesn't try to interpret it, but unlike a string that Python \"returns as is\", comments are ignored by Python--they dont't exist for it.\n  \n   \n2. The Second line, beginning of \"body\":\n * It starts with a Tab or *four* spaces: this tells Python that we have entered a function definition, and as lond as new lines start with Tab or spaces, Python will treat them as part of the function definition.\n * then we have a call to the built-in **print** function which has a complex argument: The argument consists of (a) string \"I got: \" [notice the space near the end of the string and think about why we put it [and try removing it and see what happens]], (b) operation + (interpreted as joining, i.e. concatenation), and (c) built-in functions of counting **str**(variable)\n \n \n3. The Third line, the \"tail\" of the function:\n * here, with -1 over the varaible, the main arithemetic of our function happens, but that is not itneresting to us. Just notice that we avoid Croatian letters in the code, so we put  \"Vracam: \", and not \"Vraćam: \". The emphasis is to avoid them in the code, but it is perfectly fine to load files into Python with Croatian letters.\n * The beginning of the line has a  **return**. This marks the end of the function and is what the function will return when  **called** (the function call with argument 53 is on the next line). This is the last line that has Tab, that is,  *indentation*. This must be like that, because **return** is an extremely strong command and Python always listens to it. If by chance part of the function remains below **return**, that part will never be executed.\n  ",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "## Block\n\n**Any line thatend with a colon is followed by at least one line that begins with Tab.** This is called a **code block*. \n\nThere are several types of blocks in Python:\n\n1. Definition of a function (we've seen that)\n2. If-branching (we'll se this now)\n3. For-loop (this will be in Notebooku 3/3)\n4. While-loop (this will be in Notebooku 3/3)\n\nIn this notebook, we will also go trough **If-branching**. \nLet's imagine that we have a simple example. We want to define a function that converts all three-digit numbers and higher into strings, and all numbers less than 10 into floats. It returns all other numbers as they are. Execute the cell below:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def fixing_nb(number):\n    if number >= 100:\n        return str(number)\n    elif broj < 10:#elif is shorten from else+if\n        return float(number)\n    else:\n        return number\n    \n#let's see if this works\nprint(fixing_nb(144))\nprint(fixing_nb(144) == \"144\")#this how you test if can't see the type from the result\nprint(fixing_nb(99))\nprint(fixing_nb(5))\n",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Let's observe the structure of the line with **if**: \n\nSo it goes **if number >= 100** (>= means \"more\" or \"less\"). This part **number >= 100** can be true or false (True, False), *dependng on what comes next for the  **number***. This is called **expression**. Let's notice the subtlety that the expression itself is not or false, but inside the code block some of its parts (in our example **number varaible**) will get a value and become true or false.",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "## Assigning values to varaibles (assignment)\n\nIn Python, it is possible to store values in variables. This is done with the sign= (rember that equačity is ==). This is an integral part of most programs. This is done as follows:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "highest_grade = 5\nlowest_grade = 1\nprint(highest_grade)",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "We notice that there is no commutativity here: it *must* be **highest_grade = 5** and not **5 = highest_grade**.\n\nIf a value is assignes to a variable inside a block of code, then it is no longer there when the block is exited, and such a varaible is called **local**:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def testing():#notice how this varaible is not recieving arguments. The () are mandatory.\n    local_variable = 42\n    print(\"Test 1\") #this should write  \"Test 1\" when function begins\n    print(local_variable) #this should wirte 42 when the function starts\n    \n\ntesting() #this starts function testing()\n",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "This works fine, but let's see what happens when it's called outside the block:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def testing():\n    local_variable = 42\n    print(\"Test 2\")\n\ntesting() #this is the launch of the function  testing() which should print \"Test 2\"\nprint(lokalna_varijabla) #this should write 42",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Python means by this that the  **local_variable** is not defined at the time it is called. Let's see how **global** variable behave when we call them inside a block:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "global_variable = 42\ndef testing():\n    print(\"Test 3\") \n    print(globa_variable) \n    \ntesting() ",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "Of course, when the varaible is defined outside the block, then we can also call it outside the block regardless of the block:",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "global_variable = 42\ndef testing():\n    print(\"Test 4\") \n\ntesting() \nprint(global_variable) ",
      "metadata": {},
      "execution_count": null,
      "outputs": []
    }
  ]
}