LearningPython.IO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python input-output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dealing with input-output in Python. While `readcol` is pretty awesome in IDL, the options in Python *can* be a lot more powerful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##Set up matplotlib for display in the browser:\n",
    "%matplotlib inline\n",
    "\n",
    "##Very most basic/standard imports:\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "##If you read FITS or ascii tables, these are necessary:\n",
    "from astropy.io import fits\n",
    "from astropy.io import ascii\n",
    "\n",
    "##Automatic unit tracking...maybe?\n",
    "import astropy.units as u\n",
    "\n",
    "##Module containing a lot of standard stats packages:\n",
    "from scipy import stats\n",
    "\n",
    "#System options:\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key here is the `astropy.io` packages.\n",
    "\n",
    "### Input FITS file\n",
    "We'll start by looking at the GBT AMIGA datasets, doing some reading and writing of data. First we define a variable to hold the directory with the data we want to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "baseDirectory='Data/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Use fits.open\n",
    "Let's read in the structure holding the M31 base information. The first approach is to use the `fits.open` functionality. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<astropy.io.fits.hdu.image.PrimaryHDU object at 0x191183bc18>, <astropy.io.fits.hdu.table.BinTableHDU object at 0x1a1199b048>]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m31structure = fits.open(baseDirectory+'m31structure.fits')\n",
    "m31structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This doesn't quite load things in as cleanly as IDL. We have to separate the data from the column names. The first element holds the primary header, while the second holds the data. I start by pulling these into new variables holding the data and the column names (just in case)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ColDefs(\n",
       "    name = 'PROJECT_DIR'; format = '30A'\n",
       "    name = 'DATA_DIR'; format = '43A'\n",
       "    name = 'PAPER_DIR'; format = '36A'\n",
       "    name = 'PLOT_COLOR'; format = '16A'\n",
       "    name = 'DISTKPC'; format = 'E'\n",
       "    name = 'RVIR'; format = 'E'\n",
       "    name = 'BEAMSIZE'; format = 'E'\n",
       "    name = 'RA'; format = 'E'\n",
       "    name = 'DEC'; format = 'E'\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m31 = m31structure[1].data\n",
    "m31cols = m31structure[1].columns \n",
    "m31cols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then access the individual columns using an index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "chararray(['/Users/howk/Dropbox/GBT-AMIGA/Paper/'],\n",
       "          dtype='<U36')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m31['paper_dir']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. fits.getdata\n",
    "The second approach uses the `fits.getdata` approach, which gives results that are a bit more analagous to IDL's structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FITS_rec([ ('/Users/howk/Dropbox/GBT-AMIGA/', '/Users/howk/Dropbox/GBT-AMIGA/Data-Reduced/', '/Users/howk/Dropbox/GBT-AMIGA/Paper/', 'medium sea green',  752.,  300.,  1.99060428,  10.68470764,  41.26874924)],\n",
       "         dtype=(numpy.record, [('PROJECT_DIR', 'S30'), ('DATA_DIR', 'S43'), ('PAPER_DIR', 'S36'), ('PLOT_COLOR', 'S16'), ('DISTKPC', '>f4'), ('RVIR', '>f4'), ('BEAMSIZE', '>f4'), ('RA', '>f4'), ('DEC', '>f4')]))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m31structure = fits.getdata(baseDirectory+'m31structure.fits')\n",
    "m31structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now these data can be accessed using a structure similar to the tags in IDL's structures with two exceptions: 1) the data in every tag are stored as an array; 2) the tag names *must be capitalized.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 300.], dtype=float32),\n",
       " array([b'/Users/howk/Dropbox/GBT-AMIGA/Paper/'],\n",
       "       dtype='|S36'),\n",
       " array([ 10.68470764], dtype=float32))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#More info on the fits data storage:\n",
    "#m31structure??\n",
    "m31structure.RVIR,m31structure.PAPER_DIR,m31structure.RA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print the data in a few ways, including just calling the variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.6847 41.2687\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 10.68470764], dtype=float32)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(m31structure.RA[0],m31structure.DEC[0])\n",
    "(m31structure['RA'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read in ASCII tables:\n",
    "ASCII tables can be read in multiple ways, including through the `astropy.io.ascii` package or the `astropy.tables` package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's set up the input and output filenames:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "outputFile = baseDirectory+'coveringFactors.py.dat'\n",
    "inputList = baseDirectory+'pointing_list.dat'\n",
    "inputDetections = baseDirectory+'detection_list.dat'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of using `astropy.io.ascii.read`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Read in QSOs with only limits:\n",
    "cover=ascii.read(inputList,guess=True,comment=';; ',\n",
    "                 names=('qsoindex','qsoname','ra','dec',\n",
    "                            'Tsys','sep_angle',\n",
    "                            'rho','rvir',\n",
    "                            'sigma','limits'))\n",
    "## Read in the detections:\n",
    "detections=ascii.read(inputDetections,guess=True,comment=\";; \",\n",
    "                      names=('qsoindex','qsoname','ra','dec',\n",
    "                             'rho','rhoNorm','NHI','eNHI',\n",
    "                             'vel','evel','FWHM','eFWHM',\n",
    "                             'gasID'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use this to access the variables of interest. We can now use these data!! For example, filling a variable with the quantity of interest (impact parameter in this case) or testing against specific quantities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "##Identify the detected sight lines that are associated with the MagStream:\n",
    "MSgas = (detections['gasID'] == 'MS')  ##MSgas is a boolean quantity.\n",
    "\n",
    "##Impact parameters:\n",
    "rho=cover['rho']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Outputing ASCII tables:\n",
    "Let's look into writing the data to three formats: 1) Basic ASCII table, 2) HTML table, 3) AASTeX deluxe table:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ascii.write(detections,'temp_out.dat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "# Index, Source, RA, Dec, Rho (kpc), Rho/Rvir, log N(HI), sigma(log NHI), v(HI), sigma(v(HI)), FWHM, sigma(FWHM), GAS ID\n",
    "# 10 2E0111+3851  01:13:54.50  +39:07:44.0  82  0.28  17.90  0.08  -292.0  4  67.7 10.2  Bridge\n",
    "# 24  PG0052+251  00:54:52.13  +25:25:38.9 207  0.69  17.76  0.08  -351.0 1.5 24.3 3.6  MS\n",
    "# OLD\n",
    "# 27     RBS2055  23:51:52.77  +26:19:32.5 235  0.79  18.08  0.06  -330.6 1.3 35.6 3.2  MS\n",
    "# 28     RBS2061  23:55:48.21  +25:30:31.6 238  0.80  18.18  0.07  -331.3 2.6 53.3 6.6  MS\n",
    "qsoindex qsoname ra dec rho rhoNorm NHI eNHI vel evel FWHM eFWHM gasID\n",
    "27 RBS2055 23:51:52.77 +26:19:32.5 235 0.79 17.88 0.05 -331.5 1.0 25.1 2.3 MS\n",
    "28 RBS2061 23:55:48.21 +25:30:31.6 238 0.8 17.79 0.08 -334.0 1.7 29.1 4.0 MS\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ascii.write(detections,'temp_out.html',format='html')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<html>\n",
       " <head>\n",
       "  <meta charset=\"utf-8\"/>\n",
       "  <meta content=\"text/html;charset=UTF-8\" http-equiv=\"Content-type\"/>\n",
       " </head>\n",
       " <body>\n",
       "  <table>\n",
       "   <thead>\n",
       "    <tr>\n",
       "     <th>qsoindex</th>\n",
       "     <th>qsoname</th>\n",
       "     <th>ra</th>\n",
       "     <th>dec</th>\n",
       "     <th>rho</th>\n",
       "     <th>rhoNorm</th>\n",
       "     <th>NHI</th>\n",
       "     <th>eNHI</th>\n",
       "     <th>vel</th>\n",
       "     <th>evel</th>\n",
       "     <th>FWHM</th>\n",
       "     <th>eFWHM</th>\n",
       "     <th>gasID</th>\n",
       "    </tr>\n",
       "   </thead>\n",
       "   <tr>\n",
       "    <td>27</td>\n",
       "    <td>RBS2055</td>\n",
       "    <td>23:51:52.77</td>\n",
       "    <td>+26:19:32.5</td>\n",
       "    <td>235</td>\n",
       "    <td>0.79</td>\n",
       "    <td>17.88</td>\n",
       "    <td>0.05</td>\n",
       "    <td>-331.5</td>\n",
       "    <td>1.0</td>\n",
       "    <td>25.1</td>\n",
       "    <td>2.3</td>\n",
       "    <td>MS</td>\n",
       "   </tr>\n",
       "   <tr>\n",
       "    <td>28</td>\n",
       "    <td>RBS2061</td>\n",
       "    <td>23:55:48.21</td>\n",
       "    <td>+25:30:31.6</td>\n",
       "    <td>238</td>\n",
       "    <td>0.8</td>\n",
       "    <td>17.79</td>\n",
       "    <td>0.08</td>\n",
       "    <td>-334.0</td>\n",
       "    <td>1.7</td>\n",
       "    <td>29.1</td>\n",
       "    <td>4.0</td>\n",
       "    <td>MS</td>\n",
       "   </tr>\n",
       "  </table>\n",
       " </body>\n",
       "</html>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<html>\n",
    " <head>\n",
    "  <meta charset=\"utf-8\"/>\n",
    "  <meta content=\"text/html;charset=UTF-8\" http-equiv=\"Content-type\"/>\n",
    " </head>\n",
    " <body>\n",
    "  <table>\n",
    "   <thead>\n",
    "    <tr>\n",
    "     <th>qsoindex</th>\n",
    "     <th>qsoname</th>\n",
    "     <th>ra</th>\n",
    "     <th>dec</th>\n",
    "     <th>rho</th>\n",
    "     <th>rhoNorm</th>\n",
    "     <th>NHI</th>\n",
    "     <th>eNHI</th>\n",
    "     <th>vel</th>\n",
    "     <th>evel</th>\n",
    "     <th>FWHM</th>\n",
    "     <th>eFWHM</th>\n",
    "     <th>gasID</th>\n",
    "    </tr>\n",
    "   </thead>\n",
    "   <tr>\n",
    "    <td>27</td>\n",
    "    <td>RBS2055</td>\n",
    "    <td>23:51:52.77</td>\n",
    "    <td>+26:19:32.5</td>\n",
    "    <td>235</td>\n",
    "    <td>0.79</td>\n",
    "    <td>17.88</td>\n",
    "    <td>0.05</td>\n",
    "    <td>-331.5</td>\n",
    "    <td>1.0</td>\n",
    "    <td>25.1</td>\n",
    "    <td>2.3</td>\n",
    "    <td>MS</td>\n",
    "   </tr>\n",
    "   <tr>\n",
    "    <td>28</td>\n",
    "    <td>RBS2061</td>\n",
    "    <td>23:55:48.21</td>\n",
    "    <td>+25:30:31.6</td>\n",
    "    <td>238</td>\n",
    "    <td>0.8</td>\n",
    "    <td>17.79</td>\n",
    "    <td>0.08</td>\n",
    "    <td>-334.0</td>\n",
    "    <td>1.7</td>\n",
    "    <td>29.1</td>\n",
    "    <td>4.0</td>\n",
    "    <td>MS</td>\n",
    "   </tr>\n",
    "  </table>\n",
    " </body>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ascii.write(detections,'temp_out.tex',format='aastex')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "\\begin{deluxetable}{ccccccccccccc}\n",
    "\\tablehead{\\colhead{qsoindex} & \\colhead{qsoname} & \\colhead{ra} & \\colhead{dec} & \\colhead{rho} & \\colhead{rhoNorm} & \\colhead{NHI} & \\colhead{eNHI} & \\colhead{vel} & \\colhead{evel} & \\colhead{FWHM} & \\colhead{eFWHM} & \\colhead{gasID}}\n",
    "\\startdata\n",
    "27 & RBS2055 & 23:51:52.77 & +26:19:32.5 & 235 & 0.79 & 17.88 & 0.05 & -331.5 & 1.0 & 25.1 & 2.3 & MS \\\\\n",
    "28 & RBS2061 & 23:55:48.21 & +25:30:31.6 & 238 & 0.8 & 17.79 & 0.08 & -334.0 & 1.7 & 29.1 & 4.0 & MS\n",
    "\\enddata\n",
    "\\end{deluxetable}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## A more involved AASTeX table:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we need to make some calculations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats.distributions as dist \n",
    "#Confidence interval range for the statistics.\n",
    "confidenceRange = 0.8\n",
    "\n",
    "num_bins = 14\n",
    "rho_bins = 25.*(np.arange(num_bins)+1)\n",
    "num_objects = np.zeros(num_bins)\n",
    "num_detections = np.zeros(num_bins)\n",
    "num_detectionsMS = np.zeros(num_bins)\n",
    "coveringFactors = np.zeros([num_bins, 3])\n",
    "coveringFactorsMS = np.zeros([num_bins, 3])\n",
    "\n",
    "\n",
    "for j in np.arange(0,num_bins):\n",
    "    trials = (rho <= rho_bins[j])\n",
    "    num_trials = trials.sum()\n",
    "    \n",
    "    hits = ((detections['rho'] <= rho_bins[j]) & \n",
    "            (detections['gasID'] != 'MS'))\n",
    "    num_hits = hits.sum()\n",
    "    \n",
    "    hitsMS = ((detections['rho'] <= rho_bins[j]) & \n",
    "              (detections['gasID'] == 'MS'))\n",
    "    num_hitsMS = hitsMS.sum()\n",
    "    \n",
    "    # Fill some of the outputs:\n",
    "    num_objects[j] = num_trials\n",
    "    num_detections[j] = num_hits\n",
    "    num_detectionsMS[j] = num_hitsMS\n",
    "\n",
    "\n",
    "    # Calculate the confidence intervals without MS:    \n",
    "    p_lower=dist.beta.ppf((1-confidenceRange)/2.,\n",
    "                          num_hits+1, num_trials-num_hits+1)\n",
    "    p_middle=dist.beta.ppf(0.5,\n",
    "                           num_hits+1, num_trials-num_hits+1)\n",
    "    p_upper=dist.beta.ppf(1-(1-confidenceRange)/2.,\n",
    "                          num_hits+1, num_trials-num_hits+1)\n",
    "    # Fill the output:\n",
    "    coveringFactors[j, ] = [p_lower, p_middle, p_upper]\n",
    "\n",
    "\n",
    "    #########################\n",
    "    # Calculate the confidence intervals with MS sight lines:    \n",
    "    p_lower=dist.beta.ppf((1-confidenceRange)/2.,\n",
    "                          num_hitsMS+1, num_trials-num_hitsMS+1)\n",
    "    p_middle=dist.beta.ppf(0.5,\n",
    "                           num_hitsMS+1, num_trials-num_hitsMS+1)\n",
    "    p_upper=dist.beta.ppf(1-(1-confidenceRange)/2.,\n",
    "                          num_hitsMS+1, num_trials-num_hitsMS+1)\n",
    "\n",
    "    #Fill the outputs\n",
    "    coveringFactorsMS[j, ] = [p_lower, p_middle, p_upper]\n",
    "\n",
    "coveringFactors = np.around(coveringFactors,decimals=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Next we deal with the Latex stuff:\n",
    "\n",
    "First we construct an `astropy` table:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from astropy.table import Table, Column\n",
    "\n",
    "## Set-up the header names:\n",
    "outputLabelsTex=[r'$\\rho$ [kpc]',\n",
    "              r'$\\rho / R_{vir}$',\n",
    "              r'$f_c(<\\rho)$\\tablenotemark{a}',\n",
    "              r'$N$\\tablenotemark{b}']\n",
    "\n",
    "## Fill with data:\n",
    "outputDataTex=(rho_bins, \n",
    "            np.round(rho_bins/m31['rvir'],2),\n",
    "            coveringFactors[:,2], \n",
    "            num_objects.round())\n",
    "\n",
    "## Construct astropy table:\n",
    "outputLatex=Table(outputDataTex,names=outputLabelsTex)\n",
    "#outputLatex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we write the `AASTeX` table using the `ascii.write` function. Note that arguments can be used to set options in the `latexdict` dictionary. This is how we'll set up the caption and footnotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{deluxetable}{cccc}\n",
      "\\tablecaption{\\HI\\ Covering Factors\\label{tab:coveringfactor}}\n",
      "\\tablehead{\\colhead{$\\rho$ [kpc]} & \\colhead{$\\rho / R_{vir}$} & \\colhead{$f_c(<\\rho)$\\tablenotemark{a}} & \\colhead{$N$\\tablenotemark{b}}}\n",
      "\\startdata\n",
      "25 & 0.08 & $< 0.684$ & 1 \\\\\n",
      "50 & 0.17 & $< 0.369$ & 4 \\\\\n",
      "75 & 0.25 & $< 0.250$ & 7 \\\\\n",
      "100 & 0.33 & $< 0.152$ & 13 \\\\\n",
      "125 & 0.42 & $< 0.134$ & 15 \\\\\n",
      "150 & 0.50 & $< 0.109$ & 19 \\\\\n",
      "175 & 0.58 & $< 0.095$ & 22 \\\\\n",
      "200 & 0.67 & $< 0.091$ & 23 \\\\\n",
      "225 & 0.75 & $< 0.082$ & 26 \\\\\n",
      "250 & 0.83 & $< 0.067$ & 32 \\\\\n",
      "275 & 0.92 & $< 0.056$ & 39 \\\\\n",
      "300 & 1.00 & $< 0.050$ & 44 \\\\\n",
      "325 & 1.08 & $< 0.048$ & 46 \\\\\n",
      "350 & 1.17 & $< 0.045$ & 49\n",
      "\\enddata\n",
      "\\tablenotetext{a}{Upper limits are at 90\\%\\ confidence.} \\tablenotetext{b}{Number of sight lines considered in covering factor determination.}\n",
      "\\end{deluxetable}\n"
     ]
    }
   ],
   "source": [
    "latexDict={'caption': \n",
    "           r'\\HI\\ Covering Factors\\label{tab:coveringfactor}',\n",
    "           'tablefoot':\n",
    "               r'\\tablenotetext{a}{Upper limits are at 90\\%\\ confidence.} \\tablenotetext{b}{Number of sight lines considered in covering factor determination.}'\n",
    "           }\n",
    "\n",
    "ascii.write(outputLatex,sys.stdout,format='aastex',\n",
    "            latexdict=latexDict,\n",
    "            formats={outputLatex.colnames[0]:'%3.0f',\n",
    "                     outputLatex.colnames[1]:'%4.2f',\n",
    "                     outputLatex.colnames[2]:'$< %0.3f$',\n",
    "                     outputLatex.colnames[3]:'%2.0f'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be output to a file, which can then be integrated into a latex document using the `\\input{}` functionality."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}