PNC_01Basics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from notebook.services.config import ConfigManager\n",
    "cfm = ConfigManager()\n",
    "cfm.update('livereveal', {'theme': 'simple',\n",
    " 'transition': 'convex',\n",
    " 'start_slideshow_at': 'selected'});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       ".answers { \n",
       "    visibility: hidden;\n",
       "}\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "HTML(\"\"\"\n",
    "<style>\n",
    ".answers { \n",
    "    visibility: hidden;\n",
    "}\n",
    "</style>\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n",
      "/Users/barronh/Development/RAQMSandPython/working\n"
     ]
    }
   ],
   "source": [
    "# Prepare my slides\n",
    "%pylab inline\n",
    "%cd working"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python for Air Research and Application\n",
    "\n",
    "## CMAQ\n",
    "\n",
    "Presented by: Barron H. Henderson, Byeong-Uk Kim\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Objectives\n",
    "\n",
    "Hands-on exercises introduce participants to a range of CMAQ analysis techniques and tools, including plotting maps with overlays, converting bpch to netcdf, editing bpch/netcdf files, and evaluating CMAQ against AQSD or ICARTT campaign files.\n",
    "\n",
    "1. Produce publication quality graphics\n",
    "2. Perform standard model performance evaluations\n",
    "3. Create emission perturbations\n",
    "4. Add custom modifications to each exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Abstract\n",
    "\n",
    "Attendees will learn how to leverage Python to interact with air pollution-related model and observational data. Air research and application relies on big data. In addition to the challenge presented by data size, researchers must understand a multitude of formats and meta-data standards. For example, CMAQ, CAMx, and GEOS-Chem all use different formats and different meta-data conventions. This tutorial provides format-independent and convention-independent tools."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Requirements\n",
    "\n",
    "* Some scripting experience (R, Python, Perl, bash, or csh). Attendees who do not have experience can follow my on-line Python-primer (http://www.barronh.com/software/tutorials/python-tutorial) to satisfy the requiremnt.\n",
    "* A computer with either\n",
    "  * Windows, Linux, or Mac; a text editor; and Anaconda 3.5 installed.\n",
    "  * or a computer and an account on wakari.io\n",
    "* See http://github.com/barronh/RAQMSandPython/blob/master/PythonInstallation.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Download Workshop Materials\n",
    "\n",
    "1. https://github.com/barronh/RAQMSandPython\n",
    "2. \"Clone or Download\"\n",
    "3. \"Download Zip\"\n",
    "4. Move it somewhere good\n",
    "5. Unzip it\n",
    "\n",
    "\n",
    "\n",
    "* Fork it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# With Anaconda\n",
    "\n",
    "1. Open Anaconda Navigator\n",
    "2. Open ipython\n",
    "3. Run the code below\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import zipfile\n",
    "from urllib.request import urlretrieve\n",
    "import os\n",
    "url='http://github.com/barronh/RAQMSandPython/archive/master.zip'\n",
    "if not os.path.exists('RAQMSandPython'):\n",
    "    urlretrieve(url, filename = 'master.zip');\n",
    "    zf = zipfile.ZipFile('master.zip')\n",
    "    zf.extractall()\n",
    "    os.rename('RAQMSandPython-master', 'RAQMSandPython')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# 30 minutes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Intro to python/ipython/jupyter\n",
    "\n",
    "1. Options: python, ipython, jupyter\n",
    "    - python - least burden on system\n",
    "    - ipython - least burden on user\n",
    "    - jupyter - least burden on next user\n",
    "2. Running interactively python/ipython\n",
    "3. Running saved scripts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Intro to python/ipython/jupyter\n",
    "\n",
    "1. Options: python, ipython, jupyter\n",
    "2. Running interactively python/ipython\n",
    "    1. Terminal\n",
    "    2. Integrated Development Environments\n",
    "    3. Notebook\n",
    "3. Running saved scripts\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Intro to python/ipython/jupyter\n",
    "\n",
    "1. Options: python, ipython, jupyter\n",
    "2. Running interactively python/ipython\n",
    "3. Running saved scripts\n",
    "    - from terminal `$ python /path/to/file.py`\n",
    "    - from python `>>> execfile('/path/to/file.py')\n",
    "    - from ipython `In[1] %run /path/to/file.py`\n",
    "    - from spyder open in editor\n",
    "    \n",
    "*Windows replace `$` with `C:\\>` and add .exe if necessary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Basic Functions\n",
    "\n",
    "```\n",
    "def foo(bar):\n",
    "    \"\"\"\n",
    "    foo takes bar and returns the sum of foo and bar\n",
    "    Arguments:\n",
    "        bar - a string to add to the string 'foo'\n",
    "    Returns:\n",
    "        foo + bar\n",
    "    \"\"\"\n",
    "    return 'foo' + bar\n",
    "```\n",
    "\n",
    "- created with def name and call signature followed by colon\n",
    "- defined by commands following signature until the first unindented command"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Most Useful Function... ever.\n",
    "\n",
    "`help`:\n",
    "- `?` in ipython or jupyter\n",
    "- it will return a docstring for that element or type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Really Useful Functions\n",
    "\n",
    "`type`: `type(foo)`\n",
    "- All things in python are objects (even classes).\n",
    "- type is a function object that returns the type of another object.\n",
    "\n",
    "`dir`: `dir(foo)`\n",
    "- List of methods and properties\n",
    "\n",
    "`print`:print(a, end ='')\n",
    "- display representation of object\n",
    "\n",
    "print(*foo('bar'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def foo(bar):\n",
    "    return 'foo.' + bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo.bar\n"
     ]
    }
   ],
   "source": [
    "print(foo('bar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can't convert 'int' object to str implicitly\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(foo(1))\n",
    "except Exception as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Basic Types\n",
    "\n",
    "`int`, `float`:\n",
    "\n",
    "- Literals 1 is int, 1. is float\n",
    "- 64-bit precision values (i.e., float is real*8)\n",
    "\n",
    "`str`:\n",
    "\n",
    "- literal '...' or \"...\"\n",
    "- multi-line uses triple quotes\n",
    "- indexed (aka subset) with square braces and \"slices\"\n",
    "- version 3 uses system dependent string types (use encode or decode methods*)\n",
    "\n",
    "*A method is a bound function..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Integers and Floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "1 // 2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      S.__format__(format_spec) -> str\n",
      " |      \n",
      " |      Return a formatted version of S as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.n\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      S.__sizeof__() -> size of S in memory, in bytes\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(...)\n",
      " |      S.capitalize() -> str\n",
      " |      \n",
      " |      Return a capitalized version of S, i.e. make the first character\n",
      " |      have upper case and the rest lower case.\n",
      " |  \n",
      " |  casefold(...)\n",
      " |      S.casefold() -> str\n",
      " |      \n",
      " |      Return a version of S suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(...)\n",
      " |      S.center(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S centered in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space)\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(...)\n",
      " |      S.encode(encoding='utf-8', errors='strict') -> bytes\n",
      " |      \n",
      " |      Encode S using the codec registered for encoding. Default encoding\n",
      " |      is 'utf-8'. errors may be given to set a different error\n",
      " |      handling scheme. Default is 'strict' meaning that encoding errors raise\n",
      " |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n",
      " |      'xmlcharrefreplace' as well as any other name registered with\n",
      " |      codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(...)\n",
      " |      S.expandtabs(tabsize=8) -> str\n",
      " |      \n",
      " |      Return a copy of S where all tab characters are expanded using spaces.\n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Like S.find() but raise ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(...)\n",
      " |      S.isalnum() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphanumeric\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isalpha(...)\n",
      " |      S.isalpha() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphabetic\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isdecimal(...)\n",
      " |      S.isdecimal() -> bool\n",
      " |      \n",
      " |      Return True if there are only decimal characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isdigit(...)\n",
      " |      S.isdigit() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are digits\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isidentifier(...)\n",
      " |      S.isidentifier() -> bool\n",
      " |      \n",
      " |      Return True if S is a valid identifier according\n",
      " |      to the language definition.\n",
      " |      \n",
      " |      Use keyword.iskeyword() to test for reserved identifiers\n",
      " |      such as \"def\" and \"class\".\n",
      " |  \n",
      " |  islower(...)\n",
      " |      S.islower() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are lowercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  isnumeric(...)\n",
      " |      S.isnumeric() -> bool\n",
      " |      \n",
      " |      Return True if there are only numeric characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isprintable(...)\n",
      " |      S.isprintable() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are considered\n",
      " |      printable in repr() or S is empty, False otherwise.\n",
      " |  \n",
      " |  isspace(...)\n",
      " |      S.isspace() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are whitespace\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  istitle(...)\n",
      " |      S.istitle() -> bool\n",
      " |      \n",
      " |      Return True if S is a titlecased string and there is at least one\n",
      " |      character in S, i.e. upper- and titlecase characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |      Return False otherwise.\n",
      " |  \n",
      " |  isupper(...)\n",
      " |      S.isupper() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are uppercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  join(...)\n",
      " |      S.join(iterable) -> str\n",
      " |      \n",
      " |      Return a string which is the concatenation of the strings in the\n",
      " |      iterable.  The separator between elements is S.\n",
      " |  \n",
      " |  ljust(...)\n",
      " |      S.ljust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S left-justified in a Unicode string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(...)\n",
      " |      S.lower() -> str\n",
      " |      \n",
      " |      Return a copy of the string S converted to lowercase.\n",
      " |  \n",
      " |  lstrip(...)\n",
      " |      S.lstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(...)\n",
      " |      S.partition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, and return the part before it,\n",
      " |      the separator itself, and the part after it.  If the separator is not\n",
      " |      found, return S and two empty strings.\n",
      " |  \n",
      " |  replace(...)\n",
      " |      S.replace(old, new[, count]) -> str\n",
      " |      \n",
      " |      Return a copy of S with all occurrences of substring\n",
      " |      old replaced by new.  If the optional argument count is\n",
      " |      given, only the first count occurrences are replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Like S.rfind() but raise ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(...)\n",
      " |      S.rjust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S right-justified in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(...)\n",
      " |      S.rpartition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, starting at the end of S, and return\n",
      " |      the part before it, the separator itself, and the part after it.  If the\n",
      " |      separator is not found, return two empty strings and S.\n",
      " |  \n",
      " |  rsplit(...)\n",
      " |      S.rsplit(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string, starting at the end of the string and\n",
      " |      working to the front.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified, any whitespace string\n",
      " |      is a separator.\n",
      " |  \n",
      " |  rstrip(...)\n",
      " |      S.rstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with trailing whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(...)\n",
      " |      S.split(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified or is None, any\n",
      " |      whitespace string is a separator and empty strings are\n",
      " |      removed from the result.\n",
      " |  \n",
      " |  splitlines(...)\n",
      " |      S.splitlines([keepends]) -> list of strings\n",
      " |      \n",
      " |      Return a list of the lines in S, breaking at line boundaries.\n",
      " |      Line breaks are not included in the resulting list unless keepends\n",
      " |      is given and true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(...)\n",
      " |      S.strip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading and trailing\n",
      " |      whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(...)\n",
      " |      S.swapcase() -> str\n",
      " |      \n",
      " |      Return a copy of S with uppercase characters converted to lowercase\n",
      " |      and vice versa.\n",
      " |  \n",
      " |  title(...)\n",
      " |      S.title() -> str\n",
      " |      \n",
      " |      Return a titlecased version of S, i.e. words start with title case\n",
      " |      characters, all remaining cased characters have lower case.\n",
      " |  \n",
      " |  translate(...)\n",
      " |      S.translate(table) -> str\n",
      " |      \n",
      " |      Return a copy of the string S in which each character has been mapped\n",
      " |      through the given translation table. The table must implement\n",
      " |      lookup/indexing via __getitem__, for instance a dictionary or list,\n",
      " |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If\n",
      " |      this operation raises LookupError, the character is left untouched.\n",
      " |      Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(...)\n",
      " |      S.upper() -> str\n",
      " |      \n",
      " |      Return a copy of S converted to uppercase.\n",
      " |  \n",
      " |  zfill(...)\n",
      " |      S.zfill(width) -> str\n",
      " |      \n",
      " |      Pad a numeric string S with zeros on the left, to fill a field\n",
      " |      of the specified width. The string S is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  maketrans(x, y=None, z=None, /)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"\"\"\n",
    "\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Split and join with string methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 's', <function __main__.foo>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"a b c\".split()\n",
    "[1, 's', foo]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'how can I subset?'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''.join(['h', 'ow', ' ', 'c', 'an', ' ', 'I ' 'su', 'bse', 't?'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# slices\n",
    "\n",
    "slice([start, ]stop[, step]) or [start]:stop[:step]\n",
    "\n",
    "- slices define the subset in terms of 0-based indices\n",
    "- stop is the only required element.\n",
    "- Missing starts are implied (start: 0, end: len(utterable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# CHECK POINT\n",
    "\n",
    "How can you rearange the string below to say \"this is so fun\"? Do not add any letters, use each type of slice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is "
     ]
    }
   ],
   "source": [
    "teststr = 'this is not fun.'\n",
    "print(teststr[:7], end = ' ')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# ANSWERS Hidden\n",
    "\n",
    "<div class=\"answers\">\n",
    "\n",
    "```\n",
    "print(teststr[:7], end = ' ')\n",
    "print(teststr[3:-1:6], end = '')\n",
    "print(teststr[-5:])\n",
    "```\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Iterable Types\n",
    "\n",
    "lists : [item1, item2, item3, ...]\n",
    "\n",
    "- created with square braces\n",
    "- indexed with square braces (indexing is always square braces, not just lists) and \"slices\"\n",
    "- tuples are like lists, but defined with parentheses and the items are immutable.\n",
    "\n",
    "dict : {key1: value1, key2: value2, ...}\n",
    "\n",
    "- indexed with keys\n",
    "- iterate keys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# iterables\n",
    "\n",
    "- strings, lists, dict, and tuples are iterables.\n",
    "- For any iterable, you can loop over the elements with a for loop\n",
    "    - Each character in a string...\n",
    "    - Each item in a list or tuple\n",
    "    - Each key in a dictionary\n",
    "- `enumerate` is a special function that returns the element number (0-based) and the element as a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# CHECK POINT\n",
    "\n",
    "The code below has three parts:\n",
    "\n",
    "- first cell define a function\n",
    "- subsequent cells call function\n",
    "- What are the types and values of a, b, and c?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def foo(pieces):\n",
    "    out = type(pieces[0])()\n",
    "    for i, piece in enumerate(pieces):\n",
    "        out += piece\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = foo('12345')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = foo([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "c = foo({0: 1, 1: 2, 2: 3, 3: 4, 4: 5})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Intro to numpy/scipy/matplotlib\n",
    "\n",
    "1. numpy - numerical python (aka, do math fast)\n",
    "2. scipy - a collection of scientific tools (aka, do stats or solve equations)\n",
    "3. matplotlib - a library for plotting (aka, make figures for my article)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# numpy\n",
    "\n",
    "numpy - Numerical Python (numpy.org)\n",
    "\n",
    "- Fast library for numerical mathematics\n",
    "- Large array processing (element by element)\n",
    "- Large matrix processing (using standard matrix)\n",
    "- Support for masked arrays\n",
    "- LAPACK for linear algebra\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Make a random \"ozone\" array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.random.seed(50)\n",
    "ozone = (np.random.normal(size = 2*3*4*5) + 40).reshape(2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(ozone.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4, 5) (3,) [ 39.66543482  40.48642763  38.50861149]\n"
     ]
    }
   ],
   "source": [
    "print(ozone.shape, ozone[0, :, 2, 3].shape, ozone[0, :, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39.9511584716\n"
     ]
    }
   ],
   "source": [
    "print(ozone.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 38.40819179  41.52552455]\n"
     ]
    }
   ],
   "source": [
    "print(np.percentile(ozone, [5, 95]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Which dimension is 2 long? 3 long? 4 long? 5 long?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Make an \"averaging\" kernel matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "averagekernel = np.array([[0.5, 0.35, 0.15],\n",
    "                          [0.25, 0.5, 0.25],\n",
    "                          [0.1, 0.4, 0.5]])\n",
    "averagekernelm = np.matrix(averagekernel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "(3, 3)\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "print(averagekernel.shape)\n",
    "print(averagekernelm.shape)\n",
    "print(averagekernelm.T.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3,), (1, 3), (3, 1))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "averagekernel = np.array([0.25, 0.5, 0.25])\n",
    "averagekernelm = np.matrix(averagekernel)\n",
    "averagekernel.shape, averagekernelm.shape, averagekernelm.T.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Which dimension is the input layer and which is the output layer?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Product sums and matrices?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "39.786725390722133"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(ozone[0, :, 2, 3] * averagekernel).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "ozone[0, :, 2, 3] * averagekernelm\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 39.78672539]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ozone[0, :, 2, 3] * averagekernelm.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# CHECK POINT\n",
    "\n",
    "How can we change the code to operate on all times, latitude, and longitudes without a loop?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 39.36282997,  40.25207302,  39.85299116,  39.17695003,\n",
       "          40.00616423],\n",
       "        [ 39.96880295,  39.57453709,  41.21765252,  39.77559737,\n",
       "          39.72131962],\n",
       "        [ 40.38088501,  40.87504393,  40.16600716,  39.78672539,\n",
       "          40.15137381],\n",
       "        [ 40.71263105,  40.87507997,  40.94645965,  39.67761914,\n",
       "          40.4431232 ]],\n",
       "\n",
       "       [[ 40.5726842 ,  38.83362944,  40.06432046,  37.82883717,\n",
       "          39.79688735],\n",
       "        [ 40.40327088,  39.9351408 ,  39.70370031,  39.40573444,\n",
       "          38.03569959],\n",
       "        [ 39.99168397,  39.91389171,  40.50004645,  40.61334477,\n",
       "          41.17862441],\n",
       "        [ 39.41308569,  39.64410936,  39.87867507,  40.35938726,\n",
       "          39.04594661]]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out = np.zeros_like(ozone[:, 0])\n",
    "for t in range(ozone.shape[0]):\n",
    "    for j in range(ozone.shape[2]):\n",
    "        for i in range(ozone.shape[3]):\n",
    "            out[t, j, i] = ozone[t, :, j, i] * averagekernelm.T\n",
    "out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# ANSWERS Hidden\n",
    "* Hint: Add singleton dimensions to force broadcasting.\n",
    "<div style=\"visibility: hidden\">\n",
    "\n",
    "newout = (ozone * averagekernel[None, :, None, None])\n",
    "(out == out).all()\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# scipy\n",
    "\n",
    "scipy - Scientific Python (scipy.org)\n",
    "\n",
    "- Good for physical constants\n",
    "- Large statistical library\n",
    "- Large interpolation library\n",
    "- Including masked array statistics\n",
    "- Ordinary Differential Equation Solving"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from scipy import constants\n",
    "?constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "?stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from scipy.stats import mstats\n",
    "?mstats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Our first statistical test\n",
    "\n",
    "1. Draw 2 random samples with an equal mean and standard deviation\n",
    "2. Compare them with a typical Student's t-test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ttest_indResult(statistic=-0.48157774931483521, pvalue=0.6306377590543939)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.stats import ttest_ind\n",
    "a = np.random.normal(size = 100)\n",
    "b = np.random.normal(size = 100)\n",
    "ttest_ind(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Our first regression\n",
    "\n",
    "1. Use a and 2+b from statistical test\n",
    "2. Use the linregress function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinregressResult(slope=0.25514917975823892, intercept=2.0095820912433124, rvalue=0.24503229165320531, pvalue=0.014006487835372169, stderr=0.10197936722182965)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.stats import linregress\n",
    "linregress(a, b+2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Same thing with masked data\n",
    "\n",
    "- observations are sometimes missing.\n",
    "- the example above might provide weird results in that case\n",
    "- prepare two sample dataset as before; flag some as missing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Force same results\n",
    "np.random.seed(1)\n",
    "\n",
    "# Draw random-ish samples\n",
    "a = np.random.normal(size = 100)\n",
    "b = np.random.normal(size = 100)\n",
    "\n",
    "# Select 25% of the data at random to be missing\n",
    "missing = np.random.random(size = 100) < .25\n",
    "\n",
    "# Set the data to a missing flag\n",
    "b[missing] = -9999"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Now Remove \"Missing\" Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ttest_indResult(statistic=4.8187908822920784, pvalue=2.8691204449152638e-06)\n",
      "Ttest_indResult(statistic=-0.44316616653427898, pvalue=0.65818068293308474)\n"
     ]
    }
   ],
   "source": [
    "# Create a masked array\n",
    "bm = np.ma.masked_values(b, -9999)\n",
    "\n",
    "from scipy.stats import ttest_ind\n",
    "print(ttest_ind(a, bm))\n",
    "from scipy.stats.mstats import ttest_ind\n",
    "print(ttest_ind(a, bm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# What happend to the missing data?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# XKCD, Jelly beans, and Type I Error?\n",
    "!['So, uh, we did the green study again and got no link. It was probably a--' 'RESEARCH CONFLICTED ON GREEN JELLY BEAN/ACNE LINK; MORE STUDY RECOMMENDED!'](http://imgs.xkcd.com/comics/significant.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.12/0.04, 0.09/0.03, 0.11/0.04, 0.1/0.02, 0.05/0.01, 0.08/0.04, 0.05/0.0, 0.1/0.01, 0.08/0.03, 0.1/0.04, 0.09/0.03, 0.07/0.02, 0.07/0.08, 0.03/0.0, 0.07/0.04, 0.15/0.09, 0.12/0.03, 0.1/0.02, 0.1/0.04, 0.06/0.01, [  3.           3.           2.75         5.           5.           2.\n",
      "          inf  10.           2.66666667   2.5          3.           3.5\n",
      "   0.875               inf   1.75         1.66666667   4.           5.\n",
      "   2.5          6.        ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/barronh/anaconda3/lib/python3.5/site-packages/ipykernel/__main__.py:28: RuntimeWarning: divide by zero encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import ttest_ind, mannwhitneyu\n",
    "\n",
    "np.random.seed(1)\n",
    "mdiffs = []\n",
    "tdiffs = []\n",
    "for i in range(20):\n",
    "    mdifferent = []\n",
    "    tdifferent = []\n",
    "    n = 100\n",
    "    for i in range(n):\n",
    "        obs = np.exp(np.random.normal(size = 20))\n",
    "        mod = np.exp(np.random.normal(size = 20))\n",
    "        tresult = ttest_ind(obs, mod)\n",
    "        mresult = mannwhitneyu(obs, mod)\n",
    "        if tresult.pvalue < 0.05:\n",
    "            tdifferent.append(i);\n",
    "        if mresult.pvalue < 0.05:\n",
    "            mdifferent.append(i);\n",
    "\n",
    "    mdiffs.append(len(mdifferent))\n",
    "    tdiffs.append(len(tdifferent))\n",
    "    print(len(mdifferent)/n, end = '/')\n",
    "    print(len(tdifferent)/n, end = ', ')\n",
    "\n",
    "mdiffs = np.array(mdiffs)\n",
    "tdiffs = np.array(tdiffs)\n",
    "\n",
    "print(mdiffs/tdiffs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# matplotlib\n",
    "\n",
    "matplotlib (matplotlib.org; optionally with basemap)\n",
    "\n",
    "- Plotting library with matlab functionality and naming\n",
    "- 2-D plotting\n",
    "    - line plots\n",
    "    - date plots\n",
    "    - tile plots\n",
    "    - contour plots\n",
    "- 3-D plotting\n",
    "    - see functionality above.\n",
    "    - Sometimes harder to work with than 2-D."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Super Simple Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/barronh/anaconda3/lib/python3.5/site-packages/IPython/core/magics/pylab.py:161: UserWarning: pylab import has clobbered these variables: ['mod']\n",
      "`%matplotlib` prevents importing * from pylab and numpy\n",
      "  \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABgUAAAQnCAYAAADb8WyIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10bd53320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "# from matplotlib.pyplot import *\n",
    "close()\n",
    "plot([0,10], [0,10], linestyle = '-', color = 'g', label = '1:1')\n",
    "plot([0,5], [0,10], linestyle = '-', color = 'r', label = '2:1')\n",
    "plot([0,10], [0,5], linestyle = '-', color = 'b', label = '1:2')\n",
    "legend();\n",
    "#savefig('temp.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Check Point\n",
    "\n",
    "Use help and the matplotlib gallery (google it) to determine what matplotlib functions can be used to make the following figures?\n",
    "- Heat maps\n",
    "- Contour plots\n",
    "- Scatter plots\n",
    "- Streamlines\n",
    "- Time series\n",
    "- Wind vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Answers Hidden\n",
    "<div class=\"answers\">\n",
    "- pcolor\n",
    "- contour or contourf\n",
    "- scatter\n",
    "- streamplot\n",
    "- plot\n",
    "- quiver\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Saved scripts are really important!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "?%save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "?%run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The following commands were written to file `test.py`:\n",
      "def foo(bar):\n",
      "    return 'foo.' + bar\n",
      "print(foo('bar'))\n",
      "try:\n",
      "    print(foo(1))\n",
      "except Exception as e:\n",
      "    print(e)\n",
      "1 + 1\n",
      "1 + 1.\n",
      "1 / 2.\n",
      "1 // 2;\n",
      "help(\"\"\"\n",
      "\n",
      "\"\"\")\n",
      "\"a b c\".split()\n",
      "[1, 's', foo]\n",
      "''.join(['h', 'ow', ' ', 'c', 'an', ' ', 'I ' 'su', 'bse', 't?'])\n",
      "teststr = 'this is not fun.'\n",
      "print(teststr[:7], end = ' ')\n",
      "def foo(pieces):\n",
      "    out = type(pieces[0])()\n",
      "    for i, piece in enumerate(pieces):\n",
      "        out += piece\n",
      "    return out\n",
      "a = foo('12345')\n",
      "b = foo([1, 2, 3, 4, 5])\n",
      "c = foo({0: 1, 1: 2, 2: 3, 3: 4, 4: 5})\n",
      "np.random.seed(50)\n",
      "ozone = (np.random.normal(size = 2*3*4*5) + 40).reshape(2,3,4,5)\n"
     ]
    }
   ],
   "source": [
    "%save -f test.py 5-20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo.bar\n",
      "Can't convert 'int' object to str implicitly\n",
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      S.__format__(format_spec) -> str\n",
      " |      \n",
      " |      Return a formatted version of S as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.n\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      S.__sizeof__() -> size of S in memory, in bytes\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(...)\n",
      " |      S.capitalize() -> str\n",
      " |      \n",
      " |      Return a capitalized version of S, i.e. make the first character\n",
      " |      have upper case and the rest lower case.\n",
      " |  \n",
      " |  casefold(...)\n",
      " |      S.casefold() -> str\n",
      " |      \n",
      " |      Return a version of S suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(...)\n",
      " |      S.center(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S centered in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space)\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(...)\n",
      " |      S.encode(encoding='utf-8', errors='strict') -> bytes\n",
      " |      \n",
      " |      Encode S using the codec registered for encoding. Default encoding\n",
      " |      is 'utf-8'. errors may be given to set a different error\n",
      " |      handling scheme. Default is 'strict' meaning that encoding errors raise\n",
      " |      a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n",
      " |      'xmlcharrefreplace' as well as any other name registered with\n",
      " |      codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(...)\n",
      " |      S.expandtabs(tabsize=8) -> str\n",
      " |      \n",
      " |      Return a copy of S where all tab characters are expanded using spaces.\n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Like S.find() but raise ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(...)\n",
      " |      S.isalnum() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphanumeric\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isalpha(...)\n",
      " |      S.isalpha() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphabetic\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isdecimal(...)\n",
      " |      S.isdecimal() -> bool\n",
      " |      \n",
      " |      Return True if there are only decimal characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isdigit(...)\n",
      " |      S.isdigit() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are digits\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isidentifier(...)\n",
      " |      S.isidentifier() -> bool\n",
      " |      \n",
      " |      Return True if S is a valid identifier according\n",
      " |      to the language definition.\n",
      " |      \n",
      " |      Use keyword.iskeyword() to test for reserved identifiers\n",
      " |      such as \"def\" and \"class\".\n",
      " |  \n",
      " |  islower(...)\n",
      " |      S.islower() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are lowercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  isnumeric(...)\n",
      " |      S.isnumeric() -> bool\n",
      " |      \n",
      " |      Return True if there are only numeric characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isprintable(...)\n",
      " |      S.isprintable() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are considered\n",
      " |      printable in repr() or S is empty, False otherwise.\n",
      " |  \n",
      " |  isspace(...)\n",
      " |      S.isspace() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are whitespace\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  istitle(...)\n",
      " |      S.istitle() -> bool\n",
      " |      \n",
      " |      Return True if S is a titlecased string and there is at least one\n",
      " |      character in S, i.e. upper- and titlecase characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |      Return False otherwise.\n",
      " |  \n",
      " |  isupper(...)\n",
      " |      S.isupper() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are uppercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  join(...)\n",
      " |      S.join(iterable) -> str\n",
      " |      \n",
      " |      Return a string which is the concatenation of the strings in the\n",
      " |      iterable.  The separator between elements is S.\n",
      " |  \n",
      " |  ljust(...)\n",
      " |      S.ljust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S left-justified in a Unicode string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(...)\n",
      " |      S.lower() -> str\n",
      " |      \n",
      " |      Return a copy of the string S converted to lowercase.\n",
      " |  \n",
      " |  lstrip(...)\n",
      " |      S.lstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(...)\n",
      " |      S.partition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, and return the part before it,\n",
      " |      the separator itself, and the part after it.  If the separator is not\n",
      " |      found, return S and two empty strings.\n",
      " |  \n",
      " |  replace(...)\n",
      " |      S.replace(old, new[, count]) -> str\n",
      " |      \n",
      " |      Return a copy of S with all occurrences of substring\n",
      " |      old replaced by new.  If the optional argument count is\n",
      " |      given, only the first count occurrences are replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Like S.rfind() but raise ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(...)\n",
      " |      S.rjust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S right-justified in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(...)\n",
      " |      S.rpartition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, starting at the end of S, and return\n",
      " |      the part before it, the separator itself, and the part after it.  If the\n",
      " |      separator is not found, return two empty strings and S.\n",
      " |  \n",
      " |  rsplit(...)\n",
      " |      S.rsplit(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string, starting at the end of the string and\n",
      " |      working to the front.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified, any whitespace string\n",
      " |      is a separator.\n",
      " |  \n",
      " |  rstrip(...)\n",
      " |      S.rstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with trailing whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(...)\n",
      " |      S.split(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified or is None, any\n",
      " |      whitespace string is a separator and empty strings are\n",
      " |      removed from the result.\n",
      " |  \n",
      " |  splitlines(...)\n",
      " |      S.splitlines([keepends]) -> list of strings\n",
      " |      \n",
      " |      Return a list of the lines in S, breaking at line boundaries.\n",
      " |      Line breaks are not included in the resulting list unless keepends\n",
      " |      is given and true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(...)\n",
      " |      S.strip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading and trailing\n",
      " |      whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(...)\n",
      " |      S.swapcase() -> str\n",
      " |      \n",
      " |      Return a copy of S with uppercase characters converted to lowercase\n",
      " |      and vice versa.\n",
      " |  \n",
      " |  title(...)\n",
      " |      S.title() -> str\n",
      " |      \n",
      " |      Return a titlecased version of S, i.e. words start with title case\n",
      " |      characters, all remaining cased characters have lower case.\n",
      " |  \n",
      " |  translate(...)\n",
      " |      S.translate(table) -> str\n",
      " |      \n",
      " |      Return a copy of the string S in which each character has been mapped\n",
      " |      through the given translation table. The table must implement\n",
      " |      lookup/indexing via __getitem__, for instance a dictionary or list,\n",
      " |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If\n",
      " |      this operation raises LookupError, the character is left untouched.\n",
      " |      Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(...)\n",
      " |      S.upper() -> str\n",
      " |      \n",
      " |      Return a copy of S converted to uppercase.\n",
      " |  \n",
      " |  zfill(...)\n",
      " |      S.zfill(width) -> str\n",
      " |      \n",
      " |      Pad a numeric string S with zeros on the left, to fill a field\n",
      " |      of the specified width. The string S is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  maketrans(x, y=None, z=None, /)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n",
      "this is "
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m-----------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/Users/barronh/Development/RAQMSandPython/working/test.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mseed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     30\u001b[0m \u001b[0mozone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m40\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "run test.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Explore the saved file\n",
    "\n",
    "This section is complete"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}