1_Introduction_to_Python_answered.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### About the Tutor\n",
    "\n",
    "My name is [Kasia](https://kasia.codes/) and I'm a DPhil student in Genomic Medicine and Statistics* at the [Wellcome Centre for Human Genetics](https://www.well.ox.ac.uk/), University of Oxford. I'm also the President of [NGSchool Society](https://ngschool.eu/) where with an amazing group of [people](https://ngschool.eu/people/) we try to build international community for computational biologists with training, platforms to network and exchange knowledge. Be sure to check out more on our social media ([twitter](https://twitter.com/NGSchoolEU) and [fb](https://www.facebook.com/NGSchool.eu/)) and [join us on discord](https://discord.gg/MhNeqwR).\n",
    "\n",
    "Hope you'll enjoy this workshop. If you have any questions ask me straight away by raising your hand or posting on Slack. If you are reading this outsde of the classroom, go aheas and shoot me [an email](mailto:kasia@well.ox.ac.uk) in case you have some questions. \n",
    "\n",
    "Feel free to leave your comments and/or find some bugs. Create an issue, or better yet - fix it and create a pull request. Who knows, if I get the chance I might buy you a beer as a thank you ;)\n",
    "\n",
    "\\*btw. if you're looking for a PhD, look [this one up](https://www.medsci.ox.ac.uk/study/graduateschool/courses/dtc-structured-research-degrees/genomic-medicine-and-statistics) as it is quite intresting and comes with generous funding! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://imgs.xkcd.com/comics/python.png)\n",
    "\n",
    "\n",
    "The tiltle of the [graphic](https://imgs.xkcd.com/comics/python.png): _I wrote 20 short programs in Python yesterday. It was wonderful. Perl, I'm leaving you._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python advantages, or in other words \"Why Python?\"**\n",
    "\n",
    "1. Easy to read, easy to learn.\n",
    "\n",
    "    The code you write in Python resembles instructions you would give to someone (here: computer) in English. Behind the curtain the code is automatically converted to a set of instructions your computer understands.\n",
    "\n",
    "2. Vast repository of libraries providing necessary extensions.\n",
    "\n",
    "    As in the comic above - if you need sth, there's probably a package in Python with the tools you need. Just import it `import some_package` and you're good to go.\n",
    "\n",
    "3. Portable throughout platforms.\n",
    "\n",
    "    Provided that the code is run with the same version - it should run exactly the same on Linux, Widnows or Mac machines. \n",
    "\n",
    "4. It's easy to leverage other languages speed (such as C/C++ or others) by combining it with Python code.\n",
    "\n",
    "    There are still some moments where Python is not as quick as we would need it to be. But, it's super easy to implement C for example. According to Python Manual _It is quite easy to add new built-in modules to Python, if you know how to program in C. Such extension modules can do two things that can’t be done directly in Python: they can implement new built-in object types, and they can call C library functions and system calls._ (you can read more [here](https://docs.python.org/3.7/extending/extending.html)). But even if you do not know how to write in C you still can benefit from its speed by using [Cython](https://cython.org/) - you have to slightly adjust your code (for one, define variable types) and run Cython extension which will translate as much as it can to C. Et voila!\n",
    "\n",
    "5. Python is object-oriented.\n",
    "\n",
    "    Everything in Python is an object which helps in solving complex problems. At the beginning it might be a bit hard to wrap your head around this, but don't worry - it gets easier!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "Welcome to this **Introduction to Python** and basic tools necessary for data analysis. The idea of this workshop is to show you how things are done in Python, how to load the tools and learn to use them, but mostly give you a flavor of Python's possibilities and show you where to find help.  \n",
    "\n",
    "We will be working with Python3, in Jupyter and we will be using the following packages:\n",
    "\n",
    "* [NumPy](https://www.numpy.org/) - *the fundamental package for scientific computing with Python*\n",
    "* [Pandas](https://pandas.pydata.org/) - *library providing high-performance, easy-to-use data structures and data analysis tools for the Python programming*\n",
    "* [SciPy](https://www.scipy.org/) -  *Python-based ecosystem of open-source software for mathematics, science, and engineering*\n",
    "* [Matplotlib](https://matplotlib.org/) - *2D plotting library which produces publication quality figures*\n",
    "\n",
    "### Outline\n",
    "1. Basics\n",
    "    1. Variable and types\n",
    "    2. Lists and more\n",
    "    3. Controlling the flow \n",
    "    4. Functions\n",
    "    5. Modules\n",
    "2. Data analysis\n",
    "    1. Reading in and descriptive analysis with Numpy and Pandas\n",
    "    2. Data exploration with SciPy\n",
    "    3. Plotting with Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Short note on code styling__\n",
    "\n",
    "The very best advice I got about how to write code and which style to use was that it doesn't matter which style you use as long as you are consitent! So I try to be.  \n",
    "\n",
    "If you want to read more on recommended styling - you can read the [PEP 8 Style Guide](https://www.python.org/dev/peps/pep-0008/). \n",
    "\n",
    "I name my variables usualy with `lower_snake` case, but as long as you're consistant and create names that mean something you can do whatever you want! If you want advice on how to name things, have a look at [those slides by Jenny Bryan](https://speakerdeck.com/jennybc/how-to-name-files).\n",
    "\n",
    "<a href=\"https://github.com/allisonhorst/stats-illustrations\"><img src=\"https://raw.githubusercontent.com/allisonhorst/stats-illustrations/master/other-stats-artwork/coding_cases.png\" alt=\"In that case - naming styles guide\" style=\"width: 600px;\"/></a>\n",
    "\n",
    "Artwork by [@allison_horst](https://twitter.com/allison_horst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## Basics\n",
    "\n",
    "Historically, the first thing you *ought* to do in any given programming language is to print the *Hello world!* statement. In order to this in Python3 you just call a *function* - print() and provide it with an *string argument*, as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Kasia!\n"
     ]
    }
   ],
   "source": [
    "# Now it's your turn. write line of code that will print a greeting to you. \n",
    "# In my case, that would be print(\"Hello Kasia!\") which will print \"Hello Kasia!\".\n",
    "# Type it here and press run.\n",
    "print(\"Hello Kasia!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comments**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everytime we write code we strive to make it self-explanatory. However, whenever you want to describe what your code does you shoudl use comments. In my book - more often it's better to elave too much comments than to comment too vaguely."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "# Text proceeded with the hashtag sign (#) are not executed and serve as comemnts.\n",
    "\n",
    "# There are also special kind of comments - so called docstrings.\n",
    "# You'll find them inside functions, they are use to translate \n",
    "# the comment into the proper docummentation. \n",
    "\n",
    "def add_two_numbers(a, b):\n",
    "    \"\"\"Adds two integers.\n",
    "    Args:\n",
    "        two integers\n",
    "    Returns:\n",
    "        sum of the arguments\n",
    "    \"\"\"\n",
    "    int(a) + int(b)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### Variables and Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are defined by single ' ' or double \" \" quotations.  \n",
    "We assign value to variable by writing its desired name (no white spaces!) followed by equal sign and the value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my string\n"
     ]
    }
   ],
   "source": [
    "my_string = 'This is my string'\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_string) # string lenght"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access each character from a string. Nothe that Python counts from 0, that means that if you want to access T from `mystring` you need to call for position 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'T'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also get the characters from the end. Again, we are counting from the start, but to the left. I.e., to access last character we need to call for -1, second to last -2 and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access slices of a string..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'T'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string[-0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and create new strings by using `+` and `*` operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my string\n"
     ]
    }
   ],
   "source": [
    "my_new_string = my_string + ' that I changed!'\n",
    "my_newer_string = my_string * 3\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my string that I changed!\n"
     ]
    }
   ],
   "source": [
    "print(my_new_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is my stringThis is my stringThis is my string\n"
     ]
    }
   ],
   "source": [
    "print(my_newer_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are few methods specific for strings that will come in handy in your everyday programming. Let me quickly introduce those. \n",
    "\n",
    "* `find(pattern)` - Finds the start position of the pattern; returns -1 if no match;\n",
    "* `replace(pattern, replacement)` - Replaces all occurences of a pattern with replacement;\n",
    "* `upper()`, `lower()` - converts to upper or lowercase;\n",
    "* `strip(character)` - strip string of a character (removes occurence of the character at the beggining and end of a string; \n",
    "* `rstrip()` - strips trsings of whitespace characters on the right side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Kasia!\n"
     ]
    }
   ],
   "source": [
    "hello_kasia = 'Hello Kasia!'\n",
    "hello_adam = hello_kasia.replace('Kasia', 'Adam')\n",
    "print(hello_kasia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Adam!\n"
     ]
    }
   ],
   "source": [
    "print(hello_adam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['B', ' yours', 'lf; ', 'v', 'ryon', ' ', 'ls', ' is alr', 'ady tak', 'n.']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deep_quote = 'Be yourself; everyone else is already taken.'\n",
    "deep_quote.split('e')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply more than one method of an object. The methods are executed from left to right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['\"two',\n",
       " 'things',\n",
       " 'are',\n",
       " 'infinite:',\n",
       " 'the',\n",
       " 'universe',\n",
       " 'and',\n",
       " 'human',\n",
       " 'stupidity;',\n",
       " 'and',\n",
       " \"i'm\",\n",
       " 'not',\n",
       " 'sure',\n",
       " 'about',\n",
       " 'the',\n",
       " 'universe.\"']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_deep_quote = '\"Two things are infinite: the universe and human stupidity; and I\\'m not sure about the universe.\"\\n'\n",
    "another_deep_quote.rstrip().lower().split(' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same thing can be achieved if we create intermediate variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['\"two',\n",
       " 'things',\n",
       " 'are',\n",
       " 'infinite:',\n",
       " 'the',\n",
       " 'universe',\n",
       " 'and',\n",
       " 'human',\n",
       " 'stupidity;',\n",
       " 'and',\n",
       " \"i'm\",\n",
       " 'not',\n",
       " 'sure',\n",
       " 'about',\n",
       " 'the',\n",
       " 'universe.\"']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_deep_quote_stripped = another_deep_quote.rstrip()\n",
    "another_deep_quote_stripped_and_lower = another_deep_quote_stripped.lower()\n",
    "another_deep_quote_stripped_lower_and_split = another_deep_quote_stripped_and_lower.split(' ')\n",
    "another_deep_quote_stripped_lower_and_split"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one last important function worth mentioning here. We can `format()` the strings by using other strings (not only strings, but we will talk about this later) as arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# before we start, type in your name here\n",
    "your_name = \"Kasia\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Kasia! Hope you are enjoying this Python class. :)'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello %s! Hope you are enjoying this %s class. :)' % (your_name, 'Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Kasia! Hope you are enjoying this Python class. :)'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is equivalent to the following:\n",
    "'Hello {yname}! Hope you are enjoying this {lang} class. :)'.format(yname = your_name, lang = 'Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Kasia! Hope you are enjoying this Python class. :)'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lang = 'Python'\n",
    "f'Hello {your_name}! Hope you are enjoying this {lang} class. :)'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_integer = 1\n",
    "my_float = 2.34567"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(my_integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.34567\n"
     ]
    }
   ],
   "source": [
    "print(my_float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.34567"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_float + my_integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Using Python as a calculator**\n",
    "\n",
    "Now, that we know a little about numbers and how to assign variables we can learn how to use Python as a calculator. \n",
    "\n",
    "Basic operations:\n",
    "\n",
    "|Operator|Operation|\n",
    "|:--:|---|\n",
    "|+|addition|\n",
    "|-|substration|\n",
    "|\\*|multiplication|\n",
    "|/|division|\n",
    "|//|floor division|\n",
    "|%|modulo|\n",
    "|\\*\\*|power|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise**\n",
    "Multiply the reminder of division 456 by 87 by 21 and raise it to the power of 3. Get the floor division of this number by 11. Save the result to a variable *result*.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your formula here\n",
    "result = (456 % 87 * 21) ** 3 // 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Did it work?\n",
    "result == 7796920"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Side Note: On numbers and precision**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numbers in computers are represented as a base of 2, not a base of 10 like we are used to in everyday life. What that means is that sometimes computer will store an aproximation of a number, rather than an exact number.   \n",
    "\n",
    "For example 10 will be represented as 1 x 8, 0 x 4, 1 x 2 and 0 x 1 rather than 1 x 10 and 0 x 1. That generates difficulties when we want to store a decimal number.   \n",
    "\n",
    "In order to store 1/10 in the base 2 system we would have to save it as an infinite sum.\n",
    "\n",
    "1/10 = 1/16 + 1/32 + 1/256 + 1/512 ... \n",
    "\n",
    "Therefore, 1/10 in our computers is only an approximation. You can read more about this [here](https://docs.python.org/3/tutorial/floatingpoint.html).\n",
    "\n",
    "That's why:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is not true\n",
    "0.1 + 0.1 + 0.1 == 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nor is this\n",
    "round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But this is\n",
    "round(0.1 + 0.1 + 0.1, 10) == round(0.3, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Mixing numbers and strings\n",
    "We can assign more than one variable at a time. We do that by separating each of the assignment with comma. Note, that the number of variable names and values has to be equal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.01\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 1, 2.01, 'three'\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, we can convert a number to a string, for example to check how many digits has a really big number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2713"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's check length of a big number\n",
    "big_number = 23 ** 1992\n",
    "len(str(big_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similiarly of course we can transform string to a number. This might come in handy while extracting a number from text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = str(int('1234') + 56)\n",
    "b = int('1234' + str(56))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is a equal b? What's the difference? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# To check your answer print both numbers\n",
    "print(a == b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1290\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### Lists and more"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, ['three', 4], 5.5] \n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with the strings, we can access the elemnts of the list from left and right side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "print(my_list[1:]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, ['three', 4]]\n"
     ]
    }
   ],
   "source": [
    "print(my_list[1:3]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(my_list[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "# Note, this will get us elemnts at position 3 and 4\n",
    "print(my_list[-2:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, ['three', 4], 5.5, 1, 2, ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "print(my_list * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can modify elements of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'seven', ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "my_list[1] = 'seven'\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list2 = my_list\n",
    "my_list2[0] = '1'\n",
    "my_list2[1] = \"second_element\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', 'second_element', ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list3 = my_list.copy()\n",
    "my_list3[0] = \"seventy_seven\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['seventy_seven', 'second_element', ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "print(my_list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', 'second_element', ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and add elements to the list by creating a new one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', 'second_element', ['three', 4], 5.5, 'new element']\n",
      "['1', 'second_element', ['three', 4], 5.5]\n"
     ]
    }
   ],
   "source": [
    "my_new_list = my_list + ['new element'] \n",
    "print(my_new_list) # the new list has the new element\n",
    "print(my_list) # however the original list was left unchanges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to modify the list on the fly, we can add new element with the `append()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', 'second_element', ['three', 4], 5.5, 'new element']\n"
     ]
    }
   ],
   "source": [
    "my_list.append('new element')\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `append()` always add its argument as a new element. Therefore, if we want a list as an element of our list we can do that with append. On the other hand, if we want to add multiple elements to a list - we should rather use `extend()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', 'second_element', ['three', 4], 5.5, 'new element', [1, 2, 3, 4]]\n"
     ]
    }
   ],
   "source": [
    "my_list.append([1,2,3,4])\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', 'second_element', ['three', 4], 5.5, 'new element', [1, 2, 3, 4], 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "my_list.extend([1,2,3,4])\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise:** Given a list `names = ['Kasia', 'Jasio', 'Zuzia', 'Amelka']` answer the following questions:\n",
    "\n",
    "* What will `names[-2]` output?\n",
    "* What will `sorted(names)[1]` ourput?\n",
    "* What will the following command  - `len(names[1:3])` equeal to?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Don't run the code below until you try answering the questions!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Kasia', 'Jasio', 'Zuzia', 'Amelka']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Zuzia'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names[-2] # 'Zuzia'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jasio'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(names)[1] # 'Jasio'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(names[1:3]) # 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are similiar to lists - they are a collection of items separated by commas and enclosed in parenthesis - (). Their elements can be accessed by their position, however, unlike lists their shape is constant. They cannot be updated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3, 4)\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(my_tuple[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(my_tuple[1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "print(my_tuple * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# my_tuple.append(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets are special collection in Python - they are unordered, unindexed and all their entires are unique. We create sets by using curly brackets {} or by using the `set()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a', 'b', 3}\n"
     ]
    }
   ],
   "source": [
    "my_set = {'a', 'b', 3, 'b'}\n",
    "my_set2  = set(['a', 'b', 3, 'b'])\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a', 'b', 3}\n"
     ]
    }
   ],
   "source": [
    "print(my_set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sets cannot be accessed as list - they are unordered and unindexed. Uncomment the following two lines and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# my_set[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(my_set * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, similiarly to lists, we can add items to the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a', 'b', 3, 7}\n"
     ]
    }
   ],
   "source": [
    "my_set.add(7) # one element at the time\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a', 1, 2, 3, 7, 'b', 'g', 'f'}\n"
     ]
    }
   ],
   "source": [
    "my_set.update([1, 2, 'f', 'g']) # multiple items at once\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries\n",
    "For people that have some experience with programming one might say that Python's dictionaries are kind of hash-table type. They work like associative arrays or hashes found in Perl. For others, with no background I like to say that the name - dictionary describes this type quite well. Dictionaries work in a way a real-life dictionary works - you can look up a value by it's key. You can look up a value (for example the translation od a word) by it key - this word in the language you know. \n",
    "\n",
    "We create dictionares with curly brackets {}, however, unlike with sets - we provide key and a value for each item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'me': 'ja', 'you': 'ty', 'he': 'on', 'she': 'ona', 'hi': 'czesc'}\n"
     ]
    }
   ],
   "source": [
    "my_dictionary = {\n",
    "    'me': 'ja', \n",
    "    'you': 'ty', \n",
    "    'he': 'on', \n",
    "    'she': 'ona', \n",
    "    'hi': 'czesc'\n",
    "}\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create a dictionary using a `dict()` function, the argument of the function has to be a sequence of (key, value) tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 1, 'two': 2, 'three': 3}\n"
     ]
    }
   ],
   "source": [
    "d = [('one', 1), ('two', 2), ('three', 3)]\n",
    "d_dict = dict(d)\n",
    "print(d_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check how to say you in Polish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ty'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dictionary['you']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add new entries to the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'me': 'ja', 'you': 'ty', 'he': 'on', 'she': 'ona', 'hi': 'czesc', 'ice cream': 'lody', 'pizza': 'pizza'}\n"
     ]
    }
   ],
   "source": [
    "my_dictionary['ice cream'] = 'lody'\n",
    "my_dictionary['pizza'] = 'pizza'\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the same way we can modify entries in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'me': 'ja', 'you': 'ty', 'he': 'on', 'she': 'ona', 'hi': 'czesc', 'ice cream': 'lody', 'pizza': 'wloski placek'}\n"
     ]
    }
   ],
   "source": [
    "my_dictionary['pizza'] = 'wloski placek' # roughly translates to italian pie\n",
    "print(my_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access all the keys by calling `keys()` function on our dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['me', 'you', 'he', 'she', 'hi', 'ice cream', 'pizza'])\n"
     ]
    }
   ],
   "source": [
    "print(my_dictionary.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also access all the values by calling `values()` function on our dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['ja', 'ty', 'on', 'ona', 'czesc', 'lody', 'wloski placek'])\n"
     ]
    }
   ],
   "source": [
    "print(my_dictionary.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise**: You need to save few phone numbers of your friends (Kasia +48300200100, Maja +48564763562, Jacek +48600500400). Which of the above will you use to quickly access those numbers?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-75-9045996fa056>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-75-9045996fa056>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    phone_book =\u001b[0m\n\u001b[0m                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Create your phonebook here\n",
    "phone_book = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise:** You have a long list of duplicate entries. How will you remove duplciates and create a new list with only unique values?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n"
     ]
    }
   ],
   "source": [
    "long_list_of_duplicates = [1, 7, 1, 2, 3, 5, 16, 7, 8, 17, 13, 23, 21, 34, 55, 23, 89, 1, 2, 3, 34, 4, 5, 6, 34, 7, 8, 4, 9, 10, 21, 11, 12, 13]\n",
    "print(len(long_list_of_duplicates)) # 34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create your new list\n",
    "new_list = list(set(long_list_of_duplicates))\n",
    "\n",
    "# test\n",
    "len(new_list) == 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*** \n",
    "### Controlling the flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logic in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical operators in Python:\n",
    "* `True`, `False` are respectively equal to `1` and `0`;\n",
    "* all objects have boolean value, and exept for `False`, `0`, `None` or empty collections (`\"\"`, `[]`, `{}` and `()`) every other objects are `True`;\n",
    "* `and` - both values have to be true for it to be true;\n",
    "* `or` - at least one turth makes the statement true;\n",
    "* `not` - negation of the value;\n",
    "* `is` - checks if are the same object;\n",
    "* comparisons:   \n",
    "\n",
    "| symbol | meaning |  \n",
    "| --- | --- |  \n",
    "| == | is equal|  \n",
    "| != | is not equal|  \n",
    "| > | greater than|  \n",
    "| >= | greater or equal to|  \n",
    "| < | less than|  \n",
    "| <= | less or euqal to|  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definitions\n",
    "a = True\n",
    "b = False\n",
    "c = d = 1\n",
    "true_statement = d > 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`1` is equal to `True` but those are two different objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(a == c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(a is c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(c is d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(a != b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print((a or b) and (a and not b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objects do evaluate as either `True` or `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3] is true.\n"
     ]
    }
   ],
   "source": [
    "not_empty_list = [1, 2, 3]\n",
    "if len(not_empty_list) > 0:\n",
    "    print(\"{} is true.\".format(not_empty_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] isn't.\n"
     ]
    }
   ],
   "source": [
    "empty_list = []\n",
    "if not empty_list:\n",
    "    print(\"{} isn't.\".format(empty_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "however they act a bit differently when used within logical opperations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(not(False or False) or 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not(247 % 5 or 234 % 2) or 1 == 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(not(247 % 5 or 234 % 2) or [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise:** Answer the following questions:\n",
    "\n",
    "* What is the result of 10 == “10”\n",
    "* What is the result of not(True or False)?\n",
    "* What is the result of not 'bag'?\n",
    "* Tricky question: What is the result of “bag” > “apple”?  Why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Don't run the following before you try answering the questions!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(10 == \"10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not(True or False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not 'bag')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"bag\" > \"apple\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditions: `if`, `else` and `elif`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic statement controlling flow is the statement if - If certain condition is met do sth. For example, if you input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please, provide a number greater than 0:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hmm, 0 is not greater than 0!\n"
     ]
    }
   ],
   "source": [
    "x = int(input('Please, provide a number greater than 0: '))\n",
    "if x > 0:\n",
    "    print('Thanks!')\n",
    "else:\n",
    "    print('Hmm, {} is not greater than 0!'.format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please, provide a number greater than 0:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hmm, 0 is 0, therefore not greater than 0!\n"
     ]
    }
   ],
   "source": [
    "x = int(input('Please, provide a number greater than 0: '))\n",
    "if x > 0:\n",
    "    print('Thanks!')\n",
    "elif x == 0:\n",
    "    print('Hmm, {} is 0, therefore not greater than 0!'.format(x))\n",
    "else:\n",
    "    print('Hmm, {} is not greater than 0!'.format(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops: `for` and `while`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Those statements allow us to repeat a certain procedure over an iteration of sorts. For example, let's say that for every odd number lower than 10 we would want to learn the value of this number taken to the power of 3. We can do it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "27\n",
      "125\n"
     ]
    }
   ],
   "source": [
    "print(1**3)\n",
    "print(3**3)\n",
    "print(5**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and so on. Or, we can write it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "27\n",
      "125\n",
      "343\n",
      "729\n"
     ]
    }
   ],
   "source": [
    "# range(1, 10, 2) takes a range from 1 to 10 and takes every other number\n",
    "for i in range(1, 10, 2):\n",
    "    print(i**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By modifying the above example we can get the sum of all odd numbers bigger than 0 and smaller than 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12497500\n"
     ]
    }
   ],
   "source": [
    "odd_sum = 0\n",
    "for i in range(1, 100, 2):\n",
    "    odd_sum += i**3 # += is an abbreviation for odd_sum = odd_sum + i**3\n",
    "    \n",
    "print(odd_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other statement that allows us to execute the same command multiple times is the statement `while`. You can think of this as - while something is true, do this. Coming back to our example from earlier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please, provide a number greater than 0:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are still looking for a number greater than zero ;)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please, provide a number greater than 0:  1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thanks!\n"
     ]
    }
   ],
   "source": [
    "is_greater = False\n",
    "while not is_greater:\n",
    "    x = int(input('Please, provide a number greater than 0: '))\n",
    "    if x > 0:\n",
    "        is_greater = True\n",
    "    else:\n",
    "        print('We are still looking for a number greater than zero ;)')\n",
    "print('Thanks!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### More control flow tools: `continue` and `break`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `break` statement breaks out of the looop, i.e. stop any following iterations of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please, provide a number greater than 0:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are still looking for a number greater than zero ;)\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please, provide a number greater than 0:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thanks!\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    x = int(input('Please, provide a number greater than 0: '))\n",
    "    if x > 0:\n",
    "        break\n",
    "    else:\n",
    "        print('We are still looking for a number greater than zero ;)')\n",
    "print('Thanks!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example of a `break` statement. Note, `break` only influences the loop it was put into."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 is a prime number\n",
      "3 is a prime number\n",
      "4 equals 2 * 2\n",
      "5 is a prime number\n",
      "6 equals 2 * 3\n",
      "7 is a prime number\n",
      "8 equals 2 * 4\n",
      "9 equals 3 * 3\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            print(n, 'equals', x, '*', n // x)\n",
    "            break # breaks out of the second for loop\n",
    "    else:\n",
    "        # loop fell through without finding a factor\n",
    "        print(n, 'is a prime number')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`continue` goes to another iteration skipping the remainder of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found an even number 2\n",
      "Found an odd number 3\n",
      "Found an even number 4\n",
      "Found an odd number 5\n",
      "Found an even number 6\n",
      "Found an odd number 7\n",
      "Found an even number 8\n",
      "Found an odd number 9\n"
     ]
    }
   ],
   "source": [
    "for num in range(2, 10):\n",
    "    if num % 2 == 0:\n",
    "        print(\"Found an even number\", num)\n",
    "        continue # next line will not get executed if this is reached\n",
    "    print(\"Found an odd number\", num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found an even number 2\n",
      "Found an odd number 3\n",
      "Found an even number 4\n",
      "Found an odd number 5\n",
      "Found an even number 6\n",
      "Found an odd number 7\n",
      "Found an even number 8\n",
      "Found an odd number 9\n"
     ]
    }
   ],
   "source": [
    "for num in range(2, 10):\n",
    "    if num % 2 == 0:\n",
    "        print(\"Found an even number\", num)\n",
    "    else:\n",
    "        print(\"Found an odd number\", num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise:** Write a loop that will print the following pattern:  \n",
    " 1    \n",
    "22  \n",
    "333  \n",
    "4444  \n",
    "55555  \n",
    "666666  \n",
    "7777777  \n",
    "88888888  \n",
    "999999999  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "22\n",
      "333\n",
      "4444\n",
      "55555\n",
      "666666\n",
      "7777777\n",
      "88888888\n",
      "999999999\n"
     ]
    }
   ],
   "source": [
    "# write your code here\n",
    "for i in range(1, 10):\n",
    "    print(str(i) * i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many [built-in functions in Python](https://docs.python.org/3/library/functions.html), there is a universe of those available in various packages. That said, sometimes we need to do an operation that is really specific, or simply not worth loading a whole package. Any operation that can be put into function, most likely should be put into a function. Functions in Python are defined with `def` statement as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(function_arguments):\n",
    "    # the body of the function. i.e. what it should do with the arguments\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, a simple function performing addition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    # adds two numbers\n",
    "    print(\"The sum of a = {} and b = {} is equal to {}\".format(a, b, a + b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, that we can provide arguments by possition, or by name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of a = 1 and b = 4 is equal to 5\n"
     ]
    }
   ],
   "source": [
    "add(1, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of a = 1 and b = 4 is equal to 5\n"
     ]
    }
   ],
   "source": [
    "add(b = 4, a = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that a and b inside the function are local and inside the function, they overwride whatever other variables you can have defined globally. However, the excecution of the function will not change those variables in your global eniroment. That said, it's better to call variables with a bit more inforative names than a and b, and to also avoid using the same name for different things."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of a = 7 and b = 5 is equal to 12\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "b = 7\n",
    "add(b, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, a let's look at another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's write a function that calculates an arithmetic mean \n",
    "def arithmetic_mean(input_numbers):\n",
    "    # input_numbers is a list\n",
    "    return sum(input_numbers) / len(input_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can use our function in a loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2550485896.8561983\n"
     ]
    }
   ],
   "source": [
    "even_numbers = range(2, 100, 2)\n",
    "s = 0\n",
    "for number in even_numbers:\n",
    "    s += arithmetic_mean([number, s])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviosly, this will still work if you wouldn't create a function. However, the function adds to readebilty of the code as well, as to its potential for development."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2550485896.8561983\n"
     ]
    }
   ],
   "source": [
    "even_numbers = range(2, 100, 2)\n",
    "s = 0\n",
    "for number in even_numbers:\n",
    "    s += sum([number, s]) / len([number, s])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Side note: testing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When writing a function - it's always good to think of what you expect and what potential errors can arrisen while executing the code. This helps prevent your code from crushing. It also allows you to print more human readable error messages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arithmetic_mean_long(input_numbers):\n",
    "    \"\"\"Calculates arithmetic mean\n",
    "    Args:\n",
    "        List of numbers\n",
    "    Returns:\n",
    "        Arithmetic mean\n",
    "    \"\"\"\n",
    "    try:\n",
    "        result = sum(input_numbers) / len(input_numbers)\n",
    "    except TypeError:\n",
    "        not_numbers = [number for number in input_numbers if isinstance(number, (int, float)) == False]\n",
    "        print('ERROR: Input must contain only numbers! Those are not numbers: {}'.format(not_numbers))\n",
    "    except ZeroDivisionError:\n",
    "        print('ERROR: Input cannot be empty!')\n",
    "    else:\n",
    "        return result "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test1 = [1, 2, 3, 4, 5]\n",
    "arithmetic_mean(test1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arithmetic_mean_long(test1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-117-fabbbbe442db>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtest2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'4'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'5'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0marithmetic_mean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-111-77cfb631c1ec>\u001b[0m in \u001b[0;36marithmetic_mean\u001b[0;34m(input_numbers)\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0marithmetic_mean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_numbers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;31m# input_numbers is a list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_numbers\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_numbers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "test2 = [1, 2, 3, '4', '5']\n",
    "arithmetic_mean(test2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ERROR: Input must contain only numbers! Those are not numbers: ['4', '5']\n"
     ]
    }
   ],
   "source": [
    "arithmetic_mean_long(test2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-119-4368f7f3f053>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtest3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0marithmetic_mean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-111-77cfb631c1ec>\u001b[0m in \u001b[0;36marithmetic_mean\u001b[0;34m(input_numbers)\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0marithmetic_mean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_numbers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;31m# input_numbers is a list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_numbers\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_numbers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "test3 = []\n",
    "arithmetic_mean(test3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ERROR: Input cannot be empty!\n"
     ]
    }
   ],
   "source": [
    "arithmetic_mean_long(test3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules are what, in opinion, Python so good. They provide the needed extensions to the really nice language. Within modules you can find solutions to many of your problems and tasks. \n",
    "\n",
    "Let me introduce few crucial modules, some of them come with Pyton installation, some you have to install on your own.\n",
    "\n",
    "Standard Library (i.e. modules that come with Python):\n",
    "* [os](https://docs.python.org/3/library/os.html) - provides multiple OS interfaces \n",
    "* [re](https://docs.python.org/3/library/re.html?highlight=re#module-re) -module for regular expressions\n",
    "* [math](https://docs.python.org/3/library/math.html) - math operations extension (includes rounding up, calculating factorials and much more)\n",
    "* [statistcs](https://docs.python.org/3/library/statistics.html) - some statistical functions - among others facilitates mode, medians etc. calculations\n",
    "* [random](https://docs.python.org/3/library/random.html?highlight=random#module-random) - *generates pseudo-random numbers*\n",
    "* [collections](https://docs.python.org/3/library/collections.html) - extensions of the basics colllections\n",
    "* [itertools](https://docs.python.org/3/library/itertools.html) - great module for various iteration and efficient looping\n",
    "* [multiprocessing](https://docs.python.org/3/library/multiprocessing.html) - module allowing parallel computing\n",
    "* [logging](https://docs.python.org/3/library/logging.html) - module allowing to generte nice and comprehensive messages\n",
    "\n",
    "and much more you can find descrribed [here](https://docs.python.org/3/library/).\n",
    "\n",
    "Other crucial modules: \n",
    "\n",
    "* [NumPy](https://www.numpy.org/) - *the fundamental package for scientific computing with Python*\n",
    "* [Pandas](https://pandas.pydata.org/) - *library providing high-performance, easy-to-use data structures and data analysis tools for the Python programming*\n",
    "* [SciPy](https://www.scipy.org/) -  *Python-based ecosystem of open-source software for mathematics, science, and engineering*\n",
    "* [Matplotlib](https://matplotlib.org/) - *2D plotting library which produces publication quality figures*\n",
    "* [Tensorflow](https://www.tensorflow.org/) - *An end-to-end open source machine learning platform*\n",
    "* [Keras](https://keras.io/) - *The Python Deep Learning library*\n",
    "* [scikit-learn](https://scikit-learn.org/stable/) - *Machine Learning in Python*\n",
    "* [Scrapy](https://scrapy.org/) - *An open source and collaborative framework for extracting the data you need from websites. In a fast, simple, yet extensible way.*\n",
    "* [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) - module for xml and html parsing\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can import whole modules by using `import <module_name>` statement. We usually place them at the very begining of the script in order to specify what modules the following code relies on. We can access the functions can be accessed by preceeding the function name with the module name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "print(random.randint(1,19))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we only need some functions from a module, we can load only those by using `from <module_name> import <function>` statement as follows. The functions then can be access without referring to the module name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "from math import pi, ceil\n",
    "print(pi)\n",
    "print(ceil(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In that way we can also load all functions from within the module by using `from <module_name> import *` statement. In this case, we also don't have to proceed the functions names with the module name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "print(factorial(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And lastly, we can create an abbreviation for a given module and only proceed the functions with this abbreviation by usint `import <module_name> as <module_abbrev>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "import statistics as st\n",
    "print(st.median([1, 3, 5, 7]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise:** Write a function called fizz_buzz that takes a number and:\n",
    "* If the number is divisible by 3, it should print “Fizz”.\n",
    "* If it is divisible by 5, it should print “Buzz”.\n",
    "* If it is divisible by both 3 and 5, it should print“FizzBuzz”.\n",
    "* Otherwise, it should print the same number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here\n",
    "def fizz_buzz(numb):\n",
    "    mod_three = numb % 3 \n",
    "    mod_five = numb % 5\n",
    "    \n",
    "    if mod_three > 0 and mod_five > 0:\n",
    "        return(numb)\n",
    "    elif not mod_three:\n",
    "        if not mod_five:\n",
    "            return(\"FizzBuzz\")\n",
    "        else:\n",
    "            return(\"Fizz\")\n",
    "    else:\n",
    "        return(\"Buzz\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fizz'"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# and test it\n",
    "fizz_buzz(9) # Fizz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Buzz'"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fizz_buzz(25) # Buzz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'FizzBuzz'"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fizz_buzz(15) # FizzBuzz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fizz_buzz(13) # 13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Excercise:** Write a function for checking the speed of drivers. This function should have one parameter: speed. \n",
    "* If speed is less than 70, it should print “Ok”.\n",
    "* Otherwise, for every 5km above the speed limit (70), it should give the driver one demerit point and print the total number of demerit points. For example, if the speed is 80, it should print: “Points: 2”.\n",
    "* If the driver gets more than 12 points, the function should print: “License suspended”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here\n",
    "def check_the_speed(speed):\n",
    "    if speed <= 70:\n",
    "        return(\"Ok\")\n",
    "    \n",
    "    points = (speed - 70) // 5 + ((speed - 70) % 5 > 0)\n",
    "    \n",
    "    if points < 12:\n",
    "        return(f'Points: {points}')\n",
    "    else:\n",
    "        return('Licence suspended')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ok'"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's test it:\n",
    "check_the_speed(64) # Ok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Points: 1'"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_the_speed(71) # Points: 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Points: 3'"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_the_speed(83) # Points: 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Licence suspended'"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_the_speed(131) # Licence suspended"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resources\n",
    "\n",
    "## Books\n",
    "* [Python for Data Analysis](https://www.oreilly.com/library/view/python-for-data/9781491957653/)\n",
    "* [Python in a Nutshell](http://shop.oreilly.com/product/0636920012610.do)\n",
    "* [Think Python: How to Think Like a Computer Scientist](http://greenteapress.com/thinkpython/html/index.html) - wole book available online\n",
    "* [A Byte of Python](https://python.swaroopch.com/) - whole book available online\n",
    "\n",
    "## Interactive courses\n",
    "* [Learn Python](https://www.learnpython.org/)\n",
    "* [A Python crash course](https://www.grahamwheeler.com/posts/python-crash-course.html) - This one is aimed at people already programming in Java\n",
    "* [Python for beginners](http://opentechschool.github.io/python-beginners/en/index.html)\n",
    "* [Tech Dev Guide by Google](https://techdevguide.withgoogle.com/) - Google resources for learning and advancing your programming skills\n",
    "* [Courses in Python on edX](https://www.edx.org/learn/python)\n",
    "* [Codeacademy - Python3](https://www.codecademy.com/learn/learn-python-3) - unfortunately behind a paywall\n",
    "* [10 Minutes to Pandas](https://pandas.pydata.org/pandas-docs/stable/getting_started/10min.html)\n",
    "* [Exploratory Data Anylyses with Pandas and Numpy](https://www.grahamwheeler.com/posts/exploratory-data-analysis-with-numpy-and-pandas.html)\n",
    "\n",
    "## Online IDEs\n",
    "* [Repl](https://repl.it/languages/python3)\n",
    "\n",
    "## Other\n",
    "* [List of resources on Hackr.io](https://hackr.io/tutorials/learn-python)\n",
    "* [Python excercises for beginners](https://programmingwithmosh.com/python/python-exercises-and-questions-for-beginners/)"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}