01_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python programming \n",
    "\n",
    "In this book, we are going to give an overview about basic knowledge in Python programming, but there is far more to know.  \n",
    "Python was developed in the early 1990s by Guido van Rossum and named after Monty Python. It is an high-level, interpreted programming language. For more information or a general documentation have a look at the official [Python Website](https://www.python.org/) \n",
    "![python](./img/python.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "Variables are one of the most fundamental concepts. A variable is used to store data (values). The code below does not have a visual output printed on the screen, because the variable is set with a data type or the data type is assigned to the variable. When writing code, it is important to choose variable names that are meaningful. The last example in the code cell below is an example of what one should not do. The variable name gives no information about the content or meaning in the code. A name of a variable can be almost chosen free, apart from a few words, as they have special meaning such as: if, for, list, try, ... . Variable names can not be just a number or start with a number, but thy can contain numbers: number1 or number_2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_num = 1\n",
    "var_text = \"text\"\n",
    "a = 1.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data type: Integer, Float, String, Boolean \n",
    "### Integer\n",
    "Integers are all whole numbers, as much as floats, they belong to the numeric literals. One can define a variable as an integer as the following example shows. Furthermore, we use the print function here. In comparison to the last code cell, an output will be printed here.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment, it is not interpreted code, but helpful when describing what you do or did here\n",
    "variable_num = 1\n",
    "print(variable_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, one can apply mathematical functions to it, but the assigned values have to be the same literals, in this case numeric literals. Adding a string to a number by using the plus operator would not work, because one is a numeric literal and the other a string literal. One can test this by replacing the first **or** second variable with text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_one = 1\n",
    "var_two = 2\n",
    "result_var = var_one + var_two\n",
    "print(result_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float\n",
    "The float type represents the floating point number and belongs to numeric literals. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable_float = 1.2\n",
    "print(variable_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Especially when using floats, there are numbers which look like the following one. This may have been printed on a calculator, in this case e is not a string but a mathematical term the natural logarithm. The following number is equal to 1.234*10^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable_float2 = 1.234e2\n",
    "print(variable_float2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String\n",
    "A string is a sequence of characters put in single, double or triple quotes. To be more detailed strings are arrays of bytes representing Unicode characters. Of course, it is possible to have quotes in quotes but make sure to use different ones. A character therefore is just one letter. For visualization put the variable name of the string that shall be printed in the print function and run the code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_string = 'My first string'\n",
    "second_string = \"My second string\"\n",
    "long_string = '''For strings longer than just one\n",
    "line but still continuing'''\n",
    "quotes_in_string = 'My first \"STRING\"'\n",
    "mixed_str = \"3,2,1,and some text\"\n",
    "char = \"A\"\n",
    "print(mixed_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to create a string is, by using the **str()** function. One can convert a numeric literal to a string by using the str() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 123456\n",
    "new_string = str(number)\n",
    "print (new_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to connect to strings by using the **+** operator but make sure to have spaces where they are needed. Spaces are needed when two words are connected as the following example shows. Behind Hello is a whitespace, to make sure, that when merging both words a whitespace remains between them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_string = \"Hello \"\n",
    "two_string = \"World!\"\n",
    "connected_string = one_string + two_string\n",
    "print (connected_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides one can also format strings by using the format() method, a variable value can be placed in a string. The placeholder is filled with the corresponding value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "poss_1 = \"the best I have ever done\"\n",
    "poss_2 = \"the worst I have ever done\"\n",
    "print(\"Python is {}.\".format(poss_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can also be sliced, to get or to separate specific information. This is done by using square brackets, feel free to change the length of the string and the numbers in the square brackets **[lower:upper]**. One really important thing to keep in mind: **If not further definied counting starts from 0 NOT 1!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "slicing = \"A string for slicing\"\n",
    "slicing[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are methods for strings as well, try the follwing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(slicing.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean\n",
    "There are two boolean literals **True** and **False**. Both can be assigned to a variable, as the following example shows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_bool = True\n",
    "print(var_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two major errors, firstly a Boolean is not declared as a string and secondly the value True or False is always capitalized. Both of the following declarations are not boolean. The first one does not even raise an error, while the second one does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var_bool1 = \"True\"\n",
    "var_bool2 = true\n",
    "print(var_bool2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data type: List, Tuple, Dictionary\n",
    "### List\n",
    "Lists and Tuples are Sequences, they are collections (Containers) with ordered values as members. While a list is mutable, a tuple is not.  \n",
    "There are two ways to create an empty list in Python, by using square brackets or the Python \"list\" function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_way = []\n",
    "second_way = list()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list can contain different elements such as strings, integers or objects. Also, a mixture of different kinds of elements is possible. Furthermore, it is possible to create lists in lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1,2,3]\n",
    "my_list2 = [\"a\", \"b\", \"c\"]\n",
    "list_in_list = [my_list, my_list2]\n",
    "print(list_in_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_list = [1,2,3,\"text\", 1.5]\n",
    "print (mixed_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list can be sliced by defining the lower and upper bound **[lower:upper]**. When leaving out the lower bound, Python will start from the beginning of your list, leaving out the upper bound, Python will go from the defined beginning to the end of the list. To access the last element one can use **[-1]**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "li = [1,2,3,5,1]\n",
    "li[:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "li[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "li[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the **in operator** one can test if a specific element in the list. A boolean True or False will be returned, depending, if the element is part of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 in li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4 in li"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**+** is a string as well as a list and even a tuple operation. The + operation has already been introduced in string operations, but it can also be used for lists and tuples, as the following example shows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "li1 = [\"one\",\"two\",3]\n",
    "li2 = [4,5,6]\n",
    "li3 = li1 + li2\n",
    "print(li3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are methods that can be used as list operations, to modify list content. \n",
    "* .append()  appending one or more elements at the end of a list\n",
    "* .reverse() reverse the order of a list\n",
    "* .sort()    sort a list, starting by the lowest value\n",
    "* .insert()  takes two arguments, the first one for the position in the list the second one for the value \n",
    "* .count()   counts how often a value appears in a list\n",
    "* .index()   returns the index (position number) of an element in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_unsorted = [5,7,2,4,9,1]\n",
    "list_unsorted.sort()\n",
    "print(list_unsorted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list3 = [1,2,3]\n",
    "my_list3.append(\"new\")\n",
    "print(my_list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list3.index(\"new\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple\n",
    "A tuple is similar to a list, but is created by using parentheses. The main difference between tuple and list is, that a tuple is immutable while a list is mutable. Values are stored in tuples can not be changed after creation. The only possibility is changing tuple content while saving or coping it to another tuple. You probably won't use tuples as much as lists and dictionaries. Tuples are created by either using parentheses or the tuple() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_tuple = (1,2,3,4,5)\n",
    "second_tuple = tuple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary\n",
    "Dictionaries are a sort of hash mapping and can be recognized by the curly braces. Furthermore, they can be created by using the dict() function. They are very useful for storing and indexing information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_dict = {}\n",
    "second_dict = dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are an unordered set of key:value pairs. The order, in comparision with lists or tuples does not matter here. A key can be anything, an integer or string for example. Key:value pairs are separated by a comma. While the key has to be unique, the value does not. One can access the value by using the key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {1:\"one\", 2:\"two\", 3:\"three\"}\n",
    "dict1[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two methods key() and values() can be used to get all keys and values. This is helpful if one does not really know what is stored in a dictionary. The item() method is also helpful by analysing a dictionary, because it returns the key-value pairs as tuples stored in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Values may need to be changed. To do this you access the value by using the key and set it to another value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict2 = {\"Aachen\":0.245885, \"Köln\":1.086, \"Düsseldorf\":219.294}\n",
    "dict2[\"Düsseldorf\"] = 619.294\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing\n",
    "In the following part, python comes with a lot of predefined code. There are also a lot of packages and modules which can be imported. Using the **import** keyword to import modules. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If not the hole input of a module is need, one can just import a function from the module be using **from**  \n",
    "from the module import function. If you run the code below you will not get a visual output, it is a background operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sys import argv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It may happen that an import looks like the following code cell shows, this is done due to simplification. If you import a library like this you just need to write the \"nickname\" when calling for example function or methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dtypes\n",
    "When working with NumPy you need to know **dtypes** - data tyoe objects. NumPy Arrays contain homogeneous data types such as **int** and **float**. Dtypes allow us to create structured arrays (record arrays). Structured arrays are used to have different data types in different columns of one table, as you can declare types for every column.  \n",
    "Some examples of dtypes:  \n",
    "* object\n",
    "* int64\n",
    "* float64\n",
    "* datetime64\n",
    "* bool\n",
    "\n",
    "[NumPy dtpyes](https://numpy.org/doc/stable/reference/arrays.dtypes.html) describe how bytes in a fixed-size block (array) should be interpreted."
   ]
  }
 ],
 "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.7.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "668.717px",
    "left": "940px",
    "top": "171.133px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}