S01b_Intro_Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Execute before using this notebook if using google colab\n",
    "\n",
    "kernel = str(get_ipython())\n",
    "\n",
    "if 'google.colab' in kernel:    \n",
    "    !wget https://raw.githubusercontent.com/fredzett/rmqa/master/utils.py -P local_modules -nc \n",
    "    !npx degit fredzett/rmqa/data data\n",
    "    import sys\n",
    "    sys.path.append('local_modules')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we will cover some basic aspects of **Python**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the course of this class we will then gradually introduce new programming/python concepts and/or python modules (don't worry if you don't know what this means, yet) that help us in our data analysis journey. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will not be able to cover all aspects of Python and will only see a tiny fraction of what you can do with Python - both for data analysis and for general programming. \n",
    "\n",
    "Also note that there are many ways to achieve the same thing in programming. Often times there is no such thing as *the* one right approach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should also use alternative sources to broaden and/or deepen your knowledge about Python. Here are some examples:\n",
    "\n",
    "- **tutorials**: there is a myriad of Python tutorials, e.g. [this one](https://www.w3schools.com/python/python_intro.asp) \n",
    "\n",
    "- **stackoverflow**: if you get stuck with a coding issue you can almost be certain that someone before has run into the same issue and posted a question on [stackoverflow](https://stackoverflow.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Important Note**  \n",
    "> Don't worry if you find yourself struggling to understand all the things at first. Learning to program takes some time and it is completely normal that some of the concepts seem to be difficult at first. But stick with it as you will see that eventually things become more clear. You will also realize how much more you can achieve in empirical academic research and/or business when knowing how to handle data efficiently. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mathematical expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Programming languages are just like any other (human) language. Except that they are much easier and more precise. There are, of course, some rules of grammar that needs to be understood and learned. \n",
    "\n",
    "Perhaps the most easy rules are those of math which can be used in Python (and most other programming language) using `math operators`.\n",
    "\n",
    "Overview of common mathematical expressions:\n",
    "\n",
    "| Epression Type  \t| Operator \t|  Example \t|   Value \t|\n",
    "|----------------\t|:--------:\t|:--------:\t|--------:\t|\n",
    "| Addition       \t|     +    \t|   3 + 1  \t|       4 \t|\n",
    "| Subtraction    \t|     -    \t|   3 - 2  \t|      1 \t|\n",
    "| Multiplication \t|     *    \t|   4 * 2  \t|       8 \t|\n",
    "| Division       \t|     /    \t|   7 / 3  \t| 2.66667 \t|\n",
    "| Remainder      \t|     %    \t|   7 % 3  \t|       1 \t|\n",
    "| Exponentiation \t|    **    \t| 2 ** 2 \t| 4 \t|\n",
    "| Floor division \t|    //    \t| 7 // 2 \t| 3 \t|\n",
    "\n",
    "Let' see how this is done in `Python`.\n",
    "\n",
    "**Note**: press `shift` + `enter` to excecute a cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important**: the operator for `exponentiation` is `**` (not ^ which is common in many other languages including excel). \n",
    "\n",
    "so $2^2 = 4$ in Python becomes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7 // 2 # note: floor division calculates 7 / 2 = 3.5 and than removes the digits after the decimal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mathematical operators can be combined to compute more complex arithmetics. Python math operations obey the **same rules as in algebra**:\n",
    "\n",
    "**Example**\n",
    "\n",
    "Formula: $$(3+4)*2+4*\\frac{4}{2} = 22$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3 + 4) * 2 + 4 * 4/2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "# Name assignment / Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can name any given value in Python using an assignment statement (`=`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 30\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All previously assigned names (here: `a` and `b`) can be used in any other cell once it has been created. \n",
    "\n",
    "**Example:** \n",
    "- `a` and `b` have been created once the above cell was executed (using `shift` + `enter`)\n",
    "- both of them can now be used in other cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b + 10\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can overwrite existing variables names with new values by assigning a new value. Be careful to not accidentally do this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = -20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a + b + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Names must start with a `letter` but can contain both letters and numbers. \n",
    "\n",
    "You should use descriptive names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "revenue = 100\n",
    "operating_cost = 50\n",
    "interest_expense = 10\n",
    "tax_rate = 0.30\n",
    "\n",
    "profit = (revenue - operating_cost - interest_expense) * (1 - tax_rate)\n",
    "profit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "# Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has many build-in `data types`, some of which you have already encountered. \n",
    "\n",
    "So far we have seen two Numeric Types `int` (integer; e.g. 4 or 2) and `float` (floating point decimal, e.g. 4.3 or 2.3456). \n",
    "\n",
    "Python has many other types built-in by default. For a complete list [see here](https://www.w3schools.com/python/python_datatypes.asp).\n",
    "\n",
    "In the following we will cover two other data types which are important:\n",
    "\n",
    "- Strings: `str`\n",
    "- Lists: `list`\n",
    "\n",
    "During the course of the class you will encouter other data types. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables don't have to be of numeric type but can also be of different types. \n",
    "\n",
    "Sometimes it is helpful to have a variable that stores texts (e.g. when printing a message to the console or when labellling dataframe columns).\n",
    "\n",
    "**Example:** `Strings`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Felix\"\n",
    "surname = \"Zeidler\"\n",
    "full_name = name + \" \" + surname\n",
    "full_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are collections that are changeable and orderable and allow duplicate entries. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"Apple\",\"Banana\",\"Orange\"]\n",
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,56,394.34]\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can be accessed in varies ways are handy if you work with collections of data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first = numbers[0]\n",
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "last = fruits[-1]\n",
    "last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_second = numbers[:2]\n",
    "first_second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "last_two = numbers[-2:]\n",
    "last_two"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List can also be amended by assigning new values to them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers[0] = 99\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits[1] = \"Pineapple\"\n",
    "fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "(Note: next lecture we will learn about `numpy arrays` which are even more handy when doing data analysis or statistics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also apply mathematical operations to lists to create new lists, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_apple = [\"Apple\"]\n",
    "list_apple * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Writing functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python functions take data as arguments (known as parameters) and can return data as a result (here: the average). \n",
    "\n",
    "You have probable already encountered the concept of functions when e.g. using **Excel** where you can use functions such as `=sum(number1; number2)`.\n",
    "\n",
    "In Python the concept is the same, however, the syntax rules are different + functions are a bit more flexibel (like using VBA in Excel if we may keep the analogy). \n",
    "\n",
    "Functions follow a special syntax in python\n",
    "\n",
    "```Python\n",
    "def name_of_function(parameter):\n",
    "    do something\n",
    "    return data\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are a way of abstraction and help to avoid repetitive code.\n",
    "\n",
    "Imagine we have a very complicated formula that takes 4 parameters as input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = 10\n",
    "p2 = 20\n",
    "p3 = 30\n",
    "p4 = 40\n",
    "result_of_complicated_formula = p1/p2 + p3/p4 * p1 ** p2*4 - 3 / (p1 + p3)**p4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if we want to apply the same formula to new input? We have to repeat the entire formula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p5 = 20\n",
    "p6 = 3.45\n",
    "p7 = 40\n",
    "p8 = 5\n",
    "result_of_complicated_formula = p5/p6 + p7/p8 * p5 ** p6*4 - 3 / (p5 + p7)**p8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the **perfect use case** for writing a function: it is helpful to abstract the logic of the formula away into one function and then be able to apply this function multiple times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a simple functions that takes the sum of two values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a,b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 12\n",
    "add(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we can also write the function to use other datatypes as input. Let's create the same functionality by taking a list of two items as input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_list(l):\n",
    "    return l[0] + l[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [3,7]\n",
    "add_list(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's apply the concept and create a function that calculates the mean of four values\n",
    "\n",
    "$$\\bar{x} = \\frac{\\sum_{i=1}^{N} x_i}{N} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_ages(a,b,c,d):\n",
    "    return (a + b + c +d) / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_ages(3,5,6,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Build-in python functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luckily we don't have to start from scratch and many functions are already included in Python ([see here for complete list](https://docs.python.org/3/library/functions.html))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use built-in function `sum` to take the sum of a list of *numbers*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "sum(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use built-in function `len` to determine the length of the list *numbers*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's improve our mean function using two build in functions:\n",
    "\n",
    "- `sum`\n",
    "- `len`\n",
    "\n",
    "(Note that we need to group our variables togehter in a new data type called `list`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_ages_new(list_of_names):\n",
    "    return sum(list_of_names)/len(list_of_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important build-in function in `print`. It prints out the parameters that are included in this function which is very helpful. \n",
    "\n",
    "It enables us, for example, to print out any variable within a code cell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 12\n",
    "c = a + b\n",
    "print(c)\n",
    "d = c + 10\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Class functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python objects can also have functions attached to them. A good example for a object is the data type `list` we have previously seen. Lists have functions associated with them.\n",
    "\n",
    "We can find out about these functions:\n",
    "\n",
    "- by looking up the details of lists in the python documentation ([see here](https://docs.python.org/3/tutorial/datastructures.html))\n",
    "\n",
    "- by using **tab completion** by pressing `tab` in Jupyter Notebook or `CTRL` + `SPACE` in Google Colab\n",
    "\n",
    "Let's take an example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste = [1,2,4,5]\n",
    "liste.append(12) \n",
    "liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can learn about the function by typing out the function followed by a `?`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste.append?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste = []\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste.append(1)\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste.append([1,2,3])\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste.append(\"Peter\")\n",
    "liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will gradually introduce many of these associated functions (class methods) as they will make our life easier and avoid coding things from scratch that already exist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For Loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regular for-loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine for example you have a list with numbers and want to add some constant to this list. \n",
    "\n",
    "Unfortunately, the following operation does not work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "constant = 12\n",
    "# numbers + constant # Will not work"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could, of course, achieve this adding the constant to each individual element of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers[0] = numbers[0] + constant\n",
    "numbers[1] = numbers[1] + constant\n",
    "numbers[2] = numbers[2] + constant\n",
    "numbers[3] = numbers[3] + constant\n",
    "numbers[4] = numbers[4] + constant\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This seems tedious given the operation is nearly identical each time. In many situation - including the above - we want to repeat the same operation multiple times. \n",
    "\n",
    "In Python - as in many other programming languages - you can achieve this using a `for loop`. The syntax for `for loops` is the following:\n",
    "\n",
    "```Python\n",
    "for element in elements:\n",
    "    do something\n",
    "```\n",
    "\n",
    "Note that elements must be an iterator (e.g. a list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"Apple\", \"Banana\", \"Orange\"]\n",
    "for fruit in fruits:\n",
    "    print(\"I like\", fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note**: the inner part of the for loop is indented by four spaces (or tab). This is important! \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our previous problem of adding a constant to our list of numbers can be solved using a for loop as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "constant = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers_plus_constant = []\n",
    "for n in numbers:\n",
    "    numbers_plus_constant.append(n+constant)\n",
    "numbers_plus_constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One specialty about python are `list comprehensions` which are a special (condensed) form of a for loop and provide a concise way to create lists. \n",
    "\n",
    "The pyhton syntax for `list comprehsions` is as follows:\n",
    "\n",
    "```python\n",
    "[do something for element in elements]\n",
    "\n",
    "```\n",
    "\n",
    "Let's try to solve the previous numbers example using a list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "constant = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers_plus_constant = [number + constant for number in numbers]\n",
    "numbers_plus_constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some more examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names_lower = [\"Felix\", \"Murat\", \"Sibel\", \"Abdulmutalip\"]\n",
    "names_length = [len(n) for n in names_lower]\n",
    "names_length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Syntax errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whenever your code does not follow the correct language rules (here: python syntax) the system returns a `error message`. These error messages are a somewhat intimidating and cryptic at the beginning. However, they are actually helpful to identify issues with your analysis.\n",
    "\n",
    "Let's produce an error message by running the below code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Felix\"\n",
    "name / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually the last line of the error message gives some hint as to what went wrong. In this case the error message returns a *TypeError* stating that you cannot devide a string (i.e. text) by an integer (i.e. a number). \n",
    "\n",
    "You will run into many error messages in the beginning which is part of the learning process. "
   ]
  }
 ],
 "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"
  },
  "toc-autonumbering": true,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}