01 Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"center\" src=\"http://sydney.edu.au/images/content/about/logo-mono.jpg\">\n",
    "<h1 align=\"center\" style=\"margin-top:10px\">Statistical Learning and Data Mining</h1>\n",
    "<h3 align=\"center\" style=\"margin-top:20px\">Tutorial 1: Introduction to Python</h3>\n",
    "<br>\n",
    "\n",
    "This tutorial is an introduction to the essentials of the Python programming language for purposes of the course. We assume that you followed the [instructions](http://marcelscharth.com/python/#setting-up-python) for installing Python and have your notebook ready to go."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<a href=\"#1.-Getting-Started<\">Getting Started</a> <br>\n",
    "<a href=\"#2.-Modules\">Modules</a> <br>\n",
    "<a href=\"#3.-Data-Types\">Data Types</a> <br>\n",
    "<a href=\"#4.-Data-Structures\">Data Structures</a> <br>\n",
    "<a  style=\"margin-left:20px\" href=\"#4.-Data-Structures\">Lists</a><br>\n",
    "<a  style=\"margin-left:20px\" href=\"#4.-Data-Structures\">Dictionaries</a><br>\n",
    "<a  style=\"margin-left:20px\" href=\"#4.-Data-Structures\">Tuples</a><br>\n",
    "<a href=\"#5.-For-Loops\">For Loops</a> <br>\n",
    "<a href=\"#6.-Functions\">Functions</a> <br>\n",
    "<a href=\"#7.-If-Statements\">If Statements</a> <br>\n",
    "<a href=\"#8.-Arrarys\">Arrays</a> <br>\n",
    "<a href=\"#9.-Programming-Tips\">Programming Tips</a> <br>\n",
    "<a href=\"#10.-Exercises\">Exercises</a> <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Getting Started\n",
    "\n",
    "To get started, you can use your notebook as a calculator. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise: identify the use of following arithmetic operators: `+`,`−`,`∗`,`/`,`∗∗`,`%`.\n",
    "\n",
    "The following statement assigns a value to the variable `x`. Because the variable does not yet exist, the assignment statements creates the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise: identify what the syntax `x += 2` does (we say that `+=` is an assignment operator).\n",
    "\n",
    "The `print` function allows you to display output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For truth is always strange; stranger than fiction.\n"
     ]
    }
   ],
   "source": [
    "print('For truth is always strange; stranger than fiction.') # Lord Byron (the # starts a comment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `print` function is a built-in function which is part of the core of the Python programming language. Another example of a built-in function is `abs`, which computes the absolute value of a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Modules\n",
    "\n",
    "The Python language by design has a small core. Mst of the fuctionality that we need is in modules or packages that we need to explicity load into our session. There are two ways to do this: either by loading the entire modulue (or a submodule) or a specific function that we need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sqrt(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt \n",
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use a number of different Python libraries thoughout this course, including Pandas (data processing),  Matplotlib (plotting), Seaborn (to make plots elegant), StatsModels (statistics), NumPy (scientific computing), and Scikit-Learn (machine learning)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Data Types\n",
    "\n",
    "**3.1 Boolean variables**\n",
    "\n",
    "The most basic data type is a `Boolean` variable, which can be either `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = False\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 2 > 0\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exercise: identify the use of following comparison operators: `==`, `!=`, `>=`, `<=`.\n",
    "\n",
    "Exercise: explain the code below in detail. You may want to break this down into four steps. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 3 % 2 == 0\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In numerical expressions, a `False` is automatically converted to zero and a `True` is converted to one. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x= True\n",
    "y = 2*x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3.2 Numbers**\n",
    "\n",
    "There are two main built-in numerical data types, signed integers (`int`) and floating point real values (`float`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1 \n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1.0\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, we need to do a explicit type conversion (typecasting), as the next example shows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "x = a > 0\n",
    "y = int(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3.3 Strings**\n",
    "\n",
    "String variables represent text data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence = 'For truth is always strange; stranger than fiction.' \n",
    "type(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we are going to see in a text analytics application, Python has sophisticated capability for string manipulation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Data Structures\n",
    "\n",
    "In computer science, a data structure is a way to store and organise data for efficient retrieval and modification. The four basic Python data structures lists, dictionaries, tuples and arrays. We introduce the first three in this section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.1 Lists**\n",
    "\n",
    "A list is a sequence of values. The values in a list, known as elements or items, can be of any type. To create a list, we enclose the elements in brackets `[ ]`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [ ] # empty list\n",
    "b = [1, 2, 5, 10] # list of four numbers\n",
    "cities = ['Sydney', 'Melbourne', 'Brisbane']\n",
    "c = [2, 4, 'Sydney'] # list mixing different variable types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several list methods and operations that you should be familiar with.  The `append` method inserts a new element to the end of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sydney', 'Melbourne', 'Brisbane', 'Perth']\n"
     ]
    }
   ],
   "source": [
    "cities.append('Perth')\n",
    "print(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `len` function counts the number of items in a list. It also works for counting the number of items in other types of containers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We retrieve elements by passing the numerical index. What is crucial for you to know is that numerical indexes start from zero in Python. Here are some examples: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sydney'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities[0] # first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Brisbane'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities[2] # third element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Perth'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities[-1] # last element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often, we need to retrieve a slice of a list. This can be a bit confusing initially, so here are several examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sydney', 'Melbourne']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities[:2] # first two elements/all elements up to index 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Melbourne', 'Brisbane']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities[1:3] # elements in indexes 1 to 2 (the element in index 3 is not part of the slice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Melbourne', 'Brisbane', 'Perth']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities[1:] # all elements from index 1 onwards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Brisbane', 'Perth']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities[-2:] # last two elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `+` operator concatenates lists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5, 10]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "b = [3, 5, 10]\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `in` expression allows to check if a certain item is present in a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Sydney' in cities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Copenhagen' in cities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also useful to know how to sort lists. The sorted function will return a sorted copy of an object. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Brisbane', 'Melbourne', 'Perth', 'Sydney']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast, the `sort()` method will modify the list itself by sorting it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sydney', 'Melbourne', 'Brisbane', 'Perth']\n",
      "['Brisbane', 'Melbourne', 'Perth', 'Sydney']\n"
     ]
    }
   ],
   "source": [
    "print(cities)\n",
    "cities.sort()\n",
    "print(cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.2 Dictionaries**\n",
    "\n",
    "A dictionary is a collection of key-value pairs. We create a dictionary by providing the key-value pairs within curly brackets `{ }`. For example, in the dictionary below the keys are the names of the cities and the values are the population of each city. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "population = {'Sydney': 5230330, 'Melbourne': 4936349, 'Brisbane' : 2462637}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We retrieve a value by referring to the key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5230330"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population['Sydney']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to create a dictionary is as follows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'country': 'Australia', 'state': 'NSW', 'postcode': 2006}\n"
     ]
    }
   ],
   "source": [
    "address = {} # empty dictionary\n",
    "address['country'] = 'Australia'\n",
    "address['state'] = 'NSW'\n",
    "address['postcode'] = 2006\n",
    "print(address)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4.3 Tuples**\n",
    "\n",
    "A tuple is an immutable list: we can neither modify the elements of a tuple nor insert or remove items from it. We usually create a tuple by enclosing the elements in parentheses `( )`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 'cat', 'dog')\n"
     ]
    }
   ],
   "source": [
    "a = (1, 2, 'cat', 'dog')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's also possible to create a tuple without the parentheses in the syntax, though this can make the code less clear. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 'cat', 'dog')\n"
     ]
    }
   ],
   "source": [
    "a = 1, 2, 'cat', 'dog'\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful operation is tuple unpacking, shown in the next two examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "numbers = (1, 2)\n",
    "a, b = numbers\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[*numbers, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. For Loops\n",
    "\n",
    "Often, we need to traverse a list and run code that takes each item as an input. We use a `for` block to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sydney\n",
      "Melbourne\n",
      "Brisbane\n",
      "Perth\n"
     ]
    }
   ],
   "source": [
    "cities = ['Sydney', 'Melbourne', 'Brisbane', 'Perth']\n",
    "\n",
    "for city in cities:\n",
    "    print(city)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two important details to note in this syntax. The `for` loop would work with any alias instead of `city`, as long as we use it consistently. However, we say that choosing a meaningful alias makes the code more *Pythonic* (clean and readable).  \n",
    "\n",
    "Each iteration of the loop will repeat the code in the indented part of the block, below the `for` statement. In order for the syntax to be correct, the indentation needs to be four spaces. The editor adds it automatically.\n",
    "\n",
    "Here's another example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "25\n",
      "100\n",
      "The code then continues from here\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 5, 10]\n",
    "\n",
    "for number in numbers:\n",
    "    x = number**2\n",
    "    print(x) \n",
    "    \n",
    "print('The code then continues from here') # outside the for block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For loops are applicable to any iterable objects. We commonly write loops over a numerical range, as the next two examples show. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 11, 2): # starts at 1, ends before 11, step size 2\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `enumerate` function is useful for obtaining an indexed list: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "City 0: Sydney\n",
      "City 1: Melbourne\n",
      "City 2: Brisbane\n",
      "City 3: Perth\n"
     ]
    }
   ],
   "source": [
    "cities = ['Sydney', 'Melbourne', 'Brisbane', 'Perth']\n",
    "\n",
    "for i, city in enumerate(cities):\n",
    "    print(f'City {i}: {city}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Functions\n",
    "\n",
    "In programming, a function is a piece of code that (optionally) takes inputs, performs a set of instructions, and (optionally) returns an output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "\n",
    "y = square(4)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's an example of a function that has no input or output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today is 08/08/2019\n"
     ]
    }
   ],
   "source": [
    "import time \n",
    "\n",
    "def today():\n",
    "    date = time.strftime(\"%d/%m/%Y\")\n",
    "    print(f'Today is {date}')\n",
    "    \n",
    "today()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When calling a function, we can use positional and keyword arguments. In this next example, we use positional arguments only, which means that Python will assign 2 and 3 to parameters`x` and `p` respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def power(x, p):\n",
    "    return x**p\n",
    "\n",
    "y = power(2,3)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next example does exactly the same, but based on keyword arguments. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "y = power(x=2,p=3)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using keyword arguments, the inputs do not need to be in any particular order. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "y = power(p=3,x=2)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also mix positional and keyword arguments, but in this case the positional arguments need to come first. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "y = power(2, p=3)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many functions that you will be using have default arguments. It's important for you to pay attention to these default values and ask if they make sense for your current application. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John!\n",
      "Hello user!\n"
     ]
    }
   ],
   "source": [
    "def hello(name='user'):\n",
    "    print(f'Hello {name}!')\n",
    "\n",
    "hello('John')\n",
    "hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. If Statements\n",
    "\n",
    "An if statement evaluates if an expression is `True` or `False`, and executes different code accordingly. For example, suppose that we want to code a function to calculate the absolute value of a number, defined as\n",
    "\n",
    "\\begin{equation}\n",
    "|x|=\\begin{cases}\n",
    "x & \\text{if $x\\geq0$}\\\\\n",
    "-x & \\text{if $x<0$}.\n",
    "\\end{cases}\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def absolute(x):\n",
    "    if x >= 0:\n",
    "        return x\n",
    "    else:\n",
    "        return -x\n",
    "\n",
    "y = absolute(-2)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another example, below we code a function that raises a customised error message if the input is invalid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6931471805599453"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def log(x):\n",
    "    if x <= 0:\n",
    "        raise ValueError('Wake up mate!! The log of zero or a negative number does not exist.')\n",
    "    else:\n",
    "        return math.log(x)\n",
    "\n",
    "log(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, try taking the log of zero and see what happens. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Arrays\n",
    "\n",
    "[NumPy](https://numpy.org/) is the fundamental package for scientific computing in Python. NumPy arrays are data structures that we use to represent and store vectors and matrices. This is very important to us, because all learning algorithms in this course are based on operations on vectors and matrices which typically happen behind the scenes. \n",
    "\n",
    "For example, consider the following vector.\n",
    "\n",
    "\\begin{equation}\n",
    "a = \\begin{pmatrix} 5 \\\\ -2 \\\\ -3\\end{pmatrix}\n",
    "\\end{equation}\n",
    "\n",
    "We represent this vector in Python as follows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -2, -3])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([5, -2, -3])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the same way, we use a two-dimensional NumPy array to represent a matrix. Consider for example the following square matrix.\n",
    "\n",
    "\\begin{equation}\n",
    "B=\\begin{bmatrix} \n",
    "1  & 2 \\\\\n",
    "5  & -4  \\\\\n",
    "\\end{bmatrix}\n",
    "\\end{equation}\n",
    "\n",
    "We create it as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2],\n",
       "       [ 5, -4]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the input is a list, where each item is itself a list representing a row \n",
    "B = np.array([[1,2],[5,-4]])\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `ndim` and `shape` properties allow us to retrieve the number of dimensions and the dimensions themselves of Numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim # a is a one-dimensional array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.ndim # B is a two-dimensional array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape # a has three elements along the first and only dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.shape # B has 2 rows (first dimension) and two columns (second dimension)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Retrieving elements and slices works similarly to what we do for lists, except that we need to keep track of multiple dimensions. Here are some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[1,0] # element in the second row, first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2, -4])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[:,1] # second column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5, -4])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B[-1,:] # last row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. Programming Tips\n",
    "\n",
    "1. Programming is a completely logical process. Your code will only generate the correct result if it is entirely correct, both in terms of the syntax and the logical consistency of what you are trying to do. Otherwise, you get an error message or the wrong result. This will happen all the time, whatever your level of programming ability. Just go back and find out where the problem is. Troubleshooting is a very important skill.\n",
    "\n",
    "2. Read the error messages. Students very often ask why their code is not working when the error message already says what the problem is.\n",
    "\n",
    "3. Not even a full unit on programming would be able to cover all scenarios. You should use the package documentation and internet searches frequently to find out how to do things and fix problems. It's important to conceptualise and articulate clearly what you're trying to do, then you discover how to implement that in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. Exercises\n",
    "\n",
    "Do the exercises below if you're looking for a challenge. Some are hard. Use the Internet to figure out how to do things that you don't know how to implement yet. For example, try searching how to copy a Python list – you'll need it. \n",
    "\n",
    "The solutions are collaborative on Ed. Help your colleagues by posting yours. \n",
    "\n",
    "**Exercise 1**\n",
    "\n",
    "**(a)** Print the third element in the list below.\n",
    "\n",
    "**(b)** Print elements 3 to 6. \n",
    "\n",
    "**(c)** Print the last element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,3,4,5,6,7,8,9,10]\n",
    "print(type(a))\n",
    "print(a)\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 2**\n",
    "\n",
    "Write a function called `middle` that takes a list and returns a new list that contains all but the first and last elements (Think Python 10-3). You can test it on the list below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[1,2,3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 3**\n",
    "\n",
    "Write a function called `chop` that takes a list and modifies it by removing the first and last elements (Think Python 10-4). Think about the difference between this exercise and the previous one. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 4**\n",
    "\n",
    "Write a function called `is_sorted` that takes a list as a parameter and returns `True` if the list is sorted in ascending order and false otherwise (Think Python 10-5)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 5**\n",
    "\n",
    "Write a function called `k_largest` that takes a list of numbers and a parameter `k` and returns the k largest numbers in the list. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 6**\n",
    "\n",
    "Two words are anagrams if you can rearrange the letters from one to spell the other. Write a function called `is_anagram` that takes two strings and returns True if they are anagrams (Think Python 10-6). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 7**\n",
    "\n",
    "Write a function that takes three numbers as separate inputs and returns the largest of the three. Do this by building a list. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 8**\n",
    "\n",
    "Create a function `first_k_digits` that takes a number and returns its first k digits as a list. Test it by obtaining the first 5 digits of $\\pi$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 9**\n",
    "\n",
    "Write a function `median` that takes a list of numbers and returns the median. You can assume that the size of the list is an odd number. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise 10**\n",
    "\n",
    "**(a)** Write a function that gets a text and a word as inputs and returns `True` if the word appears in the text, and false otherwise. The following methods are useful for this task: \n",
    "\n",
    "1. The string [<TT>lower</TT>](http://www.tutorialspoint.com/python/string_replace.htm) method.\n",
    "2. The string [<TT>replace</TT>](http://www.tutorialspoint.com/python/string_replace.htm) method to remove special characters. \n",
    "3. The string [<TT>split</TT>](http://www.tutorialspoint.com/python/string_split.htm) method.\n",
    "\n",
    "You can text your function with Shakespeare:\n",
    "\n",
    "<blockquote>\n",
    "We are such stuff as dreams are made on; and our little life is rounded with a sleep.\n",
    "</blockquote>\n",
    "\n",
    "Beyond the exercise, the Python [Natural Language Toolkit](http://www.nltk.org/) has functions for text processing tasks of this type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatting\n",
    "\n",
    "The two cells below format the notebook for display online. Please omit them from your work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "@import url('https://fonts.googleapis.com/css?family=Source+Sans+Pro|Open+Sans:800&display=swap');\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    "@import url('https://fonts.googleapis.com/css?family=Source+Sans+Pro|Open+Sans:800&display=swap');\n",
    "</style>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.CodeMirror pre {font-family: monospace; font-size: 12pt; line-height: 22.4px;}\n",
       "\n",
       "pre {font-family: monospace; font-size: 12pt; line-height: 22.4px;}\n",
       "\n",
       ".output_area pre {font-family: monospace; font-size: 12pt; line-height: 22.4px;}\n",
       "\n",
       ".rendered_html table {font-size: 10.5pt;}\n",
       "\n",
       "h1 {\n",
       "  font-family: 'Open Sans' !important;\n",
       "  color: #222;\n",
       "  font-size: 2.5em !important;\n",
       "  padding-bottom: 0px;  \n",
       "  margin-top: 14px;\n",
       "  margin-bottom: 6px;\n",
       "  font-weight: 800 !important;\n",
       "}\n",
       "\n",
       "\n",
       "h2 {\n",
       "  font-family: 'Open Sans' !important;\n",
       "  font-size: 1.6em !important;\n",
       "  font-weight: 800 !important;\n",
       "  color: #222;\n",
       "}\n",
       "\n",
       "\n",
       "h3 {\n",
       "  font-family: 'Open Sans' !important;\n",
       "  font-size: 25px !important;\n",
       "  color: #222 !important;\n",
       "  margin-bottom: 30px !important;\n",
       "  margin-top: 25px !important;\n",
       "}\n",
       "\n",
       "\n",
       "p {\n",
       "  font-family: 'Source Sans Pro', sans-serif;\n",
       "  color: #222;\n",
       "  font-size: 19px;\n",
       "  margin-bottom: 10px;\n",
       "  margin-top:0;\n",
       "  line-height: 1.4;\n",
       "}\n",
       "\n",
       "li {\n",
       "  font-family: 'Source Sans Pro', sans-serif;\n",
       "  color: #222;\n",
       "  font-size: 19px;\n",
       "  line-height: 1.4;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/*code {\n",
       "     padding: 2px 4px !important; \n",
       "     font-size: 90% !important;\n",
       "     color: #c7254e !important; \n",
       "     background-color: #f9f2f4 !important; \n",
       "     border-radius: 2px !important;\n",
       "     text-decoration: none !important;\n",
       "      font-size: 90% !important;\n",
       "}\n",
       "*/\n",
       "\n",
       "\n",
       "code {\n",
       "      font-size: 90% !important;\n",
       "/*      border-style: solid !important;\n",
       "      border-width: 1px !important;\n",
       "      border-color :#cccccc !important;*/\n",
       "}\n",
       "\n",
       "TT {\n",
       "      font-family: monospace;\n",
       "      font-size: 95% !important;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "a.neutral {\n",
       "  text-decoration: none !important;\n",
       "  border-style: dotted !important;\n",
       "  border-width: 1px !important;\n",
       "  border-color :#cccccc !important;\n",
       "\n",
       "}\n",
       "\n",
       "</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "style = open('css\\jupyter.css', \"r\").read()\n",
    "HTML('<style>'+ style +'</style>')"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}