EWF_Python_Introduction_Course.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EWF - Python Introduction Course",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/JasperLS/data_science_intros/blob/main/EWF_Python_Introduction_Course.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5fCEDCU_qrC0"
      },
      "source": [
        "#EWF - Python Introduction Kurs\n",
        "\n",
        "Willkommen zum EWF Python Introduction Kurs. In den folgendne Aufgaben werdet ihr die Grundlangen lernen, um Python einfach und effektiv für die empirische Forschung z.B. in eurer Bachelorarbeit zu verwenden.\n",
        "\n",
        "Bitte lest und beantwortet sorgfältig alle Aufgaben. \n",
        "Immer wenn ihr \"**...**\" seht, solltet ihr diesen Teil durch euren Code ersetzen. **Das ist aufgabenbasiertes Lernen - Ihr werdet Googeln müssen!**. Ihr könnt gerne weitere verfügbare Quellen nutzen, z.B.: \n",
        "\n",
        "- stackoverflow\n",
        "- SoloLearn\n",
        "- DataCamp\n",
        "- udemy\n",
        "\n",
        "Viel Erfolg!\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GJBs_flRovLc"
      },
      "source": [
        "##First Steps\n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p4NFErGadias"
      },
      "source": [
        "**Print Function**\n",
        "\n",
        "By using the print statement, we're able to output text. \n",
        "\n",
        "*Please run the following code*:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gJr_9dXGpJ05"
      },
      "source": [
        "print ('Hello World')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L3qFPIIqrc77"
      },
      "source": [
        "<img src=\"https://miro.medium.com/max/1250/1*iNw33pBEYZIAoE9oHdhLLw.jpeg\" width=500 height=330>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2fhs6GZ4qFMx"
      },
      "source": [
        "<strong>Basic Operations</strong>\n",
        "\n",
        "With Python, you can easily do some calculations. \n",
        "\n",
        "*Tap around to perform an addition with a result of 5:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c6i-78HEXGNu"
      },
      "source": [
        "3 "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0DsykyJTXNao"
      },
      "source": [
        "*Try to print a substraction with 7 as a result:*\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B3fhbNoMXLuf"
      },
      "source": [
        "10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8QlK460xXJqJ"
      },
      "source": [
        "*Use parantheses to determine which operations are performed first - try to get 30:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-gE-Ez1qtyIA"
      },
      "source": [
        "3*4+6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bX2Xoej0WmJn"
      },
      "source": [
        "*Try to divide by 2 to get a result of 2.00*\n",
        "\n",
        "**<strong><font color='blue'> Side Note:** we call 2.00 a float variable, while 2 is called an integer variable. Despite seemingly being the same, Python sees them as different datatypes which for example leads to differnt memory needs.</font></strong>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4ty9qsqVWVq7"
      },
      "source": [
        "4"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lSrWNr3MuFUS"
      },
      "source": [
        "The minus sign symbolizes a negative number which has no effect on how to perform an operation with them. \n",
        "\n",
        "*Tap around and try to get a positive result of 48!*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WgHrAlz6ZTB-"
      },
      "source": [
        "(-3+-1)*(12)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wt_Y_ZWA9miH"
      },
      "source": [
        "**Comments**\n",
        "\n",
        "You can comment your code, to explain something for later reference.\n",
        "\n",
        "*Please turn \"This is just a comment\" into a proper comment.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ssxN9tka9-2o"
      },
      "source": [
        "4 + 4\n",
        "This is just a comment"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4i-XuhKW3owN"
      },
      "source": [
        "**Storing Values**\n",
        "\n",
        "You can store values in variables.\n",
        "\n",
        "*Please complete the code to generate 42 as an output.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T29nLva63oG7"
      },
      "source": [
        "... = 21\n",
        "\n",
        "... = ... * ...\n",
        "\n",
        "print(...)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jhy8suwbZtde"
      },
      "source": [
        "**ZeroDivisionError**\n",
        "\n",
        "Dividing by zero produces an error, as no answer can be calculated. \n",
        "\n",
        "*You don't believe that? Tap around and divide 3 by zero.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ghD_v1QJaWhM"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8bPzVa96a-zX"
      },
      "source": [
        "**Other numerical Operations**\n",
        "\n",
        "You can also use Python for exponentiation or the quotient and remainder of a division.\n",
        "\n",
        "*Perform an exponentiation with a result of 32:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vHWTZFAsbnrU"
      },
      "source": [
        "2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e0KghhEMdLLP"
      },
      "source": [
        "*Try to get the remainder of the division 1.25 by 0.5 (should be 0.25):*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cKOpQ-2ebvmM"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSqSFbg6jRw7"
      },
      "source": [
        "##Data Types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KA7WEmmTjbRl"
      },
      "source": [
        "If Python handles data, it has to somehow turn it into 1s and 0s. Depending on the type of data, Python uses different internal representations. It is therefore very important, to always make sure your data has the right data type."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fxXZEWORXump"
      },
      "source": [
        "**Integers**\n",
        "\n",
        "Integers are whole numbers like: \n",
        "\n",
        "- 5 \n",
        "- 3\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SpL66XSAV3PW"
      },
      "source": [
        "**Floats**\n",
        "\n",
        "Numbers that aren't integers are represented as floats in Python (\"a floating point number\"). Some examples are: \n",
        "- 0.8\n",
        "- -5.346\n",
        "\n",
        "How to create a float? \n",
        "By entering a number with a decimal point, or by using operations such as division on integers as well as operations on a float and an integer.\n",
        "\n",
        "*Please build a float dividing 12 by 4 and try to convert it back into an integer (should be 3 not 3.0):*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pN81xZjUXB5Z"
      },
      "source": [
        "# create float\n",
        "print()\n",
        "# turn it into an integer\n",
        "print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VprZLg-EY5s-"
      },
      "source": [
        "**Strings**\n",
        "\n",
        "You have to use a string if you want to use text in Python. It's one of the basic things that store text like: \n",
        "\n",
        "- Python is fun\n",
        "- I love Data Science\n",
        "\n",
        "How to create a string? By entering text between two single or double quotation marks.\n",
        "\n",
        "*Run the code to create a string:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "98w-iUSGZ6ko"
      },
      "source": [
        "\"Python is fun\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JX8ScvvleqQO"
      },
      "source": [
        "*Try to print I love Data Science using single marks.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lt-l5lUJaBfd"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VeQ8nTgbbyur"
      },
      "source": [
        "*What's wrong with the following string? Please correct it so that the type is 'str' and there is no error message!*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zFxpt_tYaiPd"
      },
      "source": [
        "type('Lisa's brother likes good food.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IgVEuFwsb2hE"
      },
      "source": [
        "*Please change the following sentences to bring the second sentence in the second line:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_TdTOOA1cC7c"
      },
      "source": [
        "print ('Lisa likes good food. In the future, he wants to open a restaurant.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "We12AcbmdcPU"
      },
      "source": [
        "**Booleans & Comparisons**\n",
        "\n",
        "You've already learned about integers, floats and strings. In Python, another type is the Boolean type. It has two values: True and False. By comparing values (using the equal operator ==), you can create Booleans. \n",
        "\n",
        "*Please define my_boolean as True:*  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S7bs7aEXgjML"
      },
      "source": [
        "my_boolean = \n",
        "print(my_boolean)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-Uv7DJigzb9"
      },
      "source": [
        "*Please compare two numbers and see if you get the \"True\" statement:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "As8PeDsQnU3P"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "61liw4eOhy2i"
      },
      "source": [
        "*Is \"hi\" equal to \"hello\"? Try it out!*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0srfVv0vnmYr"
      },
      "source": [
        "\"hi\" ... \"hello\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6c-qfGoloEBC"
      },
      "source": [
        "The not equal operator (!=) is another comparison operator. \n",
        "\n",
        "*Please run the code:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zFYUiLPWoLFX"
      },
      "source": [
        "3!=3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "siEObqC2iNHa"
      },
      "source": [
        "*Please generate a True statement using the operator:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "owFd0uatoOFn"
      },
      "source": [
        "... != ..."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "crYwcDotoYtw"
      },
      "source": [
        "In Python, you can also use operators (> and <) to determine whether one number (float or integer) is smaller than or greater than another.\n",
        "\n",
        "*Tap around (change the ...) and generate one True as well as one False statement:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RV-FHVego3uL"
      },
      "source": [
        "24 ... 16"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KPY852q_o9rJ"
      },
      "source": [
        "6 ... 6.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "agDDzvQlrHxO"
      },
      "source": [
        "**<strong><font color='blue'> Side Note: In the first lessons you've learned about the basic operations in Python. To be better prepared for the following steps, the table below provides a summary: </font></strong>**\n",
        "\n",
        "<img src=\"https://i1.wp.com/makemeanalyst.com/wp-content/uploads/2017/06/Assignment-Operator.png?resize=590%2C426\" width=500 height=300>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UdRyKR44dcNI"
      },
      "source": [
        "##Control Structures\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AX8KEqV7d2jR"
      },
      "source": [
        "**if&else statement**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hdtFz5UXptLZ"
      },
      "source": [
        "<img src=\"https://www.tutorialspoint.com/python/images/if_else_statement.jpg\" width=300 height=300>\n",
        "\n",
        "*Now it's your turn! Change the following code (...) to generate \"else\":*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E6xzkR1ukfO0"
      },
      "source": [
        "if 2 + ... == 4 ...\n",
        "  if 3 * ... == 9 ...\n",
        "    print (\"if\")\n",
        "  else: \n",
        "    print (\"else\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "datsEgDB4iXQ"
      },
      "source": [
        "**<strong><font color='blue'> Side Note:**  Indentations are very important in Python, as they structure your code. </font></strong>\n",
        "\n",
        "<img src=\"https://i.redd.it/wk843smkri441.jpg\" width=500 height=300>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40mdnbNieJTh"
      },
      "source": [
        "**Boolean Logic**\n",
        "\n",
        "Boolean Logic is used to make more complicated conditions for if statements that rely on more than one condition. The Boolean operators are **and, or and not**. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OdysNNSonWA0"
      },
      "source": [
        "*Tap around to get a false statement:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7htGUSgym9KX"
      },
      "source": [
        "print ( 2 < 3 and 2 ... 6 )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHpbmcEBn_34"
      },
      "source": [
        "*Change and correct the following code to print \"Hi\":*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XlAjNuIqoKgs"
      },
      "source": [
        "age = ... \n",
        "money = 400 \n",
        "if age > 20 ... money > 50 ...\n",
        "  ...(\"Hi\"..."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0JOau1ITeOBp"
      },
      "source": [
        "**Lists**\n",
        "\n",
        "Lists are used to store multiple items. By using square brackets with commas separating items, you can create a list. \n",
        "\n",
        "*Try to print the first argument of the list (\"Hello\").*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zjovDwhNlYFn"
      },
      "source": [
        "words =  [\"Hello\", \"world\", \"!\"]\n",
        "print (words...)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F8VgN4fgrdDZ"
      },
      "source": [
        "*Change the code to create a list and print its 3rd element:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d5rWZJjOrgwC"
      },
      "source": [
        "the_list = ... 33, 66, 99 ...\n",
        "...(the_list[...])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UEmilTRFecFV"
      },
      "source": [
        "**Loops**\n",
        "\n",
        "A for loop is used to repeat a block of code multiple times. It is common to use the for loop when the number of iterations is fixed (e.g. iterating over a fixed list of items in a shopping list), but there are other loops as well.\n",
        "\n",
        "*Change the code below to print all elements of your list:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hrSVVOz2Uzm9"
      },
      "source": [
        "your_list = ['a','b','c','d']\n",
        "\n",
        "for ... ... ... :\n",
        "  print (...)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QOEUQc1SVzqh"
      },
      "source": [
        "*Please change the ... to correct the code so that the loop is broken after the loop reaches the 'c' in your list.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kYHdF1AVlZYy"
      },
      "source": [
        "for item ... your_list: \n",
        "  print(item)\n",
        "  if item ... ...: \n",
        "    print (\"Breaking\")\n",
        "    ... \n",
        "\n",
        "print(\"Finished\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hDqpOb_IXfK0"
      },
      "source": [
        "What's wrong with the following code? \n",
        "*Please find the correct code to count all the 't' letters in the string. ATTENTION, you have to correct multiple errors and may need to change pre-written code.*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "if61RplmXxGC"
      },
      "source": [
        "str = \"testing for loops to count 't's\"\n",
        "count = 0 \n",
        "\n",
        "for ... in str: \n",
        "  if ... == 't' :\n",
        "    count ... = 1\n",
        "\n",
        "print (count) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XBlj6_t8efo8"
      },
      "source": [
        "**Range**\n",
        "\n",
        "The range() function returns a sequence of numbers. By default, it starts from 0, increments by 1 and stops before the specified number. \n",
        "\n",
        "*The code below should generate a list containing all of the integers, up to 10 (not incl.). Please change the following code (...):*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jeR4mJGUlad7"
      },
      "source": [
        "numbers = list(...(10))\n",
        "\n",
        "print(...)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cLKi_bFvDN8K"
      },
      "source": [
        "*Now change the code below to print every even number from 10 to 19 using range:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TjGtMu2hDOz6"
      },
      "source": [
        "numbers = list(...)\n",
        "\n",
        "print(...)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OwuxHmxllTwN"
      },
      "source": [
        "##Functions & Modules"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EMtDBH2Xe6kR"
      },
      "source": [
        "**Functions**\n",
        "\n",
        "In addition to using pre-defined functions like range() or print(), you can create your own functions by using the def statement. You have to define functions before they are called! This is especially useful, if you want to do similar operations again and again.\n",
        "\n",
        "*Try for yourself and build a function \"quattro_hello\" which prints \"hello\" four times.*\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pHnpri3gHXV8"
      },
      "source": [
        "def ...:\n",
        "  # build a proper loop to print your output four times \n",
        "  print (...)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aDR8mvcz-q1e"
      },
      "source": [
        "*Now call your function and see if it prints 'hello' three times:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z8N9zB0V8jq7"
      },
      "source": [
        "quattro_hello()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mzUjE-zrHiu6"
      },
      "source": [
        "It is also possible to define a function that takes an argument. \n",
        "\n",
        "*Please change the following code to build a function that prints a given text and adds a question mark:*\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3qJbedzsHyTE"
      },
      "source": [
        "def hello_function ():\n",
        "  print (... + \"?\")\n",
        "\n",
        "hello_function(\"HI\")\n",
        "hello_function(\"...\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K5e3PBnT9G0o"
      },
      "source": [
        "**<strong><font color='blue'> Side Note:**  Python can take any form of object as input to a function AND (almost) everything in Python is an object !! </font></strong>\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "<img src=\"https://miro.medium.com/max/625/1*mPpNrH_b3DEd0HiljDqMkw.png\" >\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V5kSE42tJNkw"
      },
      "source": [
        "*And 2 arguments (develop a code to get a result of 16):*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tNiEftMNJzDD"
      },
      "source": [
        "def print_sum(...,...):\n",
        "  print(... + ...)\n",
        "\n",
        "print_sum(6,11)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oMgTXZFfK94l"
      },
      "source": [
        "*Fill in the ... to define a function that takes two arguments and prints their multiplication:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xBfautGKOid"
      },
      "source": [
        "... print_mult(x,y)...\n",
        "  print(x * ... )\n",
        "...(2,2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-caDGUcZLO9j"
      },
      "source": [
        "*Fill in the ... to define a function that prints whether the first given paramter is greater or equal than the second paramter - or not:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OixS1ZvgAPJk"
      },
      "source": [
        "def compare(x, y):\n",
        "  if ...:\n",
        "    print(...)\n",
        "  else:\n",
        "    print(...)\n",
        "\n",
        "print(compare(...,...))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lks5vCIQgFBR"
      },
      "source": [
        "**Modules & Libraries**\n",
        "\n",
        "Modules refer to a file containing Python functions. A file containing Python code, for example: example.py, is called a module, and its module name would be example. The basic way to use a mdule is to add import *some_module_name* at the top of your code, and then using *some_module_name*.var to access functions and values with the name var in the module. This allows you to access complex functions programmed by other people.\n",
        " \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SV5FevBtl459"
      },
      "source": [
        "*Please import a fitting module and generate 5 random numbers from the interval [0,10):*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R1892agsAnxy"
      },
      "source": [
        "import ...\n",
        "\n",
        "for i in range(5): \n",
        "  value = ...\n",
        "  print(value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pvTTfdOUm96f"
      },
      "source": [
        "*Please import only the pi constant from the respective module and print pi:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mfxt3G-Ym-wd"
      },
      "source": [
        "from ... import ...\n",
        "\n",
        "print(...)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wFCVUGx_Bqef"
      },
      "source": [
        "<img src =\"https://i.redd.it/37xqk9umycn31.jpg\" width=500 height=400>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SpnHNXNvUVUY"
      },
      "source": [
        "**Pip Install**\n",
        "\n",
        "pip is a package management program for Python packages from the Python Package Index (PyPI). It allows you to install and manage software packages written in Python. Basically, it lets you install different modules.\n",
        "\n",
        "Before you learn how to install and import packages, the first step would be to actually make sure you've the correct Python verison installed in your system. \n",
        "\n",
        "*Fill in the ... to check this and the version installed:* "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UhimRI0A1QJ1"
      },
      "source": [
        "!python ... v"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LZsAOsGNt6t2"
      },
      "source": [
        "*Please correct the following code to install the scenedetect package:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sezVDvVCA9HX"
      },
      "source": [
        "import scenedetect # are you able to import the package?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ovmkymv7unbc"
      },
      "source": [
        "... scenedetect"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dzrXbT3YBGNV"
      },
      "source": [
        "import scenedetect # you should be able to import it now!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qs52gjw6uzY8"
      },
      "source": [
        "Uninstalling/removing a package is very easy with pip. \n",
        "\n",
        "*Please uninstall scenedetect again:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1G_MJA3_vNuN"
      },
      "source": [
        "pip ..."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Rh3-Vt9Nev9"
      },
      "source": [
        "##Exceptions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1RR8qzFXgkJh"
      },
      "source": [
        "**Exception and Exception Handling**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qQamrW33vP7o"
      },
      "source": [
        "Exception is an event that occurs due to incorrect code or input. \n",
        "\n",
        "*Please generate a zero devision error:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dr5Bfn-ev_FC"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7EcpGATAv_-m"
      },
      "source": [
        "*Please create a NameError:* "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VDMdlsJcxItH"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CjSKE_T4xJO-"
      },
      "source": [
        "*Please generate a TypeError:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WNVtpN4mxSPV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4pz8WKMMxWZf"
      },
      "source": [
        "*Please create a ValueError:*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4PdQE07HCnBS"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RjaaEpTMyB-y"
      },
      "source": [
        "To handle exceptions, and to execute further code despite occuring errors, you can use a try/except statement. \n",
        "\n",
        "*Please change the following code to print \"an error occured - but the interpreter continued\":*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N7fSjbYFye3c"
      },
      "source": [
        "try:\n",
        "  num1 = 7\n",
        "  num2 = 0\n",
        "  print(...)\n",
        "  print(\"calculation done\")\n",
        "except:\n",
        "  print (\"an error occured - but the interpreter continued\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SSSAZzFFD3dW"
      },
      "source": [
        "<img src =\"https://img.devrant.com/devrant/rant/r_1200037_6jt6c.jpg\" width=500 height=300>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tClVksnmXsNn"
      },
      "source": [
        "## Save & Submit\n",
        "\n",
        "Please make sure you included your name and matrikel at the top of this notebook, save your work **with your name in the file name**, and send **two** files to jasper dot schwenzow at uni dash hamburg dot de:\n",
        "- Ipynb *(Go to File -> Download .ipynb)*\n",
        "- PDF *(Go to File -> Print -> Save as PDF)* (optional)\n",
        "\n"
      ]
    }
  ]
}