Intro_to_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "In this short crash course we will learn to code in Python programming language, specifically we will use Python 3, while searching on the internet you may sometime stumble upon Python 2.7. There are a few syntactic differences you will learn along the way.\n",
    "\n",
    "### Advantages\n",
    "\n",
    "* General-purpose language, used in web developement as well as high performance computing\n",
    "* It is an \"interpreted\" programming language, i.e. there is no need to compile your code\n",
    "* Extensive choice of libraries to deal with most complicated problems, especially for data science and machine learning\n",
    "* Is easy to read and write (closer to english than other programming languages)\n",
    "* Very well documented, and widely used ([docs.python.org](http://docs.python.org) or check Stack Overflow)\n",
    "* Dynamically-typed - it is not necessary to manually define the types of variables (in most cases)\n",
    "\n",
    "### Disadvantages\n",
    "\n",
    "* Dynamically-typed - it is not necessary to manually define the types of variables - this can cause confusion. It is good practice to leave comments with description of the input for every function\n",
    "* Is slower than compiled languages, this can be rectified by using libraries that are pre-combiled in other programming languages (*More in the workshop on scientific computing in python)*\n",
    "\n",
    "\n",
    "### Plan for today\n",
    "1. Basics: variables, conditional statements, for/while loops, functions \n",
    "2. Pythonic basics: list comprehension, lambda functions\n",
    "3. Problem solving\n",
    "\n",
    "### How to learn Python?\n",
    "\n",
    "* It is a language, the only way to learn it is to speak it. *Don't be afraid, make mistakes, and ask questions.*\n",
    "* *Practice makes perfect*. Initially you will be forgetting the commands, the more you practice the sooner you will remember the syntax.\n",
    "* If you don't understand something, first compose the question properly, think about it, and if you can't think of a solution ask someone!\n",
    "* Before you execute any cell, stop and try to predict what it will do! Ideally write your prediction on a piece of paper!\n",
    "* Experiment! Change the code in the cells, try various test cases to understand how the code behaves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are boxes labeled with name used to store values. Each variable is of a specific type, the types define the operations that can be applied to the variables and their response to them. The most common variable types are:\n",
    " - *Strings* - A \"string\" of characters\n",
    " - *Integers* - Whole numbers\n",
    " - *Floating-point values* - Decimal numbers\n",
    " - *Boolean* - Binary logic (True / False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a comment, text following a hashtag is not interpreted as code.\n",
    "\"\"\"This is also a comment, \n",
    "it is a string, \n",
    "and can span multiple lines.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To execute the code in a cell, press ctrl-shift\n",
    "a = 5  # the variable a is assigned the value 5\n",
    "type(a)  # a is variable of type \"int\", short for integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# python automatically guesses the variable type of your input, can you google what this variable type stands for?\n",
    "b = 0.2\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to print out the value of a variable or a calculation, you can use the function print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a) # don't forget the brackets ()!\n",
    "print(a + 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "print(type(a))\n",
    "a = \"hello\"\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Guess the results of the following operations, write them down before running the cell!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "print(a / 2)\n",
    "print(a // 2) # // signifies whole number division\n",
    "print(a % 2)  # % is the remainder after division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Write a code to print the sum of the variable `a` and `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Python can also work as a very powerful calculator, what is 99 to the power of 99? (Hint: powers are denoted by ** in Python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also supports scientific notation (e.g. 4x10^2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "4e2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to add different types in Python, the resulting type is chosen automomatically. (broadcasting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_str = 'str'   # string\n",
    "my_int = 4       # int\n",
    "my_float = 4.5     # float\n",
    "my_bool = True    # bool (logic value True / False)\n",
    "\n",
    "print(my_int + my_float)\n",
    "print(my_float + my_bool)\n",
    "print(my_str + my_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Some types cannot be added together as you can see above! Also notice that when adding a float and an int, the result is chosen to be a float."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String is a data type used to represent text in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = \"abc\"\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is an arithmetic associated to the string data type, see how a string behaves under the following operands:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello = \"Hello\"\n",
    "space = \" \"\n",
    "world = \"World!\"\n",
    "print(hello + space + world)\n",
    "print((hello + space) * 2 + world)\n",
    "print(\"-\" * 50)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the sign \"+\" concatenates strings, but adds numbers when applied to `int`s or `float`s. An operator with different operations for different types is called an \"overloaded operator\". It is possible to manually change the data type of a variable, for example strings to integers or floating-point numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"123\"\n",
    "si = int(s) # string s converted to an integer\n",
    "print(si)\n",
    "sf = float(s) # string s converted to a floating point number\n",
    "print(sf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... or vice-versa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 123\n",
    "ds = str(d)\n",
    "print(ds + \"_\" + \"s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another way of combining other data types (int, float etc...) with strings:\n",
    "print(\"some int: {}, some float: {}\".format(2, 2.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, strings can be split into lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"123\"\n",
    "print(len(s))   # How long is this string?\n",
    "list(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "List is a mutable sequence of elements, i.e. once created, the separate elements can be changed. Lists can be created in the following way `a = [1,2,3]`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "print(a)\n",
    "b = [2, 5] \n",
    "print(a + b)    # Lists can be added together, this appends list b to list a!\n",
    "print(a * 5)    # List can also be repeated as we did with strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try if lists can be subtracted or multiplied!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elements in a list can be accessed separately, each element has an associated index starting from 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "print(a[0])   # first element is numbered by 0, not 1!\n",
    "print(a[-1])  # last element of the list\n",
    "a[0] = 5\n",
    "print(a)      # we have modified the first element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try accessing the 10th element in list 'a' :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE\n",
    "a[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Can you use your python knowledge of lists and strings to find the 10th character in the sentence below?\n",
    "\n",
    "`this is a string with an exciting 10th character!`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below you can see some handy functions that can be perfomed on a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# length of a list\n",
    "a = [1, 2, 3]\n",
    "\n",
    "print(len(a))\n",
    "# sum of all list elements\n",
    "sum(a)\n",
    "print(sum(a))\n",
    "# adding an element to the list\n",
    "a.append(10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Especially useful is the sort() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [5, 3, 8, 1]\n",
    "print(v)\n",
    "v.sort()\n",
    "print(v)\n",
    "print(list(reversed(v)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try to print out the result of the function reverse() without converting to list. What type is it?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements in a list do not need to be all of the same type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "good_list = ['Data Science', 485, True, 0.001]\n",
    "print(good_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can also contain more lists, exciting! Let's append a list at the end of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "good_list = ['Data Science', 485, True, 0.001]\n",
    "good_list.append(['first', 'list'])\n",
    "print(good_list)\n",
    "last_elem = good_list[-1]\n",
    "print(last_elem)\n",
    "print(last_elem[0])\n",
    "print(good_list[-1][0]) # picks the first element of the last element of good_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many elements does the list `[[0,1,2,3,4,5,6]]` have? Use the `len()` function to see if you were right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE\n",
    "a = [[0,1,2,3,4,5,6]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range()` is a particularly useful iterator that can be converted into a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(10)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the future you will see that the result of the `range()` function behaves just like a list would when combined with certain functions or in loops. If you want the result to really be a list, make sure to convert it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(10)\n",
    "r = list(r)\n",
    "print(r)\n",
    "print(\"length: {}, sum: {}\".format(len(r), sum(r)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `range()` function can have a specified start, end and step size. The syntax is: range(first element, last element, step size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(1,10,2)))\n",
    "print(list(range(10,1)))\n",
    "print(list(range(10,1,-1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=range(5)\n",
    "print(a)\n",
    "print(a[2])\n",
    "print(type(a)) # range() does not result in a list, unless explicitly converted!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a list of all the multiples of three between 1000 and 2500:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Accessing elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have already seen how to access a single element in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9]\n",
    "print(a[0])\n",
    "print(a[1])\n",
    "print(a[len(a) - 1])\n",
    "print(a[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python, you can also access \"sublists\" of lists, the syntax is: list[ start : end : step ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a[0:2])   # first two elements\n",
    "print(a[:2])    # from the start to element two\n",
    "print(a[7:])    # from element seven to the end\n",
    "print(a[-2:])   \n",
    "print(a[::2])   # every second element from the start to the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a list containing 11 elements, print out the following sublists:\n",
    "    - All elements between the 2nd and 5th element\n",
    "    - Every second element of the list\n",
    "    - Print out the whole list backwards\n",
    "    - Exchange the order of the 4th and 5th element and the 8th and 9th element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python it is often necessary to write down conditions which result in a boolean value (either `False` or `True`). It is important to learn how to evaluate such conditions using basic logic. Let's look at some logic operations first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(True or False)\n",
    "print(False or False)\n",
    "print(True or True)\n",
    "\n",
    "print(False and False)\n",
    "print(True and True)\n",
    "print(True and False)\n",
    "\n",
    "print(not False)\n",
    "print(not True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These logical operations can be incorporated in terms of mathematical operations, let's define a few variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5 # an integer\n",
    "b = 6 # another integer\n",
    "c = [0,1,2,3,4,5] # a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can test a few logic operations on these variables, look at the cell below and try to guess the output! Write your guesses down before running the cell!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a == b) # a equal to b\n",
    "print(a + a == b) # 2a equal to b\n",
    "print(a != b) # a not equal to b\n",
    "print(a > b) # a greater than b\n",
    "print(a < b) # a lesser than b\n",
    "print(a <= b) # a lesser or equal to b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few more intuitive operations that will come handy later on:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a in c)\n",
    "print(b in c)\n",
    "print(a not in c)\n",
    "print(b not in c)\n",
    "print(a and b in c)\n",
    "print(a or b in c)\n",
    "\n",
    "print(2 is '2')\n",
    "print(\"2\" is '2')\n",
    "print(2 is not '2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure you understand each of the above results, if you don't, ask one of the demonstrators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Conditional statements\n",
    "Conditional statements are useful when we want to run some parts of the code only if some conditions are fulfilled. The syntax is:\n",
    "\n",
    "`if [Condition]:\n",
    "    [Code]`\n",
    "    \n",
    "If the `[Condition]` in the if statement has the value True, the `[Code]` will be executed, otherwise it will not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets start with a few simple conditional statements\n",
    "if True:\n",
    "    print(\"The condition after \\\"if\\\" is true!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "    print(\"The condition after \\\"if\\\" is false :( !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# It is possible to include a number of conditions! If neither is true, then the code in else will run.\n",
    "a = 5\n",
    "if a == 2:\n",
    "    print(\"a is equal to two!\")\n",
    "elif a == 3 or a == 4:\n",
    "    print(\"a is equal to three or four?\")\n",
    "else:\n",
    "    print(\"a is not two, three or four!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a code that takes a list with n elements on its input, and returns the string `\"Too long\"` if the n > 10, `\"Too short\"` if n < 10, and `\"Ideal\"` if n = 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops are one of the most important structures you will learn today, they allow cerain parts of the code to be executed multiple times. In Python the `for` loop is used extensively. The syntax is: `for <variable> in <list of elements>:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# one by one each element of the list is assigned to the variable i, then the code inside the for loop is executed\n",
    "for i in range(10):\n",
    "    print(i, i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The loop iterates over the list, sequentially assigning values to the variable i. The code within the loop prints the value.\n",
    "for i in [4, 1, 5, 22, 5]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in \"abc\":   #it is also possible to iterate over strings\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sometimes it is useful to have two nested for loops, keep in mind the more nested loops the slower the code!\n",
    "for i in [1,2,3]:\n",
    "    for j in range(2,22,5):\n",
    "        print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "If you encounter an expression such as this:\n",
    "\n",
    "`for item in list:\n",
    "    if conditional:\n",
    "        expression`\n",
    "        \n",
    "It can be briefly written in python as:\n",
    "\n",
    "`[ expression for item in list if conditional ]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can either use loops:\n",
    "squares = []\n",
    "\n",
    "for x in range(10):\n",
    "    squares.append(x**2)\n",
    " \n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Or you can use list comprehensions to get the same result:\n",
    "squares = [x**2 for x in range(10)]\n",
    "\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code a comprehension list that iterates over first 100 whole numbers and picks out the even ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While loop is a classic loop with a set condition, while the condition is true, the cycle will repeat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the while condition is always true, the cycle will never stop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0.0000000000000000000000000000000001\n",
    "while i != 10:\n",
    "    i += 1\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions are a basic building block of a programming language. In python, functions can return multiple variables at the output. (unlike C/C++ and Fortran). The syntax is:\n",
    "\n",
    "`def [function name]( [inputs] ):\n",
    "    [code within the function]\n",
    "    return [output]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plus(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(plus(1, 2))\n",
    "print(plus(3.2, -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions can have default input values\n",
    "def plus2(a, b=2):\n",
    "    return a + b\n",
    "\n",
    "print(plus2(7))\n",
    "print(plus2(7,4))\n",
    "print(plus2(7,b=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analyse the following function, what do you think it does? Use the function on a number of testcases to see if your guess is correct."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_sum(a):\n",
    "    summ = 0\n",
    "    \n",
    "    for character in str(a):\n",
    "        summ += int(character)\n",
    "        \n",
    "    return summ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_sum(123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combine your knowledge of comprehension lists and functions to write a code that finds all the even numbers between n and m:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## [Problem]\n",
    "A bank provides ISA with 5% interest per annum. If you deposit 50 pounds a month into the ISA over the period of one year, and the money deposited in the account is compounded at the end of every month, how much money will be in the account at the end of the year?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---\n",
    "## [Problem]\n",
    "Code a function that sums the digits in a number.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## [Problem]\n",
    "Find the sum of all integer multiples of 3 or 5 smaller than 10000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## [Problem] [Adv]\n",
    "Code a function that decides whether the input is a prime number or not.\n",
    "\n",
    "Find the sum of the first 100 prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CODE HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data handling in Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas is a library providing high-performance, easy-to-use data structures and data analysis tools for Python. In this section we will use Pandas only as means of importing and handling external files."
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}