Python_Basics.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:37d5e8c0fcf0a28de4e38e1a6cf645bc3e05285bdf3fd57a23c6c39f5e3f3663"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Assumptions\n",
      "===========\n",
      "\n",
      "You have some experience with programming (preferably scripting like language--e.g., IDL or similar)\n",
      "\n",
      "Forty five minutes coverage can only hit certain points. People will be available to answer specific questions that come up in the activities. Or refer to documentation if the location is obvious (googling is often the fastest way).\n",
      "\n",
      "Using Python 2, but with Python 3 print and division behavior (we will be switching to Python 3 within a year as our main development and operations platform)\n",
      "\n",
      "Using IPython notebook (future name: Jupyter) for nearly all tutorial material. You don't have to use it for general work, but we will require project activities to use it to display their results. Some instruction on using it later will be given.\n",
      "\n",
      "General Comments\n",
      "================\n",
      "\n",
      "Since many of the attendees have significant IDL experience:\n",
      "\n",
      "Python is much more general and powerful than IDL, but IDL does make some things more convenient for numerical analysis since it is specialized for that. One just has to live with that. The plusses far outweigh the minuses.\n",
      "\n",
      "For IDL users are there multiple web pages that map IDL operations into their Python/numpy/matplotlib equivalents:\n",
      "\n",
      "- http://www.astro.umd.edu/~mbk/idl-numpy.html\n",
      "- http://www.johnny-lin.com/cdat_tips/tips_array/idl2num.html\n",
      "\n",
      "More for the library equivalences:\n",
      "- http://www.astrobetter.com/wiki/tiki-index.php?page=Python+Switchers+Guide\n",
      "\n",
      "We will occasionally address differences in the following material\n",
      "\n",
      "Topics covered\n",
      "==============\n",
      "\n",
      "- Simple examples, how assignment works\n",
      "- Fundamental data structures: Strings, Lists, Dictionaries, Tuples\n",
      "- using modules\n",
      "- using objects\n",
      "- defining functions\n",
      "- numpy (array manipulation basics)\n",
      " - creating\n",
      " - indexing/slicing\n",
      " - broadcasting\n",
      "- plotting (matplotlib)\n",
      " - modes of use\n",
      " - gallery\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "to get notebooks, in terminal window type: \n",
      "\n",
      "`git clone https://github.com/spacetelescope/UserTraining2015.git`\n",
      "\n",
      "New directory tree should appear as UserTraining2015 in current directory. Notebooks are in that directory"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Simple examples"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%matplotlib inline\n",
      "# import statements will be talked about later, for now, just do it.\n",
      "from __future__ import print_function, division # Makes both of these Python 3 form.\n",
      "                                                # Good to get used to...\n",
      "\n",
      "x = 1\n",
      "y = 3.14\n",
      "s = \"Hello There\"\n",
      "print(s)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello There\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# string operations\n",
      "print(s + s)\n",
      "print(2*s)\n",
      "print(len(s))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello ThereHello There\n",
        "Hello ThereHello There\n",
        "11\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Fundamental data structures: Lists, Dictionaries, Tuples"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Lists\n",
      "L = [\"red\", \"green\", \"blue\"] # yes, case matters in variable names\n",
      "print(L)\n",
      "# lists can contain objects of any type, even other lists\n",
      "# But usual practice is to limit members to items that share some essential property.\n",
      "L = L + [2]\n",
      "print(L)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['red', 'green', 'blue']\n",
        "['red', 'green', 'blue', 2]\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Indexing, access a list member\n",
      "print(L[1])\n",
      "# Slicing, extract a sublist\n",
      "print(L[1:3]) # second index is non-inclusive!\n",
      "# huh?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "green\n",
        "['green', 'blue']\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Indexing conveniences\n",
      "L[-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 5,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "L[:4:2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "['red', 'blue']"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# indexing works on strings too\n",
      "s[::-2]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 7,
       "text": [
        "'eeTolH'"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Modify a list\n",
      "# Replace an element\n",
      "L[-1] = \"pink\"\n",
      "L.append('purple')\n",
      "print(L)\n",
      "# insertion\n",
      "L[1:2] = ['orange', 'brown']\n",
      "print(L)\n",
      "# deletion\n",
      "del L[4:6]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['red', 'green', 'blue', 'pink', 'purple']\n",
        "['red', 'orange', 'brown', 'blue', 'pink', 'purple']\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Dictionaries: Indexing a collection by arbitrary names or objects\n",
      "D = {'M1':('5:34.5','22:01'), 'M51':('13:29.9','47:12'), 'M27':('19:59.6','22:43')}\n",
      "D['M51']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 9,
       "text": [
        "('13:29.9', '47:12')"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Note about Tuples. Just like lists except use parentheses. \n",
      "# Single element Tuple must have a comma, otherwise it is treated as a math expression:\n",
      "et = (3.14,)\n",
      "# Can be indexed like lists, but cannot be changed once created (immutable)\n",
      "# only immutable objects can be used as keys to dictionaries (e.g., numbers, strings, tuples)\n",
      "# Tuples usually used to contain different kinds of things (unlike lists),\n",
      "# but with a consistent arrangement (e.g., (\"M51\", ra, dec, \"cool interacting galaxy\")\n",
      "D['M51'][0] = 0 # try to set a new RA; note \"traceback\" on an error"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "'tuple' object does not support item assignment",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-10-16a0a2ced564>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# Tuples usually used to contain different kinds of things (unlike lists),\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# but with a consistent arrangement (e.g., (\"M51\", ra, dec, \"cool interacting galaxy\")\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mD\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'M51'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;31m# try to set a new RA; note \"traceback\" on an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Many other useful data structures not covered here:\n",
      "\n",
      "- sets: useful for testing membership, intersections, unions, etc\n",
      "- deques: lists with fast appends/deletes at end or beginning\n",
      "- buffer: Useful with binary data\n",
      "- bytearray: Useful with data in Python 3\n",
      "- namedtuple: Allows items in tuple to have names to select by name instead of number\n",
      "- OrderedDict: Dictionary that remembers order of key creation\n",
      "- defaultdict: Dictionary that calls a special function when values are not provided"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Note about how variables and values work\n",
      "L2 = L # L2 is not a copy of L, it refers to the same list as L\n",
      "L3 = L[:] # this is a copy\n",
      "L[0] = 'lime green'\n",
      "print(L2)\n",
      "print(L3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['lime green', 'orange', 'brown', 'blue']\n",
        "['red', 'orange', 'brown', 'blue']\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Using modules"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Libraries store code in modules and packages (think of packages as groups of modules).\n",
      "# Module is a python file in the search path of Python (it can be compiled C code as well...)\n",
      "# Multiple ways of importing the code into Python\n",
      "import math # contents in the \"math\" namespace\n",
      "print(math.sqrt(2.)) \n",
      "print(sqrt(2.)) # doesn't work"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1.41421356237\n"
       ]
      },
      {
       "ename": "NameError",
       "evalue": "name 'sqrt' is not defined",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-12-8320e6c86738>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmath\u001b[0m \u001b[0;31m# contents in the \"math\" namespace\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# doesn't work\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math as m # give an alias to the original name\n",
      "print(m.sqrt(2))\n",
      "from math import sqrt # move sqrt into the current namespace\n",
      "print(sqrt(2)) # works now!\n",
      "from math import * # dump all things from math into current namespace\n",
      "print(floor(2.5)) # very convenient, but usually a very, very bad idea,\n",
      "                  # particularly in scripts and libraries\n",
      "                  # Name collisions possible (one function hides another),\n",
      "                  # Or hard to determine where a function comes from if many modules imported"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1.41421356237\n",
        "1.41421356237\n",
        "2.0\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**important note**\n",
      "If developing a module of your own, and you need to reload it after changes made to file.\n",
      "\n",
      "`import mymodule` will **not** reload your module\n",
      "\n",
      "Python see this and thinks that it is already loaded and nothing must be done\n",
      "\n",
      "Must use the following form:\n",
      "\n",
      "`reload(mymodule)`"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Using Objects"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(s.upper()) # change to upper case\n",
      "print(s.find('llo')) # is the supplied string inside s?\n",
      "print(s.split()) # split string into multiple strings as a list; defaults to splitting on whitespace\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "HELLO THERE\n",
        "2\n",
        "['Hello', 'There']\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Formatted printing\n",
      "pi = 3.1415926\n",
      "print(\"{}\".format(pi))\n",
      "print(\"{1} {0}\".format(\"hello\",pi))\n",
      "print(\"{:.2f}\".format(pi))\n",
      "# See https://docs.python.org/2/library/string.html#format-specification-mini-language\n",
      "# for all formatting options and many examples"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3.1415926\n",
        "3.1415926 hello\n",
        "3.14\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Defining functions, control loops"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A word about indentation in Python\n",
      "\n",
      "**Indentation Matters!** No use of delimiters to define blocks. What you see is what you get. *Unless you use tabs!*\n",
      "\n",
      "**Never ever use real tabs for indentation** Most editors can be set to turn tabs into spaces."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# define a simple function\n",
      "def square(x):\n",
      "    '''square supplied number''' # this is a docstring; many tools can use this automatically\n",
      "    newvalue = x**2\n",
      "    return newvalue\n",
      "\n",
      "print(square(4))\n",
      "print(square.__doc__)\n",
      "square?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "16\n",
        "square supplied number\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# handling looping\n",
      "def first_n_squares(n):\n",
      "    '''return the first n squares as a list'''\n",
      "    squares = []\n",
      "    for x in range(n):\n",
      "        squares.append(square(x))\n",
      "    return squares\n",
      "\n",
      "first_n_squares(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 17,
       "text": [
        "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# typical loop constructs\n",
      "for color in L:\n",
      "    print(color)\n",
      "# if a count is needed while looping  \n",
      "print('------')\n",
      "for i, color in enumerate(L):\n",
      "    print(i, color)\n",
      "# if you have two matching sequences you want to iterate through\n",
      "# in parallel\n",
      "print('------')\n",
      "for color, n in zip(L, range(5,5+len(L))):\n",
      "    print(color, n)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "lime green\n",
        "orange\n",
        "brown\n",
        "blue\n",
        "------\n",
        "0 lime green\n",
        "1 orange\n",
        "2 brown\n",
        "3 blue\n",
        "------\n",
        "lime green 5\n",
        "orange 6\n",
        "brown 7\n",
        "blue 8\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Truth and conditionals"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# 0, 0., empty strings, lists, tuples, dictionaries, \n",
      "# and a special value \"None\" all are treated as false.\n",
      "# The official true and false values are \"True\" and \"False\" (not strings)\n",
      "if 0:\n",
      "    print('Hi')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if True:\n",
      "    print('True!')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "True!\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if None:\n",
      "    print('None case')\n",
      "elif []:\n",
      "    print('empty list case')\n",
      "elif [0]:\n",
      "    print('nonempty list case')\n",
      "else:\n",
      "    print('nothing was true')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "nonempty list case\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "numpy"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np\n",
      "x = np.arange(20)\n",
      "print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# changing dimensionality\n",
      "x.shape = (4, 5) # must have same number of elements\n",
      "print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[ 0  1  2  3  4]\n",
        " [ 5  6  7  8  9]\n",
        " [10 11 12 13 14]\n",
        " [15 16 17 18 19]]\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f = x.astype(np.float32) # how to convert to a new type\n",
      "f"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 24,
       "text": [
        "array([[  0.,   1.,   2.,   3.,   4.],\n",
        "       [  5.,   6.,   7.,   8.,   9.],\n",
        "       [ 10.,  11.,  12.,  13.,  14.],\n",
        "       [ 15.,  16.,  17.,  18.,  19.]], dtype=float32)"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f**2 + np.sin(f) # arrays work in mathematical expressions"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 25,
       "text": [
        "array([[   0.        ,    1.84147096,    4.90929747,    9.14111996,\n",
        "          15.24319744],\n",
        "       [  24.04107666,   35.72058487,   49.65698624,   64.98935699,\n",
        "          81.412117  ],\n",
        "       [  99.45597839,  120.00000763,  143.46342468,  169.42016602,\n",
        "         196.99060059],\n",
        "       [ 225.65028381,  255.71209717,  288.03860474,  323.24902344,\n",
        "         361.14987183]], dtype=float32)"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fs = np.sin(f)\n",
      "fs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 26,
       "text": [
        "array([[ 0.        ,  0.84147096,  0.90929741,  0.14112   , -0.7568025 ],\n",
        "       [-0.95892429, -0.27941549,  0.65698659,  0.98935825,  0.41211849],\n",
        "       [-0.54402113, -0.99999022, -0.53657293,  0.42016703,  0.99060738],\n",
        "       [ 0.65028787, -0.28790331, -0.96139747, -0.75098723,  0.14987721]], dtype=float32)"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Indexing issues: 1-d works like lists\n",
      "# Numpy supports multiple dimension indexing\n",
      "# Order of indices is OPPOSITE of what IDL and Fortran users expect\n",
      "# Most rapidly varying index in memory is the last one, not first!\n",
      "print(fs[0,1]) # First row, second column"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0.841471\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# slices are views, not copies!\n",
      "fsview = fs[1:3,0:3]\n",
      "print(fsview)\n",
      "fsview[0,0] = 100\n",
      "print(fs)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[[-0.95892429 -0.27941549  0.65698659]\n",
        " [-0.54402113 -0.99999022 -0.53657293]]\n",
        "[[   0.            0.84147096    0.90929741    0.14112      -0.7568025 ]\n",
        " [ 100.           -0.27941549    0.65698659    0.98935825    0.41211849]\n",
        " [  -0.54402113   -0.99999022   -0.53657293    0.42016703    0.99060738]\n",
        " [   0.65028787   -0.28790331   -0.96139747   -0.75098723    0.14987721]]\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# using mask arrays to index\n",
      "fs[fs>0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "array([   0.84147096,    0.90929741,    0.14112   ,  100.        ,\n",
        "          0.65698659,    0.98935825,    0.41211849,    0.42016703,\n",
        "          0.99060738,    0.65028787,    0.14987721], dtype=float32)"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# using index arrays\n",
      "nz = np.where(fs > 0)\n",
      "print(nz)\n",
      "fs[nz]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(array([0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3]), array([1, 2, 3, 0, 2, 3, 4, 3, 4, 0, 4]))\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "array([   0.84147096,    0.90929741,    0.14112   ,  100.        ,\n",
        "          0.65698659,    0.98935825,    0.41211849,    0.42016703,\n",
        "          0.99060738,    0.65028787,    0.14987721], dtype=float32)"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Plotting"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from matplotlib import pyplot as plt # yet another import variant...\n",
      "plt.ion()\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plt.plot(np.sin(np.arange(100)/5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 32,
       "text": [
        "[<matplotlib.lines.Line2D at 0x107ccd490>]"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEACAYAAAC6d6FnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n",
       "text": [
        "<matplotlib.figure.Figure at 0x1052a9890>"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Notes about things that confuse\n",
      "\n",
      "What mode are you using matplotlib?\n",
      "- from a script:\n",
      "  - typically build plot then render with `plt.show()` when all done\n",
      "- interactively:\n",
      "  - Often want to make sure in interactive mode by using `plt.ion()` so all matplotlib commands render immediately\n",
      "\n",
      "What backend are you using?\n",
      "- various ones to choose from (different GUI frameworks)\n",
      "  - default usually works\n",
      "- It is possible to run completely in memory (i.e., no display available)\n",
      "\n",
      "Image orientation convention\n",
      "- by default 0,0 is upper left. \n",
      "- must specify image.orgin = 'lower' option\n",
      "\n",
      "Two kinds of image display:\n",
      "- plt.imshow() resamples to fit display area (different interpolation options available)\n",
      "- plt.figimage() one pixel per pixel on display\n",
      "  \n",
      "Three very important links:\n",
      "- [command list](http://matplotlib.org/api/pyplot_summary.html)\n",
      "- [detailed command summary](http://matplotlib.org/api/pyplot_api.html)\n",
      "- [Gallery of examples](http://matplotlib.org/gallery.html)\n",
      "\n",
      "The latter is very useful for finding something visually that matches what you want to do. Click on the gallery example to see the source code that generated it."
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "IPython Notebook Usage"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The IPython notebook provides a number of advantages:\n",
      "\n",
      "- Good tutorial medium; annotations and images can be inserted\n",
      "- Avoids editor for smaller projects\n",
      "- Can embed plots from matplotlib\n",
      "- Enhanced formatting\n",
      "\n",
      "There are some drawbacks\n",
      "\n",
      "- Can't use debugger (yet)\n",
      "- Executing cells out of order can confuse\n",
      "- Must remember to use <Shift-Return> to execute cell\n",
      "\n",
      "How to start:\n",
      "\n",
      "- Go to directory containing notebooks (the lowest level directory possible is most convenient)\n",
      "- type at the shell level in a terminal window either:\n",
      "  - `ipython notebook` : starts basic notebook in browser\n",
      "\n",
      "To enable inline plots, as first command type: `%matplotlib inline`\n",
      "\n",
      "  \n",
      "Markdown cheatsheet:\n",
      "https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code\n",
      "\n",
      "###Editing Code Cells\n",
      "\n",
      "Code cells are editable. If you make a mistake, just put the cursor in the cell and edit it. When you are done making changes, just re-execute. Rather than a long history of failed attempts as you would get in traditional logging of an interactive session, you just keep changing one thing until you get it right\n",
      "\n",
      "###Menu/Toolbar\n",
      "\n",
      "Note the menus and toolbar at the top of the browser page. These allow quite a few actions to be performed. This tutorial won't go in to exhaustive detail on each choice, but will highlight some key features. You can always explore the choices on your own, and there is a help menu item for the ipython notebook and other Python tools. If you hover on toolbar widgets, a tooltip will appear. Finally, many of these have keyboard shortcuts; you can see these under the help menu (most of the keyboard shortcuts are two character combinations starting with to avoid conflicts with other programs).\n",
      "\n",
      "###Renaming Your Notebook\n",
      "\n",
      "Click on the text to the right of \"Notebook\" at the top of the screen to rename your Notebook to something more informative.\n",
      "\n",
      "###Saving Your Notebook\n",
      "\n",
      "An IPython Notebook is a document much like any other. If you don't save your changes can be lost. To save your notebook just select \"save\" from the \"File\" dropdown at the top of the browser window or click the disk icon. The file will appear in the directory where you ran ipython notebook with the title as the name of the file and .ipynb as its extension.\n",
      "\n",
      "###Editing Options\n",
      "\n",
      "In the \"Edit\" menu and in the toolbar are options for editing actions like delete, copy, cut, paste, merge, split, etc.\n",
      "\n",
      "###New Cells\n",
      "\n",
      "IPython will automatically insert new cells at the end of the Notebook. In the menus and toolbars are buttons for inserting cells above and below the cursor.\n",
      "\n",
      "###Kinds of Cells\n",
      "\n",
      "Notebook cells can be switched between different input types, including cells expecting Markdown (like this cell), cells expecting Python code, and cells that take raw text and do nothing to it. Cells can be converted between these types using the \"Cell\" menu or the toolbar dropdown.\n",
      "\n",
      "###Keyboard Shortcuts\n",
      "\n",
      "There are keyboard shortcuts for most of the actions described above. To see all of the available shortcuts click the \"Keyboard Shortcuts\" item in the \"Help\" menu (or type <ctrl>-m-h). A number of these are intended to be typed sequentially, i.e., escape, then <ctrl> then 'b'.\n",
      "\n",
      "###Executing a Whole Notebook\n",
      "\n",
      "A Notebook can be executed linearly from top to bottom by selecting \"Run All\" from the \"Cell\" menu. This can be useful when resuming work in an existing Notebook.\n",
      "\n",
      "###Latex Math\n",
      "\n",
      "You can put nicely rendered equations into Markdown cells. Use $...$ for inline equations and \\$\\$...\\$\\$ for block equations. For example, `$E = mc^2$` is rendered as $E = mc^2$. `$$f(x) = \\int_0^x sin(\\theta) d{\\theta}$$` is rendered as:\n",
      "\n",
      " $$f(x) = \\int_0^x sin(\\theta) d{\\theta}$$"
     ]
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Resources"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Some of these taken from fperez/org/py4science/starter_kit.html (which is dated and has broken links)\n",
      "\n",
      "##Books\n",
      "\n",
      "###Python basics:\n",
      "\n",
      "####free:\n",
      "\n",
      "- http://diveintopython.org (paper version also available): Probably the best starter book\n",
      "- Official Python Tutorial: https://docs.python.org/2/tutorial/index.html\n",
      "- Python Quick Reference by Richard Gruet (python 2.x only: http://rgruet.free.fr/)\n",
      "- Code like Pythonista by David Goodger (http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html)\n",
      "\n",
      "####non-free:\n",
      "\n",
      "- Essential Python Reference 4th .ed by David Beazley: excellent concise summary of language and standard libraries (non-scientific); useful for those with some Python experience or other programming languages.\n",
      "- Python Cookbook, 3rd Ed. by David Beazley and Brian Jones\n",
      "\n",
      "##Scientific/Astronomy books/tutorials\n",
      "\n",
      "####free:\n",
      "\n",
      "- Astropy:\n",
      "  - main web site http://astropy.org\n",
      "  - documentation: http://docs.astropy.org/en/stable/ (documentation for older versions linked to on main astropy page)\n",
      "  - tutorials: http://www.astropy.org/astropy-tutorials/ (relatively new, still growing)\n",
      "\n",
      "- Book on learning how to do Interactive Data Analysis in Python by Greenfield and Jedrzejewski. A bit dated, but mostly still valid. Assumes no Python knowledge and introduces Python as more and more data analysis is introduced. IMHO, the chapter on Object-Oriented programming is more relevant for astronomers than almost anything else out there, but I'm biased.\n",
      " - Book (pdf): http://stsdas.stsci.edu/perry/pydatatut.pdf\n",
      " - Full set of data (114 MB): http://stsdas.stsci.edu/perry/full.tar.gz\n",
      " - Partial set of data (3.2 MB, missing large ACS file only) http://stsdas.stsci.edu/perry/partial.tar.gz\n",
      "\n",
      "- Lectures (video available) and Course with exercises at STScI early 2015: https://github.com/spacetelescope/scientific-python-training-2015 Follow link to videos under Course Material heading. More astronomy task-oriented than above book. Approach for some issue dated; in some cases Astropy has better solutions now.\n",
      "\n",
      "- Astrobetter/Python: http://www.astrobetter.com/wiki/python (some other links...)\n",
      "\n",
      "- Practical Python for Astronomers: https://python4astronomers.github.io/\n",
      "\n",
      "- numpy: \n",
      "  - User Guide (http://docs.scipy.org/doc/numpy/user/)\n",
      "    - pdf version: https://docs.scipy.org/doc/numpy-dev/numpy-user.pdf\n",
      "  - Reference Guide (http://docs.scipy.org/doc/numpy/reference/)\n",
      "- scipy\n",
      "  - tutorial (http://docs.scipy.org/doc/scipy/reference/tutorial/index.html)\n",
      "  - links to many othermat tutorials: http://wiki.scipy.org/Additional_Documentation\n",
      "- matplotlib\n",
      "  - command summary: http://matplotlib.org/api/pyplot_summary.html\n",
      "  - list of commands with details: http://matplotlib.org/api/pyplot_api.html\n",
      "  - gallery: http://matplotlib.org/gallery.html\n",
      "  \n",
      "####non-free:\n",
      "\n",
      "- Beginning Python Visualization by Shai Vaingast\n",
      "- Python Scripting for Computational Science by Hans Petter Langtangen\n",
      "- Matplotlib for Python Developers by Sandro Tosi\n",
      "\n",
      "##Related tools:\n",
      "\n",
      "- using the Python debugger: \n",
      "https://pythonconquerstheuniverse.wordpress.com/2009/09/10/debugging-in-python/\n",
      "\n",
      "- ipython/Jupyter (http://ipython.org)\n",
      "- Software Carpentry (https://software-carpentry.org): This is a very useful course! It introduces a lot of tools useful for scientists if only they knew about them and why they help productivity and reduce errors. Has online material but also offers multi-day in-person courses around the country.\n",
      "\n",
      "Most popular IDEs (not free, but not that expensive)\n",
      "\n",
      "- PyCharm: https://www.jetbrains.com/pycharm/\n",
      "- WingIDE: https://wingware.com/\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}