{ "metadata": { "name": "PythonLab1.ipynb" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "This is a quick review of some basic python features that you will need to do your assignments. \n", "Of course, this is far from being exhaustive. We have put together some code snippets below. \n", "You should be able to run any piece on its own in python version 2.x (not 3.x) - just place the cursor in \n", "the code cell you want to execute, then click on 'Cell/Run' or click on the \"play\" button.\n", "\n", "Python is indentation-sensitive by design \u2013 so, please follow the left-indentation that I have used. Otherwise, \n", "you will receive an 'IndentationError'. It doesn\u2019t have to be the exact same amount of indentation, however. \n", "For example, if you see a tab, it means that there needs to be some left-indentation there; \n", "it could be just a single space (I just prefer tabs only for clarity). But if you don\u2019t see any indentation, \n", "then there shouldn\u2019t be any.\n", "\n", "Any line that starts with a '#' is a comment, that is Python does not execute it.\n", "\n", "Official Python documentation - http://python.org/doc/\n", "\n", "A popular book \u201cA byte of python\" - http://www.swaroopch.com/notes/Python" ] }, { "cell_type": "code", "collapsed": false, "input": [ "#This command opens a python terminal that has gives you access to this notebook's namespace.\n", "#that is, variables you define within this notebook are only accessible through the special console \n", "#invoked by the command below. The default Python kernel or console you see below does not provide \n", "#you that acess. NOTE that this is a special iPython \"magic\" command, not a regular Python command.\n", "\n", "%qtconsole" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 5 }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(1)** At the beginning of a program you might want to specify that you want to use certain \u201cpackages\u201d in order to \n", "use their special features that python doesn\u2019t automatically provide. Some packages like \u2018math\u2019 and \u2018array\u2019 come with python. Others like \u2018pygame\u2019 and \u2018numpy\u2019 need to be installed. To tell the program that you want to use a package, say, for example:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math as m \n", "#'math' is the name of the package, 'm' is its alias that is easier to use\n", "\n", "import random as rnd\n", "#\u2018Random\u2019 package: Use this package to pull random numbers from a given range." ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(2)** Each package has its features implemented in the form of \u201cmodules\u201d or \"functions\" to which \n", "you can pass parameters and get results in return. You can invoke the modules with the \n", "name of the package (or its alias) followed by a \u2018.\u2019 that is then followed by the name of the module (modules don\u2019t have aliases). For example:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print m.sqrt(16) #'sqrt' is the square root module" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print m.cos(m.pi) #besides functions packages also have constants (e.g., 'pi') defined" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print rnd.randint(0,100) #randomly pull a number from the range 0 through 100" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(3) Conditional logic** statements: Note how the else-if is implemented in python \u2013 it is \u2018elif\u2019. \n", "Also, notice the colon at the end of the conditions which is part of the syntax." ] }, { "cell_type": "code", "collapsed": false, "input": [ "x = 0\n", "\n", "if x == 1: print \"x is 1\"\n", "elif x > 1:\n", "\tprint \"x is > 1\"\n", "else:\n", "\tprint \"x is < 1\"" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(4) Loops**: Again note the colon at the end of the loop statements." ] }, { "cell_type": "code", "collapsed": false, "input": [ "x=0\n", "\n", "while x < 10:\n", "\tx += 1 #the '+= ' which is typical in C also works in python\n", "\n", "print x" ], "language": "python", "metadata": { "canopy_exercise": { "cell_type": "" } }, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "for i in range(0,10): #range(0,10) returns a list of values from 0 through 9\n", "\tx -= i\n", "\n", "print x" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "heading", "level": 4, "metadata": {}, "source": [ "NOTE: All datatypes in Python have their indices starting from 0 as opposed to 1." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(5) Lists**: A list is an indexed container where you can store a variety of elements like integers, decimals, and strings in the same list." ] }, { "cell_type": "code", "collapsed": false, "input": [ "L = [10, 'mad',3.2] #list containing 3 different types of elements. Note the square brackets.\n", "\n", "L.append('more') #append a string to the end of the list\n", "\n", "print L" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print L[0] #access an element of the list; indices start with 0, and not 1" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print L.index('mad') #retrieves the 'index' of 'mad' in L" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "del L[1] #delete the element stored at index 1\n", "\n", "print L" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#A standard way of generating a list of numbers (this one generates a list from 0 through 19).\n", "Lst = range(0,20) \n", "\n", "print Lst" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print Lst[3:10], Lst[15:19] #indexing parts of a list" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(5a) List generators**: this is a very useful functionality that you will often need." ] }, { "cell_type": "code", "collapsed": false, "input": [ "L1 = list(n*2 for n in range(10))\n", "\n", "print L1" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#Equivalently,\n", "L1 = [n*2 for n in range(10)]\n", "\n", "print L1" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#Generates a list of indices for items in another list\n", "L2 = [L1.index(item) for item in L1]\n", "\n", "print L2" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#You can also generate a list of tuples in the following way using the function \"enumerate\":\n", "list(enumerate(['a','b','c']))" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#Another way to generate a list of tuples is by making all possible combinations of items from a set of lists:\n", "list((x,y) for x in range(1,4) for y in range(3,6))" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(6) Tuples**: A tuple is very similar to list, in that it is also an indexed container used to store \n", "a variety of elements, but it is treated as an immutable data-type. You can have a list of tuples, \n", "for example, but you can\u2019t append to a tuple after it is defined." ] }, { "cell_type": "code", "collapsed": false, "input": [ "T1 = (2.5, 3.4) #Note the parantheses (square brackets for a list)\n", "\n", "print T1" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "L = [] #To declare an empty list, you can also say: L = list()\n", "\n", "L.append(T1) #appends a tuple to a list; note that there is no \"append\" available for a tuple\n", "\n", "print L" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print L[0]" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "T2 = ((12,14),1.5,(12,13,54)) #tuple within a tuple; 2-D coordinates and velocity, for example\n", "\n", "print T2 #accessing the contents of a tuple is the same as for a list" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(7) Arrays**: A popular package for using arrays is \u201cnumpy\u201d. \n", "A nice tutorial is here - http://www.scipy.org/Tentative_NumPy_Tutorial." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import numpy as np\n", "\n", "x = np.array([30,23,100]) #you don\u2019t have to mention the datatype (e.g., integer)\n", "\n", "print x" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print x[1] #the second element of x: this is how you index an array" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "y = x * 3 #multiplication of the entire array\n", "\n", "print y #all elements" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#retrieve the index of an element in array; notice that the result is a tuple of arrays\n", "print np.where(x == 100) " ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "ind = np.where(x == 100) \n", "\n", "print ind[0][0]" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "z = np.zeros(100) #create an array of length 100 and store 0\u2019s in it\n", "\n", "print z" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ " **(7a)** You can also use numpy to perform numerical calculations like logarithm, exponentiation etc." ] }, { "cell_type": "code", "collapsed": false, "input": [ "print np.log2(2) #base-2 logarithm of a single number" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print np.log2([2,34,456]) #compute the log of an array of numbers" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print np.sum([1,59,98]) #arithmetic sum of an array" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(8) Matrices**: Generally, matrices are two-dimensional arrays. \n", "You can also think of a matrix as an array of arrays. Use numpy to define them:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import numpy as np\n", "\n", "m = np.matrix([[11,32], [3,94]]) #pass a list of equally-sized lists to define a matrix\n", "\n", "print m" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print m[0,1] #retrieves the element in the 0th row and 1st column of the matrix" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(9) Dictionary**: It is defined as a set of \"keys\" and their corresponding \"values\". \n", "Given a key, you can retrieve its value from a dictionary. Dictionaries are convenient in \n", "defining relationships between entities, for example between alphabetic letters and numbers:" ] }, { "cell_type": "code", "collapsed": true, "input": [ "Char_to_Num = { 'A' : 10, 'B' : 36, 'C' : 21} #note the use of curly braces\n", "#the 'key' is defined on the left of the colon, and its 'value' on the right\n", "\n", "print Char_to_Num['A'] #retrieves the value of the key 'A'" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print Char_to_Num.keys() #retrieves keys only, and returns them in a list" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print Char_to_Num.values() #retrieves values only, and returns them in a list" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print Char_to_Num.keys()[Char_to_Num.values().index(21)] #retrieve the key for a value" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(10) Strings**: They can be considered as arrays and indexed as you index an array" ] }, { "cell_type": "code", "collapsed": false, "input": [ "s = \"python is\"\n", "\n", "print s[1] #the second character of the string" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "s = s + \" not a snake\" #the '+' concatenates the two strings\n", "\n", "print s" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print s.index('not') #index strings just as you index lists and tuples" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print s.index('n') #retrieves the index of the first occurrence of 'n'" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#A clever way of generating a string with characters separated by commas (notice that 'join' is not \n", "#a standalone command -- it is a function defined for string objects; in this example):\n", "','.join(['a','b','c'])" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#You can make a list out of the characters of a string\n", "list(\"string\")" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(11) ASCII values**: Every keyboard character has a numerical ASCII value associated with it. \n", "Sometimes it is useful to have access to it, as it may be easier to deal with those numbers, \n", "rather than the original characters, in your program. Aside: 'ord' is short for ordinal." ] }, { "cell_type": "code", "collapsed": false, "input": [ "print ord('F') #the ASCII value of upper case F" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print chr(76) #the character whose ASCII value is 76" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print chr(ord('s')) #returns the lower case 's '" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(12) Files**: Reading and writing." ] }, { "cell_type": "code", "collapsed": true, "input": [ "# First set the working directory, where you want to read and write files\n", "import os\n", "\n", "print os.getcwd() #retrieves current working directory\n", "\n", "# Switch to a different working directory, if you want to access files from there\n", "# os.chdir('/Users/smanicka/Documents/My IU/Spring 2015/Teaching I485/Lab 0')\n", "\n", "# Now move on to file operations\n", "f = open(\"text.txt\",\"r\") #open file for reading; MAKE SURE THAT THIS FILE EXISTS\n", "\n", "lines = f.readlines() #stores each line of the text in 'lines'\n", "\n", "print len(lines) #number of lines in this file" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print lines[3] #retrieves the 4th line, assuming there are that many lines" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "print lines[2][5] #retrieves the 6th character of the 3rd line" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "#If you want to do a fresh read, you should open the file again!\n", "f = open(\"text.txt\",\"r\")\n", "\n", "chars = f.read() #stores all characters of the text, not single lines, in 'chars'\n", "\n", "chars[123] #retrieves the 124th character of the text." ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "f = open(\"text.txt\",\"a\") #open file for writing; append to existing contents\n", "\n", "s = 'a string'\n", "\n", "f.write(s)\n", "\n", "f.close() #this is required after a write, else you won\u2019t see the new contents" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(13) Defining a function**: The following should be self-explanatory. Again, please pay \n", "attention to the indentation for the statement that follow after the first \u2018def\u2019 statement. \n", "To run the following code, make sure that the file \u201ctext.txt\u201d exists in the working directory and has words in it." ] }, { "cell_type": "code", "collapsed": false, "input": [ "def getWords():\n", "\t\n", " f = open(\"text.txt\",\"r\")\n", "\t\n", " words = f.readline().split() \n", "\t#NOTE: readline() returns a string, while readlines() returns a list.\n", "\t#Also, split() works only on a string, NOT on a list, and returns a list.\n", "\t\n", " return words\n", "\n", "# To call a function, you can do the following, for example:\n", "words = getWords()\n", "\n", "print words" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(14) Histograms:** Histograms (frequency plots) are very common plots that you will encounter in any statistics course. You can use numpy.histogram() or Python's inbuilt '.count()' method to generate frequency counts." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import numpy as np\n", "\n", "letters = ['a','a','b','c','b']\n", "\n", "# numpy.histogram() won't run on a list of strings, so we convert them into ASCII numbers\n", "\n", "LettersInASCII = [ord(x) for x in data]\n", "\n", "h = np.histogram(LettersInASCII, bins = range(ord('a'), ord('c') + 2))\n", "\n", "# h[0] = counts for each number in LettersInASCII\n", "# h[1] = \"bins\" into which the numbers of LettersInASCII are put before counting\n", "# For more information on what \"bins\" mean, see \n", "# http://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html\n", "\n", "print h[0], h[1] " ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[2 2 1] [ 97 98 99 100]\n" ] } ], "prompt_number": 23 }, { "cell_type": "markdown", "metadata": {}, "source": [ "A way to count frequencies directly on a list of strings without converting them into numbers:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "letters = ['a','a','b','c','b']\n", "\n", "letters.count('a')" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 24, "text": [ "2" ] } ], "prompt_number": 24 }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can also make a dictionary of all the letters with their frequencies listed against each:" ] }, { "cell_type": "code", "collapsed": false, "input": [ "dict((x, letters.count(x)) for x in letters) #akin to a list \"generator\" in iterm (5a) above" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 25, "text": [ "{'a': 2, 'b': 2, 'c': 1}" ] } ], "prompt_number": 25 }, { "cell_type": "markdown", "metadata": {}, "source": [ "**(15) Plotting methods:** Use the package called 'matplotlib'. Typically, we use the subpackage 'matplotlib.pyplot' to do most of the plotting." ] }, { "cell_type": "code", "collapsed": false, "input": [ "import matplotlib.pyplot as plt\n", "\n", "plt.plot([1,2,4,7],[9,10,13,20]) #by default draws a blue line plot\n", "\n", "plt.xlabel('X axis')\n", "\n", "plt.ylabel('Y axis')\n", "\n", "plt.title('The simplest plot')\n", "\n", "plt.show() #this is essential to display a plot" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEZCAYAAAB7HPUdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niEhFGPpERCry/9zys4xcAZ1fAAAAAElFTkSuQmCC\n", "text": [ "" ] } ], "prompt_number": 1 }, { "cell_type": "markdown", "metadata": {}, "source": [ "To make a bar plot, you can't use the usual 'plot()' method, instead you should call the 'bar()' function." ] }, { "cell_type": "code", "collapsed": false, "input": [ "values = [1,5,9]\n", "barheights = [3,6,7]\n", "\n", "plt.bar(values, barheights)\n", "\n", "plt.xlabel('value')\n", "plt.ylabel('height')\n", "plt.axis([0,10,2,8])\n", "\n", "plt.show()" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEPCAYAAABMTw/iAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\noQcAwxF6ADAcoQcAw/0fASBy1aTfuakAAAAASUVORK5CYII=\n", "text": [ "" ] } ], "prompt_number": 2 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Use 'hist()' to make a histogram by passing to it a list of raw data. Use the 'normed' parameter to specify if you want raw frequency counts or normalized probability values. The example below also shows how to annotate a plot -- use 'annotate(text, x-y tuple of the plot to be annotated, x-y tuple specifying where in the plot area the text is to be placed, **other parameters like arrow properties)." ] }, { "cell_type": "code", "collapsed": false, "input": [ "data = [1,2,3,2,2,1,1,3,4,4,4,4,4,5,5,6,2,3,1,4]\n", "\n", "plt.hist(data, bins=6, facecolor='brown', alpha=0.5) #compute raw frequencies\n", "\n", "plt.axis([0,7,0,7]) #specify the range of values accepted on each axis\n", "\n", "plt.show()" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAEACAYAAACeQuziAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\noAHAUgQaACxFoAHAUgQaACz1H+N551E+wgsTAAAAAElFTkSuQmCC\n", "text": [ "" ] } ], "prompt_number": 4 } ], "metadata": {} } ] }