0_General_Variables-Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "22d39c1f",
   "metadata": {},
   "source": [
    "# Python Intro\n",
    "17.03.2022\n",
    "\n",
    "Welcome to the \"first\" Python intro course. The course/tutorial is written for python beginners but contains also elements for coders that want to learn some more complex constructs of Python in order to accelerate their own code.\n",
    "\n",
    "\n",
    "## What is Python?\n",
    "\n",
    "Python is a **high-level**, **intepreted**, **object orientated** programming language developed for general purpose and designed to provide easy code readability. You will see that many constructs in Python can be read just like sentences in English. This makes the language a very popular choice with coding beginners but also has some drawbacks:\n",
    "\n",
    "- Pro:\n",
    "    - **high-level** --> Easy to read and write, e.g. no memory management\n",
    "    - **intepreted** --> Just start your script. No compilation needed\n",
    "    - **object orientated** --> Everything is an object, even functions can be used as objects\n",
    "- Contra:\n",
    "    - **high-level**, **intepreted** --> Translated into C which is/can be >1000 faster when written natively\n",
    "    - **object orientated** --> Great until you need to create 10 million objects --> Slow\n",
    "\n",
    "\n",
    "So the biggest drawback when working with Python is the performance. Python can be slow unless you know some tricks --> Write less code in Python --> Let's use internal functions written in C do the work for you (Similar to R, where you just instruct R what it should do, but you dont change values by yourself). \n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "263e3d99",
   "metadata": {},
   "source": [
    "## Basic Intro\n",
    "\n",
    "Jupyter is a great environment to learn Python. Any code that we write here can also be put into a python script (e.g `helloworld.py`) and be executed using the default python command `python helloworld.py`.\n",
    "\n",
    "Code in the cells can be executed using `CTRL + Return`. \n",
    "\n",
    "Let's get started.\n",
    "\n",
    "\n",
    "Print the string `hello world`. You can use `'` or `\"` to define strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c68d963",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('hello world') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2c05715",
   "metadata": {},
   "source": [
    "Same as using `\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "421b1893",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83c0480d",
   "metadata": {},
   "source": [
    "Comments in the code (parts that Python just ignores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0350255",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "I'm a comment\n",
    "'''\n",
    "print(\"hello world\") # I'm a comment too\n",
    "# Also a comment\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e94a14f1",
   "metadata": {},
   "source": [
    "### Variables - Primitive Data types\n",
    "\n",
    "You can store values in variables. The name is basically a placeholder for the value. You create a variable by assigning a value to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e83a7a10",
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 5\n",
    "variable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f82e181d",
   "metadata": {},
   "source": [
    "The same variable can be reassigned to hold a different value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "574f2c2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 5\n",
    "print(variable)\n",
    "variable = 10\n",
    "print(variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c78f17e0",
   "metadata": {},
   "source": [
    "Python is dynamically typed. A variable can be any type and the type can change. Currently the variable is a integer. Lets assign a string to the same variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79cc9b64",
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = 5\n",
    "print(type(variable))\n",
    "print(variable)\n",
    "variable = '5'\n",
    "print('-----')\n",
    "print(type(variable))\n",
    "print(variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f014277a",
   "metadata": {},
   "source": [
    "Not only can the data type of a variable change during runtime but casting is not done by default (compare to loading a table in R). But you can cast explicitly.\n",
    "\n",
    "Guidelines:\n",
    "\n",
    "- try not to reuse variables - This might have side effects somewhere else in the code\n",
    "- use better variable names - So don't use the name `variable` :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "980ab3d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "variable = '5'\n",
    "print(type(variable)) # I'm a string\n",
    "print(variable)\n",
    "print('-----')\n",
    "variable = int(variable) # I'm a int now\n",
    "print(type(variable))\n",
    "print(variable)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3ac255d",
   "metadata": {},
   "source": [
    "### Exercise  - 5 min\n",
    " \n",
    "- What basic/primitive data types are known to python?\n",
    "- Can they be sorted into groups?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e56e80fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO, primitive data types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f422776",
   "metadata": {},
   "source": [
    "### Variables - Primitive Data Types - Continued\n",
    "\n",
    "You can also assign multiple variables at once. Doesn't look impressive. But can make your coding more easy when working with loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4842f4bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "apples, oranges = 'Apples', 'Oranges'\n",
    "apples, oranges # (These, Brackets, indicate, another, type) --> tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a690641f",
   "metadata": {},
   "source": [
    "### Operators\n",
    "\n",
    "So, what can we do with primitive data types like `int`, `float`, `str`?\n",
    "\n",
    "addition, substraction, multiplication, modulus, ... --> There are different types of operators.\n",
    "\n",
    "#### Exercise - 5-10 min\n",
    "\n",
    "- Experiment with the operators. Apply different data types. E.g. what happens when you \"sum\" up two strings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc1f956a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 6\n",
    "print(x + x)\n",
    "print(x + y)\n",
    "print(x / y)\n",
    "print(x * y)\n",
    "print(y % x)\n",
    "print(x ** y)\n",
    "print(y // x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd197c91",
   "metadata": {},
   "source": [
    "There is a large number of operators and most do exactly what you would expect them to do. Thing just go a bit crazy when you apply operators on different data types. See below for an example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93d56722",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = '5'\n",
    "print(x + y) # This will fail. Why? How would you fix it?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51171c3d",
   "metadata": {},
   "source": [
    "What happens when you mix numerical data types and apply an operator?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9f0d350",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just an example. Feel free to experiment\n",
    "x = 10.0\n",
    "y = 5\n",
    "print(x / y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5578829",
   "metadata": {},
   "source": [
    "### Summary Variables/Operators:\n",
    "\n",
    "Common exercise\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0de7ecff",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}