Part01_Python_for_Beginners.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://static.wixstatic.com/media/64484b_829e39cd0bf4469aa86afb21b28c7e90~mv2.png\" width= \"250\" style=\"float: left;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python as a Calculator\n",
    "1. Additon and Subtraction with the `+` and `-` operator, making comments with `#`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "-1\n",
      "1997\n"
     ]
    }
   ],
   "source": [
    "# Addition (You can add comments wiht the #)\n",
    "print(5+10)\n",
    "print(2-3)\n",
    "\n",
    "# Birthyear calculations\n",
    "age= 24\n",
    "year= 2021\n",
    "birth_year= 2021-24\n",
    "print(birth_year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Multiplication `*`, Division `/`, Modulo `%`, Exponentiation `**`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplication\n",
    "print(7 * 7)\n",
    "\n",
    "# Divison\n",
    "print(40 / 2)\n",
    "print(23/2)\n",
    "\n",
    "# Modulo\n",
    "print(2312 % 7)\n",
    "\n",
    "# Exponentiation\n",
    "print(8 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate Basic Formulas using all operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables and Types\n",
    "You can assign a variable by using `=`. Keep in mind that each variable has a specific type, which you can find out with the `type()` function. Different types have a different behaviour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.632674297606656\n",
      "Type age\n",
      "<class 'int'>\n",
      "Type height_m\n",
      "<class 'float'>\n",
      "Type weigth_kg\n",
      "<class 'float'>\n",
      "Type BMI\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "age= 23\n",
    "height_m= 1.86\n",
    "weight_kg= 78.3\n",
    "bmi= weight_kg/(height_m)**2\n",
    "\n",
    "print(bmi)\n",
    "\n",
    "print(\"Type age\")\n",
    "print(type(age))\n",
    "\n",
    "print(\"Type height_m\")\n",
    "print(type(height_m))\n",
    "\n",
    "print(\"Type weigth_kg\")\n",
    "print(type(weight_kg))\n",
    "\n",
    "print(\"Type BMI\")\n",
    "print(type(bmi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type first_name\n",
      "<class 'str'>\n",
      "Type last_name\n",
      "<class 'str'>\n",
      "Type agent007\n",
      "<class 'str'>\n",
      "Type on_mission\n",
      "<class 'bool'>\n",
      "My name is Bond, James Bond\n"
     ]
    }
   ],
   "source": [
    "first_name= \"James\"\n",
    "last_name= \"Bond\"\n",
    "# The Variable 007 or 007Agent will throw an error\n",
    "agent007= first_name + \" \"+ last_name\n",
    "on_mission= False\n",
    "\n",
    "print(\"Type first_name\")\n",
    "print(type(first_name))\n",
    "\n",
    "print(\"Type last_name\")\n",
    "print(type(last_name))\n",
    "\n",
    "print(\"Type agent007\")\n",
    "print(type(agent007))\n",
    "\n",
    "print(\"Type on_mission\")\n",
    "print(type(on_mission))\n",
    "\n",
    "print(\"My name is\" + \" \"+ last_name + \", \" + agent007)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last Code Chunk you have got into touch with several data types let's summarize them\n",
    "* `int`\n",
    "* `float`\n",
    "* `str`\n",
    "* `bool`\n",
    "\n",
    "There are of course more types, but for the start let's leave it at that. If you're interested in the other types have a look [here](https://realpython.com/python-data-types/#complex-numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type Conversion\n",
    "You can convert variables of different types with the following fucntions:\n",
    "* `int()`\n",
    "* `float()`\n",
    "* `str()`\n",
    "* `bool()`\n",
    "\n",
    "This can be particularly useful, when you for example want to print out a `int` variable with a bunch of strings. Have a look at the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am currently 20 years old.\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "age= 20\n",
    "print(\"I am currently \" + str(age) +\" years old.\")\n",
    "\n",
    "#The next line will throw an error if you remove the #, try it out\n",
    "#print(\"I am currently \" + age +\" years old.\")\n",
    "\n",
    "python_version_string= \"3.9\"\n",
    "python_version_float= float(python_version_string)\n",
    "print(type(python_version_float))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create three Variables: my_fav_movie, movie_length (in Minutes as int), google_review (as float)\n",
    "# Print out the variables and the type of them\n",
    "# Print out a sentence like: \"My favourite Movie is Django, it is 165 min long and it has 4.8 Stars on the Google reviews\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "* lists help to summarize data\n",
    "* can contain different data types\n",
    "* any type can be stored in a list\n",
    "* created by using `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 3, 4, 7, 2]\n",
      "['Monkey', 15, 'Lion', 3, 'Whale', 4, 'Pinguin', 7, 'Pandas', 2]\n"
     ]
    }
   ],
   "source": [
    "monkey = 15\n",
    "lion = 3\n",
    "whale = 4\n",
    "pinguin = 7\n",
    "pandas = 2\n",
    "\n",
    "zoo = [monkey, lion, whale, pinguin, pandas]\n",
    "zoo_with_names= [\"Monkey\", monkey, \"Lion\", lion, \"Whale\", whale, \"Pinguin\", pinguin, \"Pandas\", pandas]\n",
    "\n",
    "print(zoo)\n",
    "print(zoo_with_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bread', 1, 'sugar', 1, 'butter', 4]\n"
     ]
    }
   ],
   "source": [
    "item1= \"bread\"\n",
    "item2= \"sugar\"\n",
    "item3= \"butter\"\n",
    "normal_amount= 1\n",
    "\n",
    "shopping_list= [item1, normal_amount, item2, normal_amount, item3, 4]\n",
    "print(shopping_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another powerful feature of lists in python is that you can create lists of lists (of lists ...). \n",
    "As you might have guessed the type of a list is `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Monkey', 15], ['Lion', 3], ['Whale', 4], ['Pinguin', 7], ['Pandas', 2]]\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "monkey = 15\n",
    "lion = 3\n",
    "whale = 4\n",
    "pinguin = 7\n",
    "pandas = 2\n",
    "\n",
    "zoo_list= [[\"Monkey\", monkey],\n",
    "           [\"Lion\", lion],\n",
    "           [\"Whale\", whale],\n",
    "           [\"Pinguin\", pinguin],\n",
    "           [\"Pandas\", pandas]]\n",
    "           \n",
    "print(zoo_list)\n",
    "print(type(zoo_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subsetting\n",
    "### Basic Subsetting\n",
    "So now we learned how to store data or information in lists. But how can we access it? \n",
    "We can access the objects in the list by calling `[2]` after the list variable, `2` is the index.\n",
    "An important thing you have to keep in mind is that Python uses **zero-based indexing**. So if we for example call `zoo[1]` Python will extract the **second** item from our list. I hope the following code will make it more clear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monkey\n",
      "Lion\n",
      "2\n",
      "Pandas\n"
     ]
    }
   ],
   "source": [
    "monkey = 15\n",
    "lion = 3\n",
    "whale = 4\n",
    "pinguin = 7\n",
    "pandas = 2\n",
    "\n",
    "zoo = [monkey, lion, whale, pinguin, pandas]\n",
    "zoo_with_names= [\"Monkey\", monkey, \"Lion\", lion, \"Whale\", whale, \"Pinguin\", pinguin, \"Pandas\", pandas]\n",
    "\n",
    "print(zoo_with_names[0])\n",
    "print(zoo_with_names[2])\n",
    "# This will start \"counting\" from the end of the list\n",
    "print(zoo_with_names[-1])\n",
    "print(zoo_with_names[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "If you want to extract more than one item from your list you can use *list slicing* . Let's have a look on the code and find out the characteristics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Lion', 3, 'Whale']\n",
      "['Lion', 3, 'Whale', 4]\n",
      "['Monkey', 15, 'Lion']\n"
     ]
    }
   ],
   "source": [
    "monkey = 15\n",
    "lion = 3\n",
    "whale = 4\n",
    "pinguin = 7\n",
    "pandas = 2\n",
    "\n",
    "zoo = [monkey, lion, whale, pinguin, pandas]\n",
    "zoo_with_names= [\"Monkey\", monkey, \"Lion\", lion, \"Whale\", whale, \"Pinguin\", pinguin, \"Pandas\", pandas]\n",
    "\n",
    "print(zoo_with_names[2:5]) # Look at the output, what is kind of odd?\n",
    "\n",
    "print(zoo_with_names[2:6])\n",
    "print(zoo_with_names[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you tried out the code, you might have noticed that the second parameter is exclusive.\n",
    "So keep in mind `[start(inclusive) : end(exclusive]`. This is a common mistake so let's extinguish them from the start!\n",
    "You can also just leave out the starting or (not both) ending index to slice all elements after/before that index element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Monkey', 15, 'Lion']\n",
      "['Lion', 3, 'Whale', 4, 'Pinguin', 7, 'Pandas', 2]\n"
     ]
    }
   ],
   "source": [
    "monkey = 15\n",
    "lion = 3\n",
    "whale = 4\n",
    "pinguin = 7\n",
    "pandas = 2\n",
    "\n",
    "zoo = [monkey, lion, whale, pinguin, pandas]\n",
    "zoo_with_names= [\"Monkey\", monkey, \"Lion\", lion, \"Whale\", whale, \"Pinguin\", pinguin, \"Pandas\", pandas]\n",
    "\n",
    "print(zoo_with_names[:3])\n",
    "print(zoo_with_names[2:])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of your favourite movies (minimum 5)\n",
    "# Create a list of your favourite movies with the length in minutes after each string\n",
    "# Print both lists and the type of them\n",
    "# Print your 4th favourite movie \n",
    "# Print your top 3 movies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Manipulation\n",
    "Now we want to take a look at List Manipulation. How can we add and delete elements from a list? \n",
    "You can simply add elements by `zoo_with_names_new = zoo_with_names + [\"Snake\", 5]`. Elements can be removed by calling `del()`. E.g. `del(zoo_with_names[2]` would delete the string-element `\"Lion\"` from the list. Lets have a look at some more code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Monkey', 15, 'Lion', 3, 'Whale', 4, 'Pinguin', 7, 'Pandas', 2, 'Snake', 5]\n",
      "['Monkey', 15, 'Whale', 4, 'Pinguin', 7, 'Pandas', 2, 'Snake', 5]\n"
     ]
    }
   ],
   "source": [
    "monkey = 15\n",
    "lion = 3\n",
    "whale = 4\n",
    "pinguin = 7\n",
    "pandas = 2\n",
    "\n",
    "zoo = [monkey, lion, whale, pinguin, pandas]\n",
    "zoo_with_names= [\"Monkey\", monkey, \"Lion\", lion, \"Whale\", whale, \"Pinguin\", pinguin, \"Pandas\", pandas]\n",
    "\n",
    "zoo_with_names_new= zoo_with_names+ [\"Snake\", 5]\n",
    "print(zoo_with_names_new)\n",
    "\n",
    "del(zoo_with_names_new[2:4])\n",
    "print(zoo_with_names_new) # Now the index of all elements changed! Try it out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pay attention with list manipulation. Have a look at the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I am ', 21, 'years old.']\n",
      "['I am ', 21, 'years old.']\n"
     ]
    }
   ],
   "source": [
    "my_age= [\"I am \", 20, \"years old.\"]\n",
    "my_age_now= my_age\n",
    "my_age_now[1]= 21\n",
    "\n",
    "print(my_age)\n",
    "print(my_age_now)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you expect this output? Keep in mind that the variables `my_age` and `my_age_now` are just references. But if you change a value/variable inside a list it will change them in all references in this case `my_age` and `my_age_now`.\n",
    "To solve this problem you should use the `list()` function. Have a look at the next code chunk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I am ', 20, 'years old.']\n",
      "['I am ', 21, 'years old.']\n"
     ]
    }
   ],
   "source": [
    "my_age= [\"I am \", 20, \"years old.\"]\n",
    "my_age_now= list(my_age) #<---- creates new list object\n",
    "my_age_now[1]= 21\n",
    "\n",
    "print(my_age)\n",
    "print(my_age_now)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the two variables `my_age` and `my_age_now` reference two *different* objects. A change in a value/variable of the list will not affect the other one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Exercise\n",
    "# Use the lists from the previous exercise\n",
    "# Add another movie to your list\n",
    "# Subset you list so that the new list only contains your top three movies and assign it to top_three\n",
    "# Now you have seen Django and it absolutely blew your mind. (It may be my fav. movie). Change the first Element of the top_three list\n",
    "# Print out top_three and your other list\n",
    "# Did it change both lists? If not can you try to explain why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "* Many functions were already used previously `type()`, `print()`, `int()`\n",
    "* reproduces/summarizes code into a single argument\n",
    "* helps avoid copy and paste errors\n",
    "\n",
    "## Useful Build-in-Functions for the start\n",
    "* `min()`\n",
    "* `max()`\n",
    "* `round()`\n",
    "* `help()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n",
      "18.3\n",
      "Help on built-in function round in module builtins:\n",
      "\n",
      "round(number, ndigits=None)\n",
      "    Round a number to a given precision in decimal digits.\n",
      "    \n",
      "    The return value is an integer if ndigits is omitted or None.  Otherwise\n",
      "    the return value has the same type as the number.  ndigits may be negative.\n",
      "\n",
      "21.37\n",
      "10.45\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "#Temperatures\n",
    "monday= 18.34\n",
    "tuesday= 13.42\n",
    "wednesday= 19.54\n",
    "thursday= 21.37\n",
    "friday= 10.45\n",
    "saturday= 14.39\n",
    "sunday= 12.31\n",
    "\n",
    "week_temperatures= [monday,tuesday,wednesday,thursday,friday,saturday,sunday]\n",
    "\n",
    "print(round(number= monday, ndigits= None)) # default\n",
    "print(round(monday, 1))\n",
    "help(round) # Opens up the documentation\n",
    "\n",
    "print(max(week_temperatures))\n",
    "print(min(week_temperatures))\n",
    "print(round(week_temperatures[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are thousands of functions in python but some are pretty useful and you will use them frequently one of them is the `sorted()` function. It sorts the list passed in the argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10.45, 12.31, 13.42, 14.39, 18.34, 19.54, 21.37]\n",
      "[21.37, 19.54, 18.34, 14.39, 13.42, 12.31, 10.45]\n"
     ]
    }
   ],
   "source": [
    "#Temperatures\n",
    "monday= 18.34\n",
    "tuesday= 13.42\n",
    "wednesday= 19.54\n",
    "thursday= 21.37\n",
    "friday= 10.45\n",
    "saturday= 14.39\n",
    "sunday= 12.31\n",
    "week_temperatures= [monday,tuesday,wednesday,thursday,friday,saturday,sunday]\n",
    "\n",
    "print(sorted(week_temperatures))\n",
    "print(sorted(week_temperatures, reverse= True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a short outlook I want to show you how you can define your own functions. You might not be the so familiar with loops or other useful commands in Python but it is still good to know. Later on we will focus more on defining your own functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "def addition(x,y):\n",
    "    result= x+y\n",
    "    return print(result)\n",
    "\n",
    "addition(2,6)\n",
    "addition(3,9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Methods\n",
    "Just now we introduced some fucntions you can use on variables or values, but what can you do with lists? You already got familiar with the `sorted()` function.\n",
    "But there is more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "#Temperatures\n",
    "monday= 18.34\n",
    "tuesday= 13.42\n",
    "wednesday= 19.54\n",
    "thursday= 21.37\n",
    "friday= 10.45\n",
    "saturday= 14.39\n",
    "sunday= 12.31\n",
    "\n",
    "week_temperatures= [monday,tuesday,wednesday,thursday,friday,saturday,sunday]\n",
    "\n",
    "print(week_temperatures.index(wednesday))\n",
    "print(week_temperatures.index(saturday))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "[5.0, 4.0, 3.5, 4.0, 5.0, 1.0, 1.0, 2.0, 3.0, 2.5, 5.0]\n",
      "[5.0, 4.0, 3.5, 4.0, 5.0, 1.0, 2.0, 3.0, 2.5, 5.0]\n",
      "[5.0, 2.5, 3.0, 2.0, 1.0, 5.0, 4.0, 3.5, 4.0, 5.0]\n"
     ]
    }
   ],
   "source": [
    "google_reviews=[5.0, 4.0, 3.5,4.0, 5.0, 1.0,1.0, 2.0,3.0, 2.5]\n",
    "\n",
    "print(google_reviews.count(1.0))\n",
    "\n",
    "google_reviews.append(5.0)\n",
    "print(google_reviews)\n",
    "\n",
    "google_reviews.remove(1.0) #<- removes only the first 1.0\n",
    "print(google_reviews)\n",
    "\n",
    "google_reviews.reverse()\n",
    "print(google_reviews)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `index()`, returns the index of the argument passed in the list it is called on\n",
    "* `count()`, returns number of times this element appears in the list it is called on\n",
    "* `append()`, adds element to list it is called on\n",
    "* `remove()`, removes element from the list it is called on\n",
    "* `reverse()`, reverses order of the elements (index change!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create five variables and assign each of them a realistic value of the [Air Quality Index](https://www.iqair.com/de/germany). \n",
    "# Store them in a list\n",
    "# Print a sorted version of the list try to use all additional arguments\n",
    "# Use all functions I listed above under useful build in functions, especially help!\n",
    "# Define your own function multiplication, it should take two parameters\n",
    "# Get the index of a certain value\n",
    "# Count the Numbers of a value of 55\n",
    "# Add 2 or more new values to your list\n",
    "# remove the two lowest values (---->min function)\n",
    "# Flip the list around so that the first element is last afterwards\n",
    "# Check the index of the Element you checked before"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Easy way to store data (e.g. world population and countries)\n",
    "* Dictionary is created with keys and values (each key opens the door to its value)\n",
    "* Efficient way to look up data\n",
    "\n",
    "To access a value inside a dictionary you can use `my_dictionary[\"my_key\"]`.\n",
    "Keys of a dictionary can be accessed vie the `keys()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.3\n",
      "15.3\n"
     ]
    }
   ],
   "source": [
    "cities= [\"Munich\", \"Hamburg\", \"Berlin\", \"Leipzig\", \"Dortmund\", \"Stuttgart\"]\n",
    "mean_temp= [14.3, 12.2, 13.5, 15.3, 14.9, 12.4]\n",
    "# Hard to access temperature of each city\n",
    "# Solution dictionary\n",
    "\n",
    "# \"key\":value\n",
    "city_temp= {\"Munich\":14.3, \"Hamburg\":12.2, \"Berlin\":13.5, \"Leipzig\":15.3, \"Dortmund\":14.9, \"Stuttgart\":12.4}\n",
    "\n",
    "# The key \"munich\" returns the value 14.3, which was attached to it.\n",
    "print(city_temp[\"Munich\"])\n",
    "print(city_temp[\"Leipzig\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'italy': 'rome', 'france': 'paris', 'germany': 'berlin', 'poland': 'warsaw'}\n",
      "dict_keys(['italy', 'france', 'germany', 'poland'])\n"
     ]
    }
   ],
   "source": [
    "# Different types or same types can be connected\n",
    "parts_europe = { 'italy':'rome', 'france':'paris', 'germany':'berlin', 'poland':'warsaw'}\n",
    "\n",
    "print(parts_europe)\n",
    "print(parts_europe.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding new keys and values is similiar to declaring a variable. Have a look."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'italy': 'rome', 'france': 'paris', 'germany': 'berlin', 'poland': 'warsaw', 'austria': 'vienna'}\n",
      "dict_keys(['italy', 'france', 'germany', 'poland', 'austria'])\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "parts_europe = { 'italy':'rome', 'france':'paris', 'germany':'bonn', 'poland':'warsaw', \"uk\":\"london\"}\n",
    "parts_europe['austria']= 'vienna' #<--------\n",
    "parts_europe['germany']= 'berlin' #<--------\n",
    "\n",
    "del(parts_europe[\"uk\"])#<----- Quickest Brexit ever\n",
    "\n",
    "print(parts_europe)\n",
    "print(parts_europe.keys())\n",
    "\n",
    "print(\"uk\" in parts_europe)\n",
    "print(\"italy\" in parts_europe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Differnces between Lists and Dictionaries\n",
    "* Dictionaries is indexed by (unique) keys, Lists are indexed by numbers\n",
    "* Dictionaries are more like a table to look up specific keys, while lists are a collection values (subsetting/slicing possible)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "## While Loop\n",
    "Defining a while loop in Python is pretty simple. However, do not forget to add the `:` after your condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.204081632653061\n",
      "1.0412328196584755\n",
      "0.10624824690392606\n"
     ]
    }
   ],
   "source": [
    "error_estimate= 100.0\n",
    "\n",
    "while error_estimate >1:\n",
    "    error_estimate= error_estimate/9.8\n",
    "    print(error_estimate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In connection with if statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "correcting...\n",
      "-4\n",
      "correcting...\n",
      "-3\n",
      "correcting...\n",
      "-2\n",
      "correcting...\n",
      "-1\n",
      "correcting...\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "error_estimate = -5\n",
    "while error_estimate != 0 :\n",
    "    print(\"correcting...\")\n",
    "    if error_estimate>=1 :\n",
    "      error_estimate= error_estimate-1\n",
    "    else:\n",
    "      error_estimate= error_estimate+1\n",
    "    print(error_estimate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercise\n",
    "# Create a variable age and set it to 0\n",
    "# Create a while loop that prints out if our if not that person (age) is allowed to drive a car\n",
    "# Each loop sequence should print out \"Is the person allowed to drive: True/False\" (depending on the loop sequence)\n",
    "# Edit your loop to specifiy if the person's nationality is American. If the person is an American the loop should stop when the age is already 16."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For Loop\n",
    "Do not forget `:`. The rest is almost the same as defining a while loop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.25\n",
      "13.0\n",
      "19.0\n",
      "12.75\n",
      "15.5\n",
      "Day 1: 11.25\n",
      "Day 2: 13.0\n",
      "Day 3: 19.0\n",
      "Day 4: 12.75\n",
      "Day 5: 15.5\n"
     ]
    }
   ],
   "source": [
    "temperatures = [11.25, 13.0, 19.0, 12.75, 15.50]\n",
    "\n",
    "for degree in temperatures:\n",
    "    print(degree)\n",
    "\n",
    "# Change for loop to use enumerate() and update print()\n",
    "for index, degree in enumerate(temperatures) :\n",
    "    print(\"Day \" + str(index+1) + \": \" + str(degree))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `enumerate()` Function comes in handy right here. Keep in mind that we added the  `+1` so that our Days do not start at zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Exercise\n",
    "# Create a list called rooms with the areas from your apartments rooms\n",
    "# Print them out one after another using a for loop\n",
    "# Print out the areas with numbers to each room e.g \"Room 1 20.4 square meters\""
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}