2 - Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python basics\n",
    "We will focus on a very helpful mathematical library called numpy. To learn more about numpy, or to use as future reference visit [this link](http://cs231n.github.io/python-numpy-tutorial/#numpy-arrays).\n",
    "\n",
    "Lets start by importing numpy. To keep your code clean and easy to read, **you should always import all of your libraries in the first cell**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy contains many useful mathematical functions which we will use throughout this course. We use np to represent numpy. Whenever you want to use a numpy function, after `np` you need to add a `.` and then the name of the function. This tells python that the function you are calling is from the numpy library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.add(4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types\n",
    "\n",
    "Each variable or number that you input will have a type associated to it.\n",
    "\n",
    "**Boolean:** These are limited to `True` or `False`.\n",
    "\n",
    "**String:** We signal to Python to make an element a string by putting it within quote marks. It doesn't matter if you use single quotes `' '` or double quotes  `\" \"`\n",
    "\n",
    "**Int:** Python will automatically assign this type to any whole number.\n",
    "\n",
    "**Float:** Similarly, Python will assign this type to any number that contains a decimal point.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(True))\n",
    "print(type('True')) # Note how this becomes a string not a boolean term because of the quote marks\n",
    "print(type(10))\n",
    "print(type(10.0)) # Note how this becomes a floating point number as we add the decimal place"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String arithmetic in Python is very helpful when we want to load a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "directory = '/Documents/Teaching/KF5012/'\n",
    "filename = 'Example.py'\n",
    "\n",
    "full_filename = directory + filename\n",
    "print('Find the file at', full_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "List are an easy way to store information, including results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [0, 1, 1, 3, 4, 4, 6, 6, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add a new element to the end of the list, use `.append`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.append(10)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops and if statements:\n",
    "These will be extremely helpful in any machine learning model. In the following practicals, we will need to loop through all of our data. Let's learn how to do this. \n",
    "\n",
    "At the end of each `for` or `if` statement, you will need to place a colon. Your indentation is essential here. Your `if` statement or `for`loop ends when you stop indenting.\n",
    "\n",
    "#### If statements\n",
    "If statements are very intuitive and will be similar to what you have seen before. The most important statements to call are `if`, `elif`, and `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = 'hello'\n",
    "\n",
    "if len(my_string)>3: # Here `len` is a function that returns the length of the string.\n",
    "    print('hi')\n",
    "else:\n",
    "    print('hey')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops\n",
    "Loops have a slightly different format than you might have seen elsewhere. Note: in Python, **indexing starts at 0**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    j = i+3\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, you can explicitly loop over a list, as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in my_list:\n",
    "    j = i*i\n",
    "    print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops and if statements together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 4\n",
    "j=0\n",
    "for i in my_list:\n",
    "    if (i == x):\n",
    "        print('Found x at position', j)\n",
    "    j=j+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = [] # Here we initialise the list as empty and we will fill it as we find more\n",
    "\n",
    "x = 4\n",
    "j = 0\n",
    "for i in my_list:\n",
    "    if (i == x):\n",
    "        new_list.append(j)\n",
    "    j = j+1\n",
    "    \n",
    "if new_list == []: # Note here that we are back to 0 indentations. This means that this is not within the previous for-loop\n",
    "    print ('Could not find x')\n",
    "else:\n",
    "    for i in new_list:\n",
    "        print('Found x at position', i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "Functions make everything easier in Python. By calling a function, you won't need to code the same thing over and over again.\n",
    "\n",
    "You can define a function with the `def` key word as follows:\n",
    "> `def function_name(variables):`\n",
    "\n",
    "The function code then needs to be written. Finally, we need to code what variables the function will output when it is called. We do this via\n",
    "\n",
    "> `return`\n",
    "\n",
    "We can return as many variables as we need but for now, we will stick to just returning one\n",
    "\n",
    "Note again that when you use `def`, you need to follow the same indentation rules as you did with `for` and `if`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_positive(x):\n",
    "    if x>0:\n",
    "        return x\n",
    "    elif x<0:\n",
    "        return -x\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "a = [-2, -1, 0 , 1, 2]\n",
    "\n",
    "for i in a:\n",
    "    print(i, 'made positive is', make_positive(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(x,y,z):\n",
    "    if x > y:\n",
    "        x = x * y\n",
    "    if y > z:\n",
    "        for i in range(3):\n",
    "            z = z + (x*i)\n",
    "        y = x - y\n",
    "    return x*y*z\n",
    "\n",
    "print(my_function(1, 2, 3))\n",
    "print(my_function(1, 3, 2))\n",
    "print(my_function(3, 2, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can define some default values in a function. You then won't get an error if you omit them when you call the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def triple(x, y = 3): # Here y = 3 is the default.\n",
    "    return x*y\n",
    "\n",
    "print('Triple 5 is', triple(5)) # With one value, triple(5) will just multiple 5 by the default value, 3\n",
    "print('Now I can use this function to double. Double 5 is', triple(5, 2)) # Now that we use two values when we call triple, the default is overridden"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}