tutorials/tut01_print_comments_strings_numbers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c2073762",
   "metadata": {},
   "source": [
    "# Python Crash Course 01 - Print, Comments, Strings, and Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51e89896",
   "metadata": {},
   "source": [
    "## The notebook environment\n",
    "\n",
    "Notebook environments consist of two types of cells:\n",
    "- Markdown cells (like this one), for writing formatted text\n",
    "- Code cells, for writing and executing Python source code\n",
    "\n",
    "Also, there are two _modes_ in a notebook environment:\n",
    "- Edit mode: for changing the content of a cell\n",
    "- Command mode: for creating, moving, deleting one or multiple cells\n",
    "\n",
    "_Edit mode_ can be intered in different ways:\n",
    "- Double-click on a markdown cell\n",
    "- Single-click in a code cell\n",
    "- Hit <kbd>Enter</kbd> when any cell is selected in command mode\n",
    "\n",
    "In _edit mode_, the usual text-editing shortcuts work:\n",
    "- <kbd>Ctrl</kbd>+<kbd>c</kbd> to copy selected text\n",
    "- <kbd>Ctrl</kbd>+<kbd>v</kbd> to paste something\n",
    "- <kbd>Tab</kbd> for text completion (if your notebook environment supports it)\n",
    "\n",
    "\n",
    "To switch to _command mode_, hit <kbd>Esc</kbd>. Below you'll find some of the most commonly used shortcuts. In Colab, you'll have to press <kbd>Ctrl</kbd>+<kbd>m</kbd> before entering the shortcut, in VS Code and JupyterLab they work directly.\n",
    "- <kbd>a</kbd> create a new cell _above_ the currently selected\n",
    "- <kbd>b</kbd> create a new cell _below_ the currently selected\n",
    "- <kbd>c</kbd> copy selected cell(s)\n",
    "- <kbd>v</kbd> paste copied cell(s) below the selected one\n",
    "- <kbd>d</kbd><kbd>d</kbd> delete the selected cell(s) (yes, that's hitting <kbd>d</kbd> twice)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d29f1e24",
   "metadata": {},
   "source": [
    "## Print\n",
    "The function `print` allows to show something to the user. The message to be printed needs to be surrounded by quotes (`\"` or `'`). The printed words that appear as a result of the `print` function are referred to as _output_. \n",
    "\n",
    "What you see below is a _code cell_. Place the cursor in the cell (i.e. click on it) and press <kbd>Shift</kbd>+<kbd>Enter</kbd> to execute it. \n",
    "\n",
    "Note: If you double click this text, its \"source code\" will be shown.<kbd>Esc</kbd>gets you back to the rendered version.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bfbfef3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello beautiful people\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09c6d7f7",
   "metadata": {},
   "source": [
    "By default, the print functions also prints a _newline_ (`\\n`) at the end of the string, so the next print starts off in a new line:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6503fd8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\")\n",
    "print(\"Goodbye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51c9dd61",
   "metadata": {},
   "source": [
    "You can also print the contents of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dcacc75",
   "metadata": {},
   "outputs": [],
   "source": [
    "saying_hello = \"Hello there!\"\n",
    "saying_goodbye = \"Hasta la vista!\"\n",
    "\n",
    "print(saying_hello)\n",
    "print(saying_goodbye)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "258db1b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "saying_hello"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41d9af38",
   "metadata": {},
   "source": [
    "What happened here?  \n",
    "__In a notebook environment, the result of the last expression is always displayed!__  \n",
    "This is _not_ normal Python behaviour. In order to show output in a terminal (or show intermediate output in a notebook environment), `print` is required."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7260d005",
   "metadata": {},
   "source": [
    "## Comments\n",
    "_Comments_ allow you to tell the Python interpreter to _ignore_ something. This is useful in two situations:\n",
    "\n",
    "- providing additional plain text information to someone reading the code\n",
    "- trying different implementations without needing to actually (re)move code\n",
    "\n",
    "In Python, comments start with a number sign (pound or hash sign): `#`. They can be placed in their own line or next to some code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58af2a2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the first time we're using comments\n",
    "\n",
    "print(\"Commenting is great!\")  # commenting should be encouraged"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcd40215",
   "metadata": {},
   "source": [
    "If you comment out a line of code, it won't be executed. \n",
    "\n",
    "Try to comment out the first line and uncomment the second one!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8eb55fa7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\")\n",
    "# print(\"Goodbye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45a6fb7a",
   "metadata": {},
   "source": [
    "Most programming environments have keyboard shortcuts to comment and uncomment a line or block of code (so you don't have to add/remove the `#` in each individual line). Most commonly, those are <kbd>Ctrl</kbd>+<kbd>/</kbd> or <kbd>Ctrl</kbd>+<kbd>#</kbd>, depending on your keyboard layout. You can try with the block of print statements below (select multiple lines and press the keys). If neither of the two works, take a look at the shortcut list (in Colab, go to \"Tools\" -> \"Keyboard shortcuts\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "567f5ff4",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"So\")\n",
    "print(\"many\")\n",
    "print(\"lines\")\n",
    "print(\"to\")\n",
    "print(\"(un-)\")\n",
    "print(\"comment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "294c984f",
   "metadata": {},
   "source": [
    "## Best practices\n",
    "- Code itself exactly states what the program will do. Therefore, instead of explaining in plain text _what_ the code does (which will often be less specific), try to explain _why_ a part of the code is needed.\n",
    "- Sometimes someone will read the code in the future, think \"oh, there should be a much easier way to do this\". This someone will often be you and the \"easy way\" may turn out to be difficult of not work at all. So, if you tried multiple approaches to a problem before you arrived at a solution, you might want to state why the others didn't work. \n",
    "- Add a single space between the `#` and the comment text for readability.\n",
    "- You'll find more best practices [here](https://pep8.org/#comments).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2817e85",
   "metadata": {},
   "source": [
    "## Strings\n",
    "- [Video tutorial (21 min)](https://www.youtube.com/watch?v=k9TUPpGqYTo)\n",
    "- [Library reference](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)\n",
    "\n",
    "Strings hold textual data. A string in python is created with double quotes (`\"`) or single quotes (`'`) (Don't mix them up!). Each string can be seen as a sequence of characters.\n",
    "You can do a lot with strings and since Python is a cool programing language it provides a big set of string methods to use. Here are some of the most commonly used (you'll find a lot more in the [library reference](https://docs.python.org/3/library/stdtypes.html#string-methods)):\n",
    "\n",
    "| Method          | Action                                                |\n",
    "|-----------------|-------------------------------------------------------|\n",
    "| `len(string)`   | gives the length of the string (amount of characters) |\n",
    "| `string[4]`     | gives the 4th character of the string (begin to count at 0!)\n",
    "| `str.join(iterable)` | joins the iterable to a string. `str` is the delimiter between the elements |\n",
    "| `str.split(sep=None, maxsplit=-1)`| splits the string by the seperator |\n",
    "| `str.find(sub[, start[, end]])` | finds the substring in `str` and returns the index |\n",
    "| `str.replace(old, new[, count])`| replaces `old` with `new` in `str` |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a506c5cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "string_1 = \"Hello\"\n",
    "string_2 = 'World'\n",
    "\n",
    "type(string_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "effa93c5",
   "metadata": {},
   "source": [
    "What? Math on string? This is getting crazy.  \n",
    "But actually it makes sense:  \n",
    "Strings can be concatenated (\"put together\") using `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "501753c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "string_1 + \" \" + string_2\n",
    "# string_2 + \" \" + string_1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc090cf7",
   "metadata": {},
   "source": [
    "If you want to repeat a string multiple times you can use `*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27db3530",
   "metadata": {},
   "outputs": [],
   "source": [
    "string_1 * 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e18440d",
   "metadata": {},
   "source": [
    "To get a single character of the string you can use square brakets. Be carefull, we programmers always start with 0 when counting!  \n",
    "For example the string `hello_world = \"Hello World\"` has following indexing:  \n",
    "```python\n",
    "hello_world[0] = 'H'\n",
    "hello_world[1] = 'e'\n",
    "hello_world[2] = 'l'\n",
    "hello_world[3] = 'l'\n",
    "hello_world[4] = 'o'\n",
    "hello_world[5] = ' '\n",
    "hello_world[6] = 'W'\n",
    "hello_world[7] = 'o'\n",
    "hello_world[8] = 'r'\n",
    "hello_world[9] = 'l'\n",
    "hello_world[10] = 'd'\n",
    "```\n",
    "\n",
    "You can also get a substrings from the string by using slicing. It always follows the same pattern:  \n",
    "```python\n",
    "str[start:end:stepsize]\n",
    "```\n",
    "If there's only one colon (`:`), \n",
    "Notice `start` is always _inclusive_ while `end` is _exclusive_:\n",
    "\n",
    "```python\n",
    "hello_world[0:4] = 'Hell'\n",
    "hello_world[0:4:2] = 'Hl'\n",
    "hello_world[0:-3] = 'Hello Wo'\n",
    "hello_world[0:-3:3] = 'HlW'\n",
    "hello_world[::] = 'Hello World'\n",
    "hello_world[::-1] = 'dlroW olleH'\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "167b6bb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "hello_world = \"Hello World\"\n",
    "hello_world[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4cde4c4",
   "metadata": {
    "tags": []
   },
   "source": [
    "Now let´s also take a look at the methods we mentioned earlier that exist for strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c3bc861",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "string = \"I am a string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efd5d4b4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "len(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68b4b01d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "splitted_string = string.split(\"a\")\n",
    "splitted_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86a02e01",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"_hallo_\".join(splitted_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6a13e38",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "string.find(\"z\") # returns the index. What happens if the substring does not exist?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cb8a65b",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Numbers\n",
    "- [Video tutorial (12 min)](https://www.youtube.com/watch?v=khKv-8q7YmY)\n",
    "- [Library reference](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "127cce8a",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Integers:\n",
    "An Integer is a Datatype which holds whole Numbers. The Numbers can be negative or positiv. In python Integers have unlimited precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebaa533d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "an_integer = 5\n",
    "type(an_integer) # The type is int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1c0d4f1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "an_integer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ef29e97",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Float:\n",
    "A Float is a Datatype which holds numbers with decimal places. The Numbers can be negative or positiv. In python floats have a limited precision, which is dependent on the system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ae040a3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a_float = 1.45\n",
    "type(a_float) # the type is float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b8ea3a6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "a_float"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6322fca",
   "metadata": {},
   "source": [
    "## Conversion\n",
    "Floats can be turned into integers (this cuts off the decimal places, no rounding is performed!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54d5c865",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "int(1.45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "148a58a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "int(9.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "306c7dde",
   "metadata": {},
   "source": [
    "This works the other way around as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d3ef387",
   "metadata": {},
   "outputs": [],
   "source": [
    "float(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f547a65",
   "metadata": {},
   "source": [
    "Integers and floats can also be created from strings containing only digits (and up to 1 decimal point in case of floats):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9554f454",
   "metadata": {},
   "outputs": [],
   "source": [
    "float(\"1.234\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7678f8cb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "int(\"444\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b4b7ce0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "int(\"1.234\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bac4b3ac",
   "metadata": {},
   "source": [
    "Again, the other way around works too (the quotes tell us the results are strings):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c482377a",
   "metadata": {},
   "outputs": [],
   "source": [
    "str(12.345)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ec0e93a",
   "metadata": {},
   "outputs": [],
   "source": [
    "str(81926379182793812)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11738901",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Math\n",
    "With the now newly learned numbers you can also perform math. Following operations are available in python (with floats and integers):\n",
    "\n",
    "| Syntax         | Action                                                                      | Notes  |\n",
    "|-------------------|-----------------------------------------------------------------------------|--------|\n",
    "| `x + y`           | sum of x and y                                                              |        |\n",
    "| `x - y`           | difference of x and y                                                       |        |\n",
    "| `x * y`           | product of x and y                                                          |        |\n",
    "| `x / y`           | quotient of x and y                                                         |        |\n",
    "| `x // y`          | floored quotient of x and y                                                 | (1)    |\n",
    "| `x % y`           | remainder of x / y (modulo)                                                |     |    \n",
    "| `-x`              | x negated                                                                   |        |\n",
    "| `x**y`          | x to the power y                    | (2), (3)    |\n",
    "| [`abs(x)`](https://docs.python.org/3/library/functions.html#abs)          | absolute value of x                                            |        |\n",
    "| [`round(x)`](https://docs.python.org/3/library/functions.html#round)        | round x to the nearest integer    |||\n",
    "| [`round(x, n)`](https://docs.python.org/3/library/functions.html#round)        | round x to n decimal places    |||\n",
    "| [`divmod(x, y)`](https://docs.python.org/3/library/functions.html#divmod)    | the pair (x // y, x % y)                                                    |    |\n",
    "\n",
    "Notes:\n",
    "\n",
    "(1) Also referred to as integer division. The resultant value is a whole integer, though the result’s type is not necessarily int. The result is always rounded towards negative infinity: `1//2` is `0`, `(-1)//2` is `-1`, `1//(-2)` is `-1`, and `(-1)//(-2)` is `0`.\n",
    "\n",
    "(2) Python defines `0**0` to be `1`, as is common for programming languages.\n",
    "\n",
    "(3) Attention: `x^y` is not the power but the bitwise XOR of the two numbers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "524dfbee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# use parentheses to change the order of operations:\n",
    "print(1 + 2 * 3)\n",
    "print((1 + 2) * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0016fb5b",
   "metadata": {},
   "source": [
    "# f-strings\n",
    "\n",
    "Using _formatted string literals_ (\"f-strings\" for short), it is super easy to put variables into some predefined text. Prefix the string with an `f` and put the desired variables into curly brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82963855",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Tim\"\n",
    "age = 23\n",
    "\n",
    "print(f\"Hi, my name is {name} and I'm {age} years old!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "426d23c4",
   "metadata": {},
   "source": [
    "The curly brackets can contain arbitrary Python expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9924c089",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Hi, my name is {name} and in two years I'll be {age + 2}!\")"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "46e2835a142a16ae115bce5fddf19f27ce13b17a4ab8ded638c88ab5ce5171d2"
  },
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}