{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro\n",
    "This is going to be a fast whirlwind into python. With 1 hour I won't be able to teach you everything about python, so instead I'll just give you the broad details, some examples, and some links to more references."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mathematical operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.6\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "b = a * 3.4\n",
    "b += 1  # same as b = b + 1\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: exponentiation is done by `**` NOT `^`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2^3 # this is actually (2 BITWISE_OR 3), not 2*2*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logic and Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if` blocks and other types of logic use whitespace to demark the block of code it affects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is greater than 3\n"
     ]
    }
   ],
   "source": [
    "if b > 3:\n",
    "    print(\"b is greater than 3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions also use whitespace, and need to start with `def`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply_by_5(x):\n",
    "    return x*5\n",
    "\n",
    "multiply_by_5(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing external code\n",
    "This approach works for both code you write and packages you install with `conda`/`pip`.\n",
    "\n",
    "First I'll just make a sample file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"sample_file.py\", mode=\"w\") as f:\n",
    "    f.write(\"\"\"\n",
    "def divide_by_two(x):\n",
    "    result = x / 2\n",
    "    return result\n",
    "    \n",
    "def divide_by_three(x):\n",
    "    result = x / 3\n",
    "    return result\n",
    "\n",
    "    \"\"\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sample_file\n",
    "\n",
    "sample_file.divide_by_two(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sample_file import divide_by_three # you can import \n",
    "\n",
    "divide_by_three(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: it's hard to import an arbitrary script stored in a random folder on your computer. The simplest solution is to make sure it's in the same folder as where you started python from, or the folder where your jupyter notebook is located."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To import packages you installed from pip/conda, you do the same thing, but don't need to worry about where it's saved:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2019, 1, 22, 13, 14, 7, 989667)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datetime\n",
    "datetime.datetime.today()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collections of objects\n",
    "So I've already shown that python can handle `int`s, `float`s, and `string`s. The next level up is *collections* of these objects.\n",
    "\n",
    "In general, python is fine having a collection of multiple types all at once:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_list type:  <class 'list'>\n",
      "my_other_list type:  <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4]\n",
    "my_other_list = [1, \"two\", 3.14]\n",
    "\n",
    "print(\"my_list type: \", type(my_list))\n",
    "print(\"my_other_list type: \", type(my_other_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the elements within a list, as well as changing the size of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "my_changing_list = [1, 2, 3, 4]\n",
    "print(my_changing_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'hello world']\n"
     ]
    }
   ],
   "source": [
    "my_changing_list[3] = \"hello world\"  # note that it's 0-indexed!\n",
    "print(my_changing_list)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'hello world', 'test']\n"
     ]
    }
   ],
   "source": [
    "my_changing_list.append(\"test\")\n",
    "print(my_changing_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'hello world', 'test', 'appending', 'a', 'second', 'list', 'example']\n"
     ]
    }
   ],
   "source": [
    "my_changing_list += [\"appending\", \"a\", \"second\", \"list\", \"example\"]\n",
    "print(my_changing_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'hello world', 'test', 'appending', 'a', 'second', 'list']\n",
      "last_element:  example\n"
     ]
    }
   ],
   "source": [
    "last_element = my_changing_list.pop()\n",
    "print(my_changing_list)\n",
    "print(\"last_element: \", last_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: You technically can run the above cells in any order, but you'll keep getting different results. This is an example of how jupyter notebooks can make it easier to screw up your code/results.  In general your notebook should only run from top to bottom, and you should put anything super important into a separate `.py` file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating `list`s: constructor vs literal\n",
    "\n",
    "You can also create a `list` using its \"constructor\", rather than the \"literal\" version above. \n",
    "\n",
    "The constructor (`list()`) version is most useful when you're converting something else into a list. The \"literal\" version (`[...]`) is best if your coding it in manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "list_from_constructor = list()\n",
    "print(list_from_constructor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a']\n"
     ]
    }
   ],
   "source": [
    "list_from_constructor.append(\"a\")\n",
    "print(list_from_constructor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loops and iterating over collections\n",
    "You can use a `for` loop with either the list index or the list values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_list = [10, 20, 30, 40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(sample_list)): # iterates from 0 to 3\n",
    "    print(sample_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "for value_from_list in sample_list:\n",
    "    print(value_from_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `tuple`\n",
    "- `tuple` is like a list, except you can't change it once you create it. It has a literal version `(1, 2, ...)` and a constructor `tuple()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-21-6c386b1ad898>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_tuple\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;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"new value\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_tuple = (1, 2, 3)\n",
    "my_tuple[2] = \"new value\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuple also has a constructor and literal version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_1 = (1, 2, 3)\n",
    "tuple_2 = tuple([4, 5, 6]) # creates a list, and then converts that into a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict\n",
    "Unlike lists which require integer indices (`my_list[0]`), dictionaries use user-defined indices.\n",
    "\n",
    "(This makes this a \"key -> value\" map, if that helps you understand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.2\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"NGC_1234\": 5.2,\n",
    "           \"NGC_5678\": 3.4,\n",
    "           \"SN_1987a\": \"the value matched to SN_1987a\",\n",
    "          }\n",
    "\n",
    "print(my_dict[\"NGC_1234\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also `dict` has a literal version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "redshift_dict = {\"NGC_1234\": 5.2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and a constructor version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.2\n"
     ]
    }
   ],
   "source": [
    "redshift_dict = dict()\n",
    "redshift_dict[\"NGC_1234\"] = 5.2\n",
    "\n",
    "print(redshift_dict[\"NGC_1234\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: `dict`s can use a `tuple` as an index/label, but not `list`, so make sure to convert them. Example (bad, then good):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-6dc8b1b7d69f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtemporary_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"3\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"quick\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"things\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_dict\u001b[0m\u001b[0;34m[\u001b[0m \u001b[0mtemporary_list\u001b[0m \u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "temporary_list = [\"3\", \"quick\", \"things\"]\n",
    "my_dict[ temporary_list ] = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "my_dict[ tuple(temporary_list) ] = 1.0\n",
    "\n",
    "print(my_dict[tuple(temporary_list)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using tuples as the key is useful for when you want the key to be a combination of multiple variables (e.g. RA and DEC pairs, not just RA or DEC individually.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`dict`s can have any data type as their \"value\", just like `list`s and `tuples`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Misc. collections\n",
    "I won't talk about things like `set`s, `Counters`, etc. Just know there's an entire `collections` library.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `numpy` and `array`s\n",
    "`lists` and the built-in functions are great, but we often want to do *numerical* science. For this, basically everything will built upon the package `numpy` (numerical python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # standard abbreviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.38905609893065"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(2) # e^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`numpy` also provides `array`s, which let you create list-like objects, which behave like _vectors_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_list = [1, 2, 3]\n",
    "example_array = np.array(example_list)\n",
    "example_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * example_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.30103   , 0.47712125])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log10(example_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(np.array([1,2,3]), np.array([4,5,6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -5])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_matrix = np.array([[1,2,3],\n",
    "                      [4,5,6],\n",
    "                      [7,8,9]])\n",
    "\n",
    "np.dot(my_matrix, np.array([-2, 0, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, `array`s will be the standard way we group together large numbers of values (even if we don't need it to behave like a matrix). Even more complicated data types (like `fits` images) will still be based on `numpy.array`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting with `matplotlib`\n",
    "\n",
    "The core plotting package for python is `matplotlib`, and more specifically `matplotlib.pyplot`\n",
    "\n",
    "Here's their [example gallery](https://matplotlib.org/gallery/index.html) which is a great place for finding how to do more complex types of plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = np.random.random(100) # draw 100 random values in (0, 1), store as an array\n",
    "ys = np.random.random(xs.size)\n",
    "\n",
    "plt.scatter(xs, ys)\n",
    "plt.xlabel(\"Add an optional axis label\")\n",
    "\n",
    "plt.ylim(bottom=-.2) # you can change the limits of the axes\n",
    "\n",
    "plt.xscale(\"log\") # and switch between linear/log spacing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11c5d8630>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# same data as above, just taking the histogram of the x axis\n",
    "plt.hist(xs, label=\"my data\", bins = np.logspace(-1, 0))\n",
    "\n",
    "plt.xscale(\"log\")\n",
    "\n",
    "plt.legend() # this'll automatically create a legend using the `label`s used when creating the plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "multiple plots can be combined:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11c552a20>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# hist2d creates a \"heat map\"\n",
    "plt.hist2d(np.random.normal(size=1000), # x variable\n",
    "           np.random.normal(size=1000), # y variable\n",
    "           cmap = \"Greys\", # sets the colormap\n",
    "          )\n",
    "\n",
    "plt.colorbar(label=\"number of points per bin\") # so you can interpret the colors of your colormap\n",
    "\n",
    "x_line = np.linspace(0, 1, num=50) # 50 equally spaced points between 0 and 1\n",
    "y_line = 3*np.sin(x_line*4) - 2\n",
    "plt.plot(x_line, y_line,\n",
    "         color=\"red\",\n",
    "         label=\"example line plot\",\n",
    "        )\n",
    "\n",
    "# this only works if you already have latex installed\n",
    "plt.ylabel(r\"can use latex math: $\\mathcal{O}(n^{3/2}) \\binom{n}{2}$\")\n",
    "\n",
    "plt.legend(loc=\"upper right\") # `loc` sets the location of the legend to the given area\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `astropy`\n",
    "`astropy` is the biggest astronomy package in python. It tends to be pretty general purpose, since it's aimed at all astronomers. If you need something more specific (like a package to reduce data from a specific telescope), that will usually be in a separate package. (Here are some [affiliated packages](http://www.astropy.org/affiliated/index.html) which is a good place to start looking if `astropy` doesn't have what you need.)\n",
    "\n",
    "It has more than I can talk about here, but I'll go over some popular parts, and you can look at the [tutorials](http://www.astropy.org/astropy-tutorials/) as you need."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `astropy.units`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from astropy import units as u\n",
    "from astropy import constants as const"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$1.9884754 \\times 10^{30} \\; \\mathrm{kg}$"
      ],
      "text/plain": [
       "<<class 'astropy.constants.iau2015.IAU2015'> name='Solar mass' value=1.9884754153381438e+30 uncertainty=9.236140093538353e+25 unit='kg' reference='IAU 2015 Resolution B 3 + CODATA 2014'>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Physical constants:\n",
    "const.M_sun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$1.9884754 \\times 10^{33} \\; \\mathrm{g}$"
      ],
      "text/plain": [
       "<Quantity 1.98847542e+33 g>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Unit conversion\n",
    "const.M_sun.to(u.g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.9884754153381438e+33"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can still get a plain float if you need\n",
    "const.M_sun.to(u.g).value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `astropy` and `fits` files\n",
    "Astropy is a great way to read and manipulate `.fits` files (see `astropy.io.fits`). They even have a whole tutorial on this for images, so we're just going to pop over there for a moment:\n",
    "\n",
    "http://www.astropy.org/astropy-tutorials/rst-tutorials/FITS-images.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `scipy` for more complex numerical tools than `numpy`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: `scipy` doesn't import all of itself automatically; it would take too long / be too large. Instead you'll have to explicitly import submodules, like we do below. There's two main options for the syntax:\n",
    "\n",
    "1) `import scipy.optimize`, which you then use by calling, e.g., `scipy.optimize.root()`\n",
    "\n",
    "2) `from scipy import optimize`, which you can call by simply using `optimize.root()` (you don't need to say `scipy.` first)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: function \"root\" solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.optimize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x + np.exp(x) - 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x101e0d2898>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = np.linspace(0, 2)\n",
    "plt.plot(xs, f(xs))\n",
    "plt.axhline(0, linestyle=\"dashed\", color=\"black\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "    fjac: array([[-1.]])\n",
       "     fun: array([0.])\n",
       " message: 'The solution converged.'\n",
       "    nfev: 10\n",
       "     qtf: array([-2.66453526e-13])\n",
       "       r: array([-3.92627094])\n",
       "  status: 1\n",
       " success: True\n",
       "       x: array([1.07372894])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scipy.optimize.root(f, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: integrator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.integrate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deriv(t, y):\n",
    "    # this is dy/dt evaluated at t where y=y(t)\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = np.linspace(0, 5, num=100)\n",
    "results = scipy.integrate.solve_ivp(deriv,\n",
    "                                    [min(ts), max(ts)],\n",
    "                                    [1], #start at t0=min(ts), and y(t0)=1\n",
    "                                    t_eval = ts,\n",
    "                                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11c4f7710>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(results.t, \n",
    "         results.y.flatten(),\n",
    "         label=\"approx\",\n",
    "        )\n",
    "\n",
    "plt.plot(results.t,\n",
    "         np.exp(results.t),\n",
    "         label=\"exact\",\n",
    "         linestyle=\"dashed\",\n",
    "        )\n",
    "\n",
    "\n",
    "plt.legend(loc=\"best\")\n",
    "# plt.xlim(-5, 5)\n",
    "# plt.ylim(-10, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scipy also contains a bunch of useful things like:\n",
    "- special functions (`airy`, Bessel)\n",
    "- Fourier transforms\n",
    "- statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `pandas` and `DataFrames`\n",
    "\n",
    "`pandas` is great for reading in, and exploring a number of different types of datasets. It's still based on `numpy.array`s, but adds a lot more usability\n",
    "\n",
    "They also have a nice set of getting started guides:\n",
    " - [10 Minutes to Pandas](https://pandas.pydata.org/pandas-docs/stable/10min.html)\n",
    " - [Comparison with R / R libraries](https://pandas.pydata.org/pandas-docs/stable/comparison_with_r.html)\n",
    " - [Comparison to SQL](https://pandas.pydata.org/pandas-docs/stable/comparison_with_sql.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>number</th>\n",
       "      <th>orbital_period</th>\n",
       "      <th>mass</th>\n",
       "      <th>distance</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>269.300</td>\n",
       "      <td>7.10</td>\n",
       "      <td>77.40</td>\n",
       "      <td>2006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>874.774</td>\n",
       "      <td>2.21</td>\n",
       "      <td>56.95</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>763.000</td>\n",
       "      <td>2.60</td>\n",
       "      <td>19.84</td>\n",
       "      <td>2011</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>326.030</td>\n",
       "      <td>19.40</td>\n",
       "      <td>110.62</td>\n",
       "      <td>2007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>516.220</td>\n",
       "      <td>10.50</td>\n",
       "      <td>119.47</td>\n",
       "      <td>2009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>185.840</td>\n",
       "      <td>4.80</td>\n",
       "      <td>76.39</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>1773.400</td>\n",
       "      <td>4.64</td>\n",
       "      <td>18.15</td>\n",
       "      <td>2002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>798.500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>21.41</td>\n",
       "      <td>1996</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>1</td>\n",
       "      <td>993.300</td>\n",
       "      <td>10.30</td>\n",
       "      <td>73.10</td>\n",
       "      <td>2008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Radial Velocity</td>\n",
       "      <td>2</td>\n",
       "      <td>452.800</td>\n",
       "      <td>1.99</td>\n",
       "      <td>74.79</td>\n",
       "      <td>2010</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            method  number  orbital_period   mass  distance  year\n",
       "0  Radial Velocity       1         269.300   7.10     77.40  2006\n",
       "1  Radial Velocity       1         874.774   2.21     56.95  2008\n",
       "2  Radial Velocity       1         763.000   2.60     19.84  2011\n",
       "3  Radial Velocity       1         326.030  19.40    110.62  2007\n",
       "4  Radial Velocity       1         516.220  10.50    119.47  2009\n",
       "5  Radial Velocity       1         185.840   4.80     76.39  2008\n",
       "6  Radial Velocity       1        1773.400   4.64     18.15  2002\n",
       "7  Radial Velocity       1         798.500    NaN     21.41  1996\n",
       "8  Radial Velocity       1         993.300  10.30     73.10  2008\n",
       "9  Radial Velocity       2         452.800   1.99     74.79  2010"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_planets = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/planets.csv')\n",
    "print(type(df_planets))\n",
    "\n",
    "df_planets.head(10) # shows the top 10 rows of the dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>number</th>\n",
       "      <th>orbital_period</th>\n",
       "      <th>mass</th>\n",
       "      <th>distance</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>1035.000000</td>\n",
       "      <td>992.000000</td>\n",
       "      <td>513.000000</td>\n",
       "      <td>808.000000</td>\n",
       "      <td>1035.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.785507</td>\n",
       "      <td>2002.917596</td>\n",
       "      <td>2.638161</td>\n",
       "      <td>264.069282</td>\n",
       "      <td>2009.070531</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.240976</td>\n",
       "      <td>26014.728304</td>\n",
       "      <td>3.818617</td>\n",
       "      <td>733.116493</td>\n",
       "      <td>3.972567</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.090706</td>\n",
       "      <td>0.003600</td>\n",
       "      <td>1.350000</td>\n",
       "      <td>1989.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>5.442540</td>\n",
       "      <td>0.229000</td>\n",
       "      <td>32.560000</td>\n",
       "      <td>2007.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>39.979500</td>\n",
       "      <td>1.260000</td>\n",
       "      <td>55.250000</td>\n",
       "      <td>2010.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>2.000000</td>\n",
       "      <td>526.005000</td>\n",
       "      <td>3.040000</td>\n",
       "      <td>178.500000</td>\n",
       "      <td>2012.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>7.000000</td>\n",
       "      <td>730000.000000</td>\n",
       "      <td>25.000000</td>\n",
       "      <td>8500.000000</td>\n",
       "      <td>2014.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            number  orbital_period        mass     distance         year\n",
       "count  1035.000000      992.000000  513.000000   808.000000  1035.000000\n",
       "mean      1.785507     2002.917596    2.638161   264.069282  2009.070531\n",
       "std       1.240976    26014.728304    3.818617   733.116493     3.972567\n",
       "min       1.000000        0.090706    0.003600     1.350000  1989.000000\n",
       "25%       1.000000        5.442540    0.229000    32.560000  2007.000000\n",
       "50%       1.000000       39.979500    1.260000    55.250000  2010.000000\n",
       "75%       2.000000      526.005000    3.040000   178.500000  2012.000000\n",
       "max       7.000000   730000.000000   25.000000  8500.000000  2014.000000"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_planets.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>number</th>\n",
       "      <th>orbital_period</th>\n",
       "      <th>mass</th>\n",
       "      <th>distance</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>method</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Astrometry</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>631.180000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>17.875000</td>\n",
       "      <td>2011.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Eclipse Timing Variations</th>\n",
       "      <td>1.666667</td>\n",
       "      <td>4751.644444</td>\n",
       "      <td>5.125000</td>\n",
       "      <td>315.360000</td>\n",
       "      <td>2010.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Imaging</th>\n",
       "      <td>1.315789</td>\n",
       "      <td>118247.737500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>67.715937</td>\n",
       "      <td>2009.131579</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Microlensing</th>\n",
       "      <td>1.173913</td>\n",
       "      <td>3153.571429</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4144.000000</td>\n",
       "      <td>2009.782609</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Orbital Brightness Modulation</th>\n",
       "      <td>1.666667</td>\n",
       "      <td>0.709307</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1180.000000</td>\n",
       "      <td>2011.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Pulsar Timing</th>\n",
       "      <td>2.200000</td>\n",
       "      <td>7343.021201</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1200.000000</td>\n",
       "      <td>1998.400000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Pulsation Timing Variations</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1170.000000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2007.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Radial Velocity</th>\n",
       "      <td>1.721519</td>\n",
       "      <td>823.354680</td>\n",
       "      <td>2.630699</td>\n",
       "      <td>51.600208</td>\n",
       "      <td>2007.518987</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Transit</th>\n",
       "      <td>1.954660</td>\n",
       "      <td>21.102073</td>\n",
       "      <td>1.470000</td>\n",
       "      <td>599.298080</td>\n",
       "      <td>2011.236776</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Transit Timing Variations</th>\n",
       "      <td>2.250000</td>\n",
       "      <td>79.783500</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1104.333333</td>\n",
       "      <td>2012.500000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                 number  orbital_period      mass  \\\n",
       "method                                                              \n",
       "Astrometry                     1.000000      631.180000       NaN   \n",
       "Eclipse Timing Variations      1.666667     4751.644444  5.125000   \n",
       "Imaging                        1.315789   118247.737500       NaN   \n",
       "Microlensing                   1.173913     3153.571429       NaN   \n",
       "Orbital Brightness Modulation  1.666667        0.709307       NaN   \n",
       "Pulsar Timing                  2.200000     7343.021201       NaN   \n",
       "Pulsation Timing Variations    1.000000     1170.000000       NaN   \n",
       "Radial Velocity                1.721519      823.354680  2.630699   \n",
       "Transit                        1.954660       21.102073  1.470000   \n",
       "Transit Timing Variations      2.250000       79.783500       NaN   \n",
       "\n",
       "                                  distance         year  \n",
       "method                                                   \n",
       "Astrometry                       17.875000  2011.500000  \n",
       "Eclipse Timing Variations       315.360000  2010.000000  \n",
       "Imaging                          67.715937  2009.131579  \n",
       "Microlensing                   4144.000000  2009.782609  \n",
       "Orbital Brightness Modulation  1180.000000  2011.666667  \n",
       "Pulsar Timing                  1200.000000  1998.400000  \n",
       "Pulsation Timing Variations            NaN  2007.000000  \n",
       "Radial Velocity                  51.600208  2007.518987  \n",
       "Transit                         599.298080  2011.236776  \n",
       "Transit Timing Variations      1104.333333  2012.500000  "
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_mean_values = df_planets.groupby(\"method\") \\\n",
    "                           .mean()\n",
    "df_mean_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x152102d198>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# pandas also provides some simple wrappers to speed up some plotting:\n",
    "df_planets.plot(x=\"orbital_period\", y=\"mass\", \n",
    "                kind=\"scatter\", \n",
    "                loglog=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**More functionality**\n",
    "\n",
    "I won't show all the examples here, but other easy things I commonly use are:\n",
    "*   `df_1.join(df_2, how=\"outer\", ...)` \n",
    "*   `df_planets.drop_duplicates()`\n",
    "*  `pd.read_sql_table`\n",
    "* `pd.concat([df_1, df_2])`  - concatenate rows\n",
    "* `df.apply` (applies a function to each row or column)\n",
    "*  `df.pivot(...)` / `df.melt(...\n",
    ")`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `scikit-learn` for basic modelling\n",
    "\n",
    "Great. So we have a data in an easy-to-use structure (using `pandas`) and we use `matplotlib` to help with plotting during exploratory data analsysi.\n",
    "\n",
    "Now we want to start building basic models on the data. A good starting place is `scikit-learn` (or `sklearn`).  It includes some really easy interfaces to some pretty powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn\n",
    "import sklearn.model_selection\n",
    "\n",
    "# filter to only allow planets with mass and orbital period\n",
    "df_planets_filtered = df_planets[[\"mass\", \"orbital_period\"]]\n",
    "df_planets_filtered = df_planets_filtered.dropna(axis=0) # this is a built-in pandas.DataFrame function\n",
    "\n",
    "# split 75/25 training/testing\n",
    "df_planets_training, df_planets_testing = sklearn.model_selection.train_test_split(df_planets_filtered)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Model: mass = A * orbital_period + c\n",
    "\n",
    "All scikit learn models follow a simple structure (below) which makes it easy to swap/test out new models:\n",
    "```\n",
    "model = sklearn. ... .ModelName(...)\n",
    "model.fit(x, y)\n",
    "y_new = model.predict(x_new)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.linear_model\n",
    "\n",
    "model = sklearn.linear_model.LinearRegression(fit_intercept=True, \n",
    "                                              normalize=False)\n",
    "\n",
    "x_train = df_planets_training[\"orbital_period\"].values.reshape(-1, 1)\n",
    "y_train = df_planets_training[\"mass\"].values.reshape(-1, 1)\n",
    "\n",
    "model.fit(x_train, y_train)\n",
    "\n",
    "x_test = df_planets_testing[\"orbital_period\"].values.reshape(-1, 1)\n",
    "y_test = df_planets_testing[\"mass\"].values.reshape(-1, 1)\n",
    "\n",
    "y_predict = model.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a226e32e8>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = np.linspace(0, 2*10**4).reshape(-1, 1)\n",
    "ys = model.predict(xs)\n",
    "\n",
    "plt.plot(xs, ys, label=\"best fit\")\n",
    "plt.scatter(x_train, y_train, label=\"training\")\n",
    "# plt.scatter(x_test, y_test, label=\"testing\")\n",
    "\n",
    "plt.xlabel(\"orbital period\")\n",
    "plt.ylabel(\"mass\")\n",
    "\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1a226fdbe0>]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(y_test, y_predict)\n",
    "plt.xlabel(\"Actual\")\n",
    "plt.ylabel(\"Predicted\")\n",
    "\n",
    "plt.plot([0, 20], [0, 20],\n",
    "         linestyle=\"dashed\", color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay, so yes, it's a terrible model. This dataset doesn't include any great linear models. But you get the point that actually training and using a linear model is super easy with `scikit-learn`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.1"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}