1-Basics_of_Python.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:cd7a899eaebe39dbfa1c2e1d017ceb0c22b83c10329c606f755ce32efb0ec298"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Basics of Python\n",
      "\n",
      "__NOTE:__ Before working on the notebook, please go to the 'file' menu, and __save a copy of the notebook!__ This will prevent your file from being overwritten by someone else.\n",
      "\n",
      "## Variables and Functions"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Comments are written with a # in front\n",
      "\n",
      "# Assign the value 3 to variable x\n",
      "x = 3\n",
      "\n",
      "# Printing in Python 2.x uses the special print keyword\n",
      "print x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Function definitions start with the def keyword, and can return values.\n",
      "# Variables in the function definition can be used only locally\n",
      "def my_func(y):\n",
      "    return 2*y\n",
      "# Note that the above line is indented - that is how\n",
      "# you specify what's 'inside' a function definition in Python.\n",
      "\n",
      "print my_func(4)\n",
      "print my_func(x)\n",
      "print y # Gives an error"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Functions can have multiple arguments, and can have default values\n",
      "# ** indicates exponentiation\n",
      "def my_func2(y, c=2, exponent=1):\n",
      "    return (c*y)**exponent\n",
      "\n",
      "print my_func2(4)\n",
      "# Default values can be omitted...\n",
      "print my_func2(x, 5)\n",
      "# ... And can be assigned using their name\n",
      "print my_func2(1,exponent=2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__Ex 1__: Write a function that takes three arguments, and returns the first argument to the power of the second argument to the power of the third argument. Then make the second argument default to 3. What happens?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def ex1_function():\n",
      "    # \"pass\" is used to indicate that the function\n",
      "    # doesn't return anything.\n",
      "    # It can be used as a placeholder for functions\n",
      "    # that are not yet finished.\n",
      "    pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Lists\n",
      "\n",
      "Lists in python behave in much the same way as arrays in most languages."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Make a list of numbers\n",
      "a = [1, 3, 4, 7, 8]\n",
      "\n",
      "print a\n",
      "# lists have lengths - len is a built-in function\n",
      "print len(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Pick out a particular member of the list\n",
      "# NOTE: Indexing in Python starts at 0!\n",
      "print a[0]\n",
      "print a[3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Use negative numbers to pick out elements from the back of the list\n",
      "print a[-1]\n",
      "print a[-3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Cut out slices of the list\n",
      "print a[2:]\n",
      "print a[:3] # Non-inclusive!\n",
      "print a[1:-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Pick out each element in turn and print it:\n",
      "for v in a:\n",
      "    print v\n",
      "# indentation is also used for 'for'-loops"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__Ex 2__: What do you think happens for each of the statements below? What actually happens? We'll come back to this later."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print a*2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print a**2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__Ex 3__: If you're ever in doubt as to what a function does, use the ? magic keyword"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "len?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Working with lists\n",
      "\n",
      "A typical thing to do with lists is to take each value in the list, do something to it and make a new list with the results.\n",
      "\n",
      "Here are 4 ways to make a new list which contains the values of _a_, all doubled. I've listed them in increasing order of prettiness - if you need to do something with a list, always try to use the bottom one first!\n",
      "\n",
      "__Task__: Make the list _b_ have the elements of _a_, but multiplied by 2"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = [1, 3 ,4, 7, 8, 12, 16]\n",
      "\n",
      "# Method 1: The FORTRAN/C way\n",
      "\n",
      "# Make a list of the same length as a:\n",
      "b = [0]*len(a)\n",
      "# Make an indexing variable\n",
      "i = 0\n",
      "# Run a for-loop over indices into the list\n",
      "while i < len(a):\n",
      "    b[i] = 2*a[i]\n",
      "    i = i + 1\n",
      "print b\n",
      "# This method takes a lot of work to set up!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Method 2: The \"I know about linked lists\"-way\n",
      "\n",
      "# Make an empty list\n",
      "b = []\n",
      "# Loop over each element in a, and add them to b\n",
      "for v in a:\n",
      "    b.append(2*v)\n",
      "    # The append command 'attaches' a value to\n",
      "    # the end of the list\n",
      "print b\n",
      "# Note that we didn't need indices - we can just\n",
      "# pick out the elements directly."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Method 3: The \"I like functional programming and Hadoop\"-way\n",
      "\n",
      "# 'map' is a built-in function that can be used to apply a\n",
      "# function across the members of a list\n",
      "print map(my_func, a) # my_func multiplies a number by 2\n",
      "\n",
      "# Bonus points: Look at the documentation for map"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Method 4: The Python way\n",
      "\n",
      "# Write the for loop inside a list\n",
      "print [v*2 for v in a]\n",
      "# Notice that it's clear directly from the code what the\n",
      "# resulting list will be - and it's all in one line!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This way of writing the lists directly is called a __list comprehension__. It is extremely powerful, as it lets you skip most of the busywork involved in working with lists.\n",
      "\n",
      "As a rule of thumb: If you are using indices in python, you are probably doing it wrong.\n",
      "\n",
      "Let's make the exersize slightly harder: Return a list of the values in a, squared, but only put them in the list if they are even."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Return a list from a with the even values squared\n",
      "# Method 2: \"I still really like linked-lists!\"\n",
      "b = []\n",
      "for v in a:\n",
      "    if v % 2 == 0: # v % 2 == the remainder of v after division by 2\n",
      "        b.append(v**2)\n",
      "# Note the double indentation!\n",
      "print b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Method 4: The \"I'm not getting paid per line of code\"-way.\n",
      "print [v**2 for v in a if v % 2 == 0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Say we want to print the same list, but now for numbers that are not divisible by 3. We could split into multiple cases,\n",
      "but it's easier to just use the 'not' keyword."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print [v**2 for v in a if not v % 3 == 0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# A few examples of combining if-clauses\n",
      "print [v**2 for v in a if not v % 3 == 0 if v % 2 == 0]\n",
      "print [v**2 for v in a if not v % 3 == 0 and v % 2 == 0]\n",
      "print [v**2 for v in a if not v % 3 == 0 or v % 2 == 0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__Ex 4__: For the list _a_ below, make a new list that contains the values in _a_, cubed,\n",
      "    but only if the values of _a_ are even, greater than 11 and not divisible by 7."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = [3, 5, 19, 7, 13, 73, 31, 22, 14, 28]\n",
      "a2 = [] # Your code here\n",
      "print a2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you need to combine elements from two lists, the _zip_ function is really handy:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b1 = [4, 5, 3, 2, 34, 4]\n",
      "b2 = [7, 3, 4, 5, 21] # The lists don't have to be the same size!\n",
      "\n",
      "print zip(b1, b2)\n",
      "\n",
      "# We can assign multiple variables in a single for loop.\n",
      "print [x + y for x, y in zip(b1, b2)] "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "__Ex:__ Make a list with the product of each element in turn from a, a2, b1 and b2. (Hint: _zip_ makes this easy)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[] # !"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}