Basics.ipynb

{
 "metadata": {
  "name": "Basics"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "from pandas import *\n",
      "import pandas\n",
      "import numpy as np\n",
      "\n",
      "def side_by_side(*objs, **kwds):\n",
      "    from pandas.core.common import adjoin\n",
      "    space = kwds.get('space', 4)\n",
      "    reprs = [repr(obj).split('\\n') for obj in objs]\n",
      "    print adjoin(space, *reprs)\n",
      "\n",
      "plt.rc('figure', figsize=(10, 6))\n",
      "pandas.set_printoptions(notebook_repr_html=False)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Series\n",
      "======"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "labels = ['a', 'b', 'c', 'd', 'e']\n",
      "s = Series(randn(5), index=labels)\n",
      "s"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'b' in s"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s['b']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mapping = s.to_dict()\n",
      "mapping"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s = Series(mapping)\n",
      "s"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s[:3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s.index"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "DataFrame: 2D collection of Series\n",
      "=================================="
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df = DataFrame({'a': np.random.randn(6),\n",
      "                'b': ['foo', 'bar'] * 3,\n",
      "                'c': np.random.randn(6)})\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.index"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.columns"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df = DataFrame({'a': np.random.randn(6),\n",
      "                'b': ['foo', 'bar'] * 3,\n",
      "                'c': np.random.randn(6)},\n",
      "               index=DateRange('1/1/2000', periods=6))\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df = DataFrame({'a': np.random.randn(6),\n",
      "                'b': ['foo', 'bar'] * 3,\n",
      "                'c': np.random.randn(6)},\n",
      "               columns=['a', 'b', 'c', 'd'])\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Creation from nested dicts\n",
      "--------------------------\n",
      "\n",
      "These arise naturally in Python code"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "data = {}\n",
      "for col in ['foo', 'bar', 'baz']:\n",
      "    for row in ['a', 'b', 'c', 'd']:\n",
      "        data.setdefault(col, {})[row] = randn()\n",
      "data"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "DataFrame(data)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Data alignment\n",
      "=============="
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "close_px = read_csv('stock_data.csv', index_col=0, parse_dates=True)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "close_px"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "<class 'pandas.core.frame.DataFrame'>\n",
        "DatetimeIndex: 1000 entries, 2007-10-29 00:00:00 to 2011-10-14 00:00:00\n",
        "Data columns:\n",
        "AA      1000  non-null values\n",
        "AAPL    1000  non-null values\n",
        "GE      1000  non-null values\n",
        "IBM     1000  non-null values\n",
        "JNJ     1000  non-null values\n",
        "MSFT    1000  non-null values\n",
        "PEP     1000  non-null values\n",
        "SPX     1000  non-null values\n",
        "XOM     1000  non-null values\n",
        "dtypes: float64(9)"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s1 = close_px['AAPL'][-20:]\n",
      "s2 = close_px['AAPL'][-25:-10]\n",
      "side_by_side(s1, s2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "2011-09-19    411.63    2011-09-12    379.94\n",
        "2011-09-20    413.45    2011-09-13    384.62\n",
        "2011-09-21    412.14    2011-09-14    389.30\n",
        "2011-09-22    401.82    2011-09-15    392.96\n",
        "2011-09-23    404.30    2011-09-16    400.50\n",
        "2011-09-26    403.17    2011-09-19    411.63\n",
        "2011-09-27    399.26    2011-09-20    413.45\n",
        "2011-09-28    397.01    2011-09-21    412.14\n",
        "2011-09-29    390.57    2011-09-22    401.82\n",
        "2011-09-30    381.32    2011-09-23    404.30\n",
        "2011-10-03    374.60    2011-09-26    403.17\n",
        "2011-10-04    372.50    2011-09-27    399.26\n",
        "2011-10-05    378.25    2011-09-28    397.01\n",
        "2011-10-06    377.37    2011-09-29    390.57\n",
        "2011-10-07    369.80    2011-09-30    381.32\n",
        "2011-10-10    388.81    Name: AAPL          \n",
        "2011-10-11    400.29                        \n",
        "2011-10-12    402.19                        \n",
        "2011-10-13    408.43                        \n",
        "2011-10-14    422.00                        \n",
        "Name: AAPL                                  \n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s1 + s2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "2011-09-12       NaN\n",
        "2011-09-13       NaN\n",
        "2011-09-14       NaN\n",
        "2011-09-15       NaN\n",
        "2011-09-16       NaN\n",
        "2011-09-19    823.26\n",
        "2011-09-20    826.90\n",
        "2011-09-21    824.28\n",
        "2011-09-22    803.64\n",
        "2011-09-23    808.60\n",
        "2011-09-26    806.34\n",
        "2011-09-27    798.52\n",
        "2011-09-28    794.02\n",
        "2011-09-29    781.14\n",
        "2011-09-30    762.64\n",
        "2011-10-03       NaN\n",
        "2011-10-04       NaN\n",
        "2011-10-05       NaN\n",
        "2011-10-06       NaN\n",
        "2011-10-07       NaN\n",
        "2011-10-10       NaN\n",
        "2011-10-11       NaN\n",
        "2011-10-12       NaN\n",
        "2011-10-13       NaN\n",
        "2011-10-14       NaN\n",
        "Name: AAPL"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df = close_px.ix[-10:, :3]\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 7,
       "text": [
        "               AA    AAPL     GE\n",
        "2011-10-03   8.90  374.60  14.69\n",
        "2011-10-04   9.12  372.50  14.86\n",
        "2011-10-05   9.37  378.25  15.27\n",
        "2011-10-06   9.88  377.37  15.53\n",
        "2011-10-07   9.71  369.80  15.50\n",
        "2011-10-10  10.09  388.81  16.14\n",
        "2011-10-11  10.30  400.29  16.14\n",
        "2011-10-12  10.05  402.19  16.40\n",
        "2011-10-13  10.10  408.43  16.22\n",
        "2011-10-14  10.26  422.00  16.60"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "side_by_side(s1.reindex(s2.index), s2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b, c  = s1.align(s2, join='inner')\n",
      "side_by_side(b, c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b, c  = s1.align(s2, join='outer')\n",
      "side_by_side(b, c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b, c  = s1.align(s2, join='right')\n",
      "side_by_side(b, c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df = close_px.ix[-10:, ['AAPL', 'IBM', 'MSFT']]\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df2 = df.ix[::2, ['IBM', 'MSFT']]\n",
      "side_by_side(df, df2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df + df2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b, c = df.align(df2, join='inner')\n",
      "side_by_side(b, c) "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 29
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Transposing: no copy if all columns are same type\n",
      "-------------------------------------------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df[:5].T"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Columns can be any type\n",
      "-----------------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "n = 10\n",
      "foo = DataFrame(index=range(n))\n",
      "foo['floats'] = np.random.randn(n)\n",
      "foo['ints'] = np.arange(n)\n",
      "foo['strings'] = ['foo', 'bar'] * (n / 2)\n",
      "foo['bools'] = foo['floats'] > 0\n",
      "foo['objects'] = DateRange('1/1/2000', periods=n)\n",
      "foo"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "foo.dtypes"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "N.B. transposing is not roundtrippable in this case (column-oriented data structure)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "foo.T.T"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "foo.T.T.dtypes"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 34
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Function application\n",
      "====================\n",
      "\n",
      "You can apply arbitrary functions to the rows or columns of a DataFrame"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.apply(np.mean)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.apply(np.mean, axis=1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 36
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can get as fancy as you want"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "close_px"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 37
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def peak_date(series):\n",
      "    return series.index[series.argmax()]\n",
      "close_px.apply(peak_date)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.apply(lambda x: x.max() - x.min()) # np.ptp"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.log(close_px)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 40
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Plotting\n",
      "========\n",
      "\n",
      "Some basic plotting integration with matplotlib in Series / DataFrame"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "close_px[['AAPL', 'IBM', 'MSFT', 'XOM']].plot()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "rets.ix[-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 42
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "close_px.ix[-1].plot(kind='bar')\n",
      "title('Prices on %s' % close_px.index[-1])\n",
      "axhline(0)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 43
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Hierarchical indexing\n",
      "---------------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "index = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux'],\n",
      "                                   ['one', 'two', 'three']],\n",
      "                           labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3, 3],\n",
      "                                   [0, 1, 2, 0, 1, 1, 2, 0, 1, 2]])\n",
      "hdf = DataFrame(np.random.randn(10, 3), index=index,\n",
      "                columns=['A', 'B', 'C'])\n",
      "hdf"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 44
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "hdf.ix['foo']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 45
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "hdf.ix['foo'] = 0\n",
      "hdf"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 46
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "hdf.ix['foo', 'three']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 47
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Stacking and unstacking\n",
      "-----------------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "tuples = zip(*[['bar', 'bar', 'baz', 'baz',\n",
      "                'foo', 'foo', 'qux', 'qux'],\n",
      "               ['one', 'two', 'one', 'two',\n",
      "                'one', 'two', 'one', 'two']])\n",
      "index = MultiIndex.from_tuples(tuples)\n",
      "columns = MultiIndex.from_tuples([('A', 'cat'), ('B', 'dog'),\n",
      "                                  ('B', 'cat'), ('A', 'dog')])\n",
      "df = DataFrame(randn(8, 4), index=index, columns=columns)\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 48
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df2 = df.ix[[0, 1, 2, 4, 5, 7]]\n",
      "df2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 49
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.unstack()['B']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 50
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "GroupBy\n",
      "======="
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df = DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',\n",
      "                       'foo', 'bar', 'foo', 'foo'],\n",
      "                'B' : ['one', 'one', 'two', 'three',\n",
      "                       'two', 'two', 'one', 'three'],\n",
      "                'C' : np.random.randn(8),\n",
      "                'D' : np.random.randn(8)})\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 51
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for key, group in df.groupby('A'):\n",
      "    print key\n",
      "    print group"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 52
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.groupby('A')['C'].describe().T"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 53
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.groupby('A').mean()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 54
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for key, group in df.groupby('A'):\n",
      "    print key\n",
      "    print group"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 55
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.groupby(['A', 'B']).mean()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.groupby(['A', 'B'], as_index=False).mean()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 57
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "GroupBy example: linear regression by group\n",
      "-------------------------------------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import scikits.statsmodels.api as sm\n",
      "rets = close_px / close_px.shift(1) - 1\n",
      "\n",
      "def get_beta(rets):\n",
      "    rets = rets.dropna()\n",
      "    rets['intercept'] = 1.\n",
      "    model = sm.OLS(rets['MSFT'], rets.ix[:, ['AAPL', 'intercept']]).fit()\n",
      "    return model.params\n",
      "\n",
      "get_beta(rets)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 58
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "grouped = rets.groupby([lambda x: x.year, lambda x: x.month])\n",
      "beta_by_ym = grouped.apply(get_beta)\n",
      "beta_by_ym"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 59
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "beta_by_ym.unstack(0)['AAPL']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 60
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "GroupBy with hierarchical indexing\n",
      "----------------------------------"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "tuples = zip(*[['bar', 'bar', 'baz', 'baz',\n",
      "                'foo', 'foo', 'qux', 'qux'],\n",
      "               ['one', 'two', 'one', 'two',\n",
      "                'one', 'two', 'one', 'two']])\n",
      "index = MultiIndex.from_tuples(tuples)\n",
      "columns = MultiIndex.from_tuples([('A', 'cat'), ('B', 'dog'),\n",
      "                                  ('B', 'cat'), ('A', 'dog')])\n",
      "df = DataFrame(randn(8, 4), index=index, columns=columns)\n",
      "df"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 61
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.groupby(level=0, axis=0).mean()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 62
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.stack()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 63
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "df.stack().mean(1).unstack()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 64
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# could also have done\n",
      "df.groupby(level=1, axis=1).mean()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 65
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": "&nbsp;"
    }
   ],
   "metadata": {}
  }
 ]
}