01 - Python basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python basics\n",
    "\n",
    "A quick recap from the introduction sent before the course started "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Variables\n",
    "\n",
    "A variable is just a way to store values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# It is possible to perform direct calculations using any Python interpreter. For instance:\n",
    "13 + 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# however, this is not very useful for data analysis, so we can assign values to a variable,\n",
    "# and we can use that variable at any time:\n",
    "birth_year = 1769\n",
    "death_year = 1821"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The we can perform calculations, like:\n",
    "print('Napoleon Bonaparte lived for', death_year - birth_year, 'years')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Types of data\n",
    "\n",
    "Python deals with various types of data. Three common ones are:\n",
    "\n",
    "* integer numbers\n",
    "* floating point numbers, and\n",
    "* strings\n",
    "\n",
    "In the previous example, **birth_year** and **death_year** were **integer numbers**. **Floating point numbers** include a decimal point, so it is easy to performa calculations with this type of data too. However, with **strings**, things get a little more complicated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "birth_date = '15/08/1769'\n",
    "death_date = '05/05/1821'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now the dates have more information and are stored as STRINGS instead of INTEGERS. If we try the same, we will get an error:\n",
    "print('Napoleon Bonaparte lived for', death_date - birth_date, 'years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We need to manipulate the data\n",
    "import datetime as dt # importing a package tha deals with dates\n",
    "date_format = \"%d/%m/%Y\" # defining the standard date format\n",
    "\n",
    "# assuring our data is in the right date format\n",
    "birth_date = dt.datetime.strptime(birth_date, date_format).date() \n",
    "death_date = dt.datetime.strptime(death_date, date_format).date()\n",
    "\n",
    "# getting our result\n",
    "print('Napoleon Bonaparte lived for', (death_date - birth_date).days, 'days')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Storing data in Python\n",
    "\n",
    "Besides variables, there are other ways of storing data in Python. The two most common are:\n",
    "\n",
    "* lists\n",
    "* dictionaries\n",
    "\n",
    "While with lists we can store multiple values (but only values!), with dictionaries we can store values that are associated with keys! Let's see an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# below we have two lists: one with historical actors and the other with their birth dates\n",
    "historical_actors = ['Isabella I of Castile','Napoleon Bonaparte','Catherine the Great','Martin Luther','Queen Victoria']\n",
    "birth_dates = ['22/04/1451','15/08/1769','02/05/1729','10/11/1483','24/05/1819']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can create a single dictionary with these two lists, with historical actors as keys and\n",
    "# their respective birth dates as values\n",
    "birth_actors = {'Isabella I of Castile':'22/04/1451','Napoleon Bonaparte':'15/08/1769','Catherine the Great':'02/05/1729',\n",
    "                'Martin Luther':'10/11/1483','Queen Victoria':'24/05/1819'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Manipulating data\n",
    "\n",
    "Two very basic and also very practical ways of manipulating data are:\n",
    "\n",
    "* slicing\n",
    "* for loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Slicing\n",
    "\n",
    "**Very, very important** - In Python the index (the position of a value) starts at 0, so when slicing we have to keep this in mind! The first value of a list, for instance, has index 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the entire list (our dataset)\n",
    "print(historical_actors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# one may be interested only in the first three values of the dataset\n",
    "print(historical_actors[0:3]) # the first limit (the value before the ':') is included, but the second limit is not!\n",
    "print(historical_actors[:3]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or perhaps, in the last four values of the data\n",
    "print(historical_actors[-4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or yet, only in the values in specific positions\n",
    "print(historical_actors[1:3])\n",
    "print(historical_actors[2:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a string can work as a list of characters\n",
    "sentence = 'I am a short sentence!'\n",
    "print(len(sentence))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and slicing works just the same\n",
    "print(sentence[0])\n",
    "print(sentence[-1])\n",
    "print(sentence[7:12])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### For loops\n",
    "\n",
    "This is a technique used when we want to repeat the same task, several times, as for instance, for every value of the dataset. There are two main ways of performing for loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first, we can 'call' values directly\n",
    "for actor in historical_actors:\n",
    "    print(actor)\n",
    "    \n",
    "for date in birth_dates:\n",
    "    print(date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# second, we can 'call' values using their indexes \n",
    "# this is particularly useful when we have more than one list (they must be of the same length!), for example\n",
    "\n",
    "for i in range(len(historical_actors)): \n",
    "    print('The birth of', historical_actors[i], 'was on', birth_dates[i])\n",
    "    \n",
    "# this reads as: for every index in the range of the length of the list containing the historical actors,\n",
    "# print their name and their birthdate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### List comprehension\n",
    "\n",
    "This is a one-line way of creating a list (dictionary) using a for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [c for c in sentence]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Control flow\n",
    "\n",
    "This deals with conditional statements: `if`, `elif`, `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 23 # change this variable\n",
    "\n",
    "if a < 10:  # trifft das zu? falls ja, \"break\"\n",
    "    print(str(a) + \" kleiner 10\")\n",
    "elif a == 0:  # oder trifft das zu? falls ja, \"break\"\n",
    "    print(str(a) + \" ist 0\")\n",
    "elif a < 20:  # oder trifft das zu?\n",
    "    print(str(a) + \" größer 10 kleiner 20\")\n",
    "elif a == 10:  # oder trifft das zu?\n",
    "    print(str(a) + \" ist gleich 10\")\n",
    "else:\n",
    "    print(str(a) + \" größer 10 (bzw. 20)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now let's use a loop with control flow\n",
    "\n",
    "zahl = 17.0 # the idea is to check if this variable is a prime number\n",
    "anzTeiler = 0\n",
    "k = 1\n",
    "\n",
    "while k < zahl:  # Schleife mit Abbruchbedingung, \":\" = dann\n",
    "    e = zahl / k  # einrücken\n",
    "    ge = int(e)\n",
    "    if e != ge:  # falls if nicht erfüllt, automatisch \"else: break\"\n",
    "        anzTeiler = anzTeiler + 1\n",
    "    k = k + 1\n",
    "if anzTeiler == zahl - 2:\n",
    "    # Primzahl, wenn Zahl nicht durch n-2 teilbar.\n",
    "    # Nicht durch sich selbst und 1 teilbar, also von 2. bis n-1 gerechnet.\n",
    "    print(\"Hurra Primzahl!\", k)\n",
    "else:\n",
    "    print(\"Keine Primzahl!\", k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Function \n",
    "\n",
    "A function take data (parameters) to do a specific task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here we have a (super simple) function that returns in a readable way how many characters a string has\n",
    "\n",
    "def stringLength(s):\n",
    "    \"\"\"\n",
    "    Print a string 's' and tell how many characters it has    \n",
    "    \"\"\"\n",
    "    \n",
    "    print(s + \" has \" + str(len(s)) + \" characters\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stringLength(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stringLength('I can add any string as parameter')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stringLength(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a Python function...\n",
    "1. to reverse a string\n",
    "2. that accepts a string and calculate the number of upper case letters and lower case letters\n",
    "3. that checks whether a passed string is palindrome or not\n",
    "4. that accepts a hyphen-separated sequence of words as input and prints the words in a hyphen-separated sequence after sorting them alphabetically"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reversing a string\n",
    "\n",
    "def string_reverse(str1):\n",
    "\n",
    "    rstr1 = ''\n",
    "    index = len(str1)\n",
    "    while index > 0:\n",
    "        rstr1 += str1[index-1]\n",
    "        index = index - 1\n",
    "    return rstr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# upper case and lower case\n",
    "\n",
    "def string_test(s):\n",
    "    d={\"UPPER_CASE\":0, \"LOWER_CASE\":0}\n",
    "    for c in s:\n",
    "        if c.isupper():\n",
    "           d[\"UPPER_CASE\"]+=1\n",
    "        elif c.islower():\n",
    "           d[\"LOWER_CASE\"]+=1\n",
    "        else:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# palindrome\n",
    "\n",
    "def isPalindrome(string):\n",
    "    left_pos = 0\n",
    "    right_pos = len(string) - 1\n",
    "\n",
    "    while right_pos >= left_pos:\n",
    "        if not string[left_pos] == string[right_pos]:\n",
    "            return False\n",
    "        left_pos += 1\n",
    "        right_pos -= 1\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hyphen-separated words\n",
    "\n",
    "def sortWords(str2):\n",
    "    \n",
    "    items=[n for n in str2.split('-')]\n",
    "    items.sort()\n",
    "    return items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}