General_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Python for Data\n",
    "\n",
    "## Useful Packages\n",
    "+ [`astropy`](http://www.astropy.org/): Includes functions for reading/writing data files (including `.fits`), cosmology calculations, astronomical constants and coordinate systems, image processing, and much more\n",
    "+ [`numpy`](http://www.numpy.org/): Adds ability to deal with multi-dimensional arrays and vectorized math functions\n",
    "+ [`scipy`](http://www.scipy.org/): Extends `numpy` by adding common scientific functions such as ODE integration, statistical analysis, linear algebra, and FFT\n",
    "+ [`matplotlib`](http://matplotlib.org/): A useful plotting package\n",
    "+ [`pandas`](https://pandas.pydata.org/): Package for dealing with data tables\n",
    "+ [`astroML`](http://www.astroml.org/): Common statistical analysis and machine learning tools used in astronomy\n",
    "+ [`scikit-learn`](http://scikit-learn.org/stable/): More machine learning tools written in python\n",
    "\n",
    "## Installing python\n",
    "The easiest way to install python on any OS is to use [anaconda python](https://www.continuum.io/downloads).  This will install a local version of python on your system so you don't need to worry about needing admin to install new packages.  Most of the packages listed above are installed by default with anaconda.  For this class we will be using python 3, and I recommend you use this version for you research (unless you have a very good reason to use python 2).\n",
    "\n",
    "### Note\n",
    "As of October 2019 python 2.7 is officially depreciated and will only receive security updates and in 2023 python 3.7 was officially depreciated as well.  Many of the major packages listed above have already dropped python 2 support are are starting to drop support of python 3.7 and lower.\n",
    "\n",
    "## Text editors\n",
    "Although there are numerous IDEs (e.g. IDLE, Spyder) for python, for most everyday use you will likely be writing python code in a text editor and running your programs via the command line. In this case it is important to have a good text editor that supports syntax highlighting, live linting (syntax and style checking), and is easy to configure the way you want. I can highly recommend [VScode](https://code.visualstudio.com/) as a free text editor with all the features above.\n",
    "\n",
    "For python coding in VScode you will want to install the `Python` extension by Microsoft (you will be prompted to install it when you first open a .py file) and the `Jupyter` extension by Microsoft. Other useful extensions are the `Excel Viewer` extension for easier viewing CSV files, `open in browser` for and option to open HTML files in your browser, `MyST-Markdown` for rendering markdown files, and `Code Spell Checker` for basic spell checking.\n",
    "\n",
    "## Coding style\n",
    "What is a coding style?  Beyond the syntax of a coding language, a coding style is a set of conventions that can be followed to make it easier for other developers (including your future self) to read you code and to understand the intention behind your code.  For python coding the style most developers use has it basis in [PEP 8](https://peps.python.org/pep-0008/).\n",
    "\n",
    ">A style guide is about consistency. Consistency with this style guide is important. Consistency within a project is more important. Consistency within one module or function is the most important.\n",
    ">\n",
    ">However, know when to be inconsistent – sometimes style guide recommendations just aren’t applicable. When in doubt, use your best judgment. Look at other examples and decide what looks best. And don’t hesitate to ask!\n",
    "\n",
    "Here are some examples of PEP 8 conventions:\n",
    "\n",
    "- Use 4 spaces to indent lines (rather than a tab)\n",
    "- A max line limit of 79 characters (preferred by people who use command line editors, I typically override this to be higher)\n",
    "- Constants are defined at the module level with names in `ALL_CAPS`\n",
    "- Class names should normally use the `CapWords` convention\n",
    "- Function names should be `lowercase`, with words separated by underscores as necessary to improve readability\n",
    "\n",
    "## Basic syntax examples\n",
    "For a general overview of python's syntax head over to [codecademy](https://www.codecademy.com/learn/python) and take their interactive tutorial.  In this class we will only be covering what is necessary for data analysis.\n",
    "\n",
    "### importing packages\n",
    "Any package or code from another `.py` file can be imported with a simple `import` statement.  By default all imported code has its own name space, so you don't have to worry about overwriting existing functions.  The final line of this code block is a \"magic\" `Jupyter` function needed to make interactive plots inside of `Jupyter notebooks`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### data containers\n",
    "Data inside of python can be stored in several different types of containers.  The most basic ones are:\n",
    "\n",
    "+ `list`: an indexed data structure that can hold any objects as an element\n",
    "+ `tuple`: same as a `list` except the data is immutable\n",
    "+ `dictionary`: objects stored as a `{key: value}` set (note: any immutable object can be used as a key including a tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_list = [1, 2, 3]\n",
    "example_tuple = (1, 2, 3)\n",
    "example_dict = {'key1': 1, 'key2': 2, ('key', 3): 3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elements in these objects can be accessed using an zero-based index (`list` and `tuple`) or key (`dict`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3\n",
      "2\n",
      "1 3\n"
     ]
    }
   ],
   "source": [
    "print(example_list[0], example_list[-1])\n",
    "print(example_tuple[1])\n",
    "print(example_dict['key1'], example_dict[('key', 3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each of these objects have various methods that can be called on them to do various things.  To learn what methods can be called you can look at the python documentation (e.g. https://docs.python.org/3/tutorial/datastructures.html) or you can inspect the object directly and use python's `help` function to get the doc string.\n",
    "\n",
    "Note: Methods that start with `__` or `_` are private methods that are not designed to be called directly on the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n",
      "\n",
      "\n",
      "\n",
      "Help on built-in function pop:\n",
      "\n",
      "pop(index=-1, /) method of builtins.list instance\n",
      "    Remove and return item at index (default last).\n",
      "    \n",
      "    Raises IndexError if list is empty or index is out of range.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(dir(example_list))\n",
    "print('\\n\\n')\n",
    "help(example_list.pop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing lists\n",
    "Many times it is useful to slice and manipulate lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2]\n",
      "[3, 4, 5, 6]\n",
      "[7, 8, 9]\n",
      "[7, 8, 9]\n",
      "[0, 2, 4, 6, 8]\n",
      "[1, 3, 5, 7, 9]\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "print(a)\n",
    "# print the first 3 elements\n",
    "print(a[:3])\n",
    "# print the middle 4 elements\n",
    "print(a[3:7])\n",
    "# print the last 3 elements\n",
    "print(a[7:])\n",
    "# you can also use neg index\n",
    "print(a[-3:])\n",
    "# print only even index\n",
    "print(a[::2])\n",
    "# print only odd index\n",
    "print(a[1::2])\n",
    "# print the reverse list\n",
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping over `list`s and `dict`s\n",
    "There are several ways to loop over a `list` or `dict` depending on what values you want access to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "=========\n",
      "0: 1\n",
      "1: 2\n",
      "2: 3\n",
      "=========\n",
      "key1\n",
      "key2\n",
      "('key', 3)\n",
      "=========\n",
      "1\n",
      "2\n",
      "3\n",
      "=========\n",
      "key1: 1\n",
      "key2: 2\n",
      "('key', 3): 3\n"
     ]
    }
   ],
   "source": [
    "# loop over values in a list\n",
    "for i in example_list:\n",
    "    print(i)\n",
    "print('=========')\n",
    "\n",
    "# loop over values in a list with index\n",
    "for idx, i in enumerate(example_list):\n",
    "    # print('{0}: {1}'.format(idx, i))\n",
    "    print(f'{idx}: {i}')\n",
    "print('=========')\n",
    "\n",
    "# loop over keys in dict\n",
    "for i in example_dict:\n",
    "    print(i)\n",
    "print('=========')\n",
    "\n",
    "# loop over values in dict\n",
    "for i in example_dict.values():\n",
    "    print(i)\n",
    "print('=========')\n",
    "\n",
    "# loop over keys and values in dict\n",
    "for key, value in example_dict.items():\n",
    "    # print('{0}: {1}'.format(key, value))\n",
    "    print(f'{key}: {value}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list/dict comprehension\n",
    "If you need to make a `list` or `dict` as the result of a loop you can use comprehension. **Note** comprehension is faster than a normal loop since the iteration uses the `map` function that is compiled in `C`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "{'key0': 0, 'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5, 'key6': 6, 'key7': 7, 'key8': 8, 'key9': 9}\n"
     ]
    }
   ],
   "source": [
    "# slower method\n",
    "list_loop = []\n",
    "dict_loop = {}\n",
    "for i in a:\n",
    "    list_loop.append(i**2)\n",
    "    dict_loop[f'key{i}'] = i\n",
    "print(list_loop)\n",
    "print(dict_loop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "{'key0': 0, 'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5, 'key6': 6, 'key7': 7, 'key8': 8, 'key9': 9}\n"
     ]
    }
   ],
   "source": [
    "# faster method\n",
    "list_comp = [i**2 for i in a]\n",
    "dict_comp = {f'key{i}': i for i in a}\n",
    "print(list_comp)\n",
    "print(dict_comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing reusable code\n",
    "It is always best to keep your code DRY (don't repeat yourself).  If you find yourself writing the same block of code more than 2 times you should think about extracting it to a function.  If you need to create a custom object that has its own methods assigned to it you should create a custom class.\n",
    "\n",
    "### functions\n",
    "In python functions use a local name space, so don't worry about reusing variable names.  Only if a variable is not in the local name space will the function look to the global name space.  If the function argument is immutable it will be local in scope, otherwise it will not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "[2]\n",
      "[2]\n"
     ]
    }
   ],
   "source": [
    "def alpha(x):\n",
    "    x = x + 1\n",
    "    return x\n",
    "\n",
    "x = 1\n",
    "print(alpha(x))\n",
    "print(x)\n",
    "\n",
    "def beta(x):\n",
    "    x[0] = x[0] + 1\n",
    "    return x\n",
    "\n",
    "x = [1]\n",
    "print(beta(x))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### classes\n",
    "Classes are useful when you will have multiple instances of an object type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rectangle area: 2, position: [x: 0.0, y: 0.0]\n",
      "square area: 9, position: [x: 1.0, y: 1.0]\n",
      "circle area: 78.53981633974483, position: [x: 2.0, y: 2.0]\n"
     ]
    }
   ],
   "source": [
    "class Shape:\n",
    "    def __init__(self, x, y, cx=0.0, cy=0.0):\n",
    "        self.name = 'rectangle'\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.cx = cx\n",
    "        self.cy = cy\n",
    "\n",
    "    def area(self):\n",
    "        return self.x * self.y\n",
    "\n",
    "    def move(self, dx, dy):\n",
    "        self.cx += dx\n",
    "        self.cy += dy\n",
    "\n",
    "    def get_position(self):\n",
    "        return f'[x: {self.cx}, y: {self.cy}]'\n",
    "\n",
    "\n",
    "class Square(Shape):\n",
    "    def __init__(self, x, cx=0.0, cy=0.0):\n",
    "        self.name = 'square'\n",
    "        self.x = x\n",
    "        self.y = x\n",
    "        self.cx = cx\n",
    "        self.cy = cy\n",
    "\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, r, cx=0.0, cy=0.0):\n",
    "        self.name = 'circle'\n",
    "        self.r = r\n",
    "        self.cx = cx\n",
    "        self.cy = cy\n",
    "\n",
    "    def area(self):\n",
    "        '''Return the area of the circle'''\n",
    "        return np.pi * self.r**2\n",
    "\n",
    "shape_list = [Shape(1, 2), Square(3), Circle(5)]\n",
    "for sdx, s in enumerate(shape_list):\n",
    "    s.move(sdx, sdx)\n",
    "    print(f'{s.name} area: {s.area()}, position: {s.get_position()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As demonstrated before, you can show all the methods available to a class by using the `dir` function.  If a docstring is defined (triple quote comment on the first line of a function) it will be displayed if `help` is called on the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'area', 'get_position', 'move']\n",
      "\n",
      "\n",
      "\n",
      "Help on method area in module __main__:\n",
      "\n",
      "area() method of __main__.Circle instance\n",
      "    Return the area of the circle\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(dir(Circle))\n",
    "print('\\n\\n')\n",
    "print(help(shape_list[2].area))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `if __name__ == '__main__':`\n",
    "Sometimes you want a file to run a bit of code when called directly form the command line, but not call that code if it is imported into another file.  This can be done by checking the value of the global variable `__name__`, when a bit of code it directly run `__name__` will be `'__main__'`, when imported it will not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An example\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    # code that is only run when this file is directly called from the command line\n",
    "    # This is a good place to put example code for the functions and classes defined in the file\n",
    "    print('An example')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `with` blocks\n",
    "When working with objects that have `__enter__` and `__exit__` methods defined, you can use a `with` block to automatically call `__enter__` at the start and `__exit__` at the end.  A typical use case is automatically closing files after you are done reading/writing data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID,x,y,sy,sx,pxy\n",
      "\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "I/O operation on closed file.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[13], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdata.csv\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m file:\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;28mprint\u001b[39m(file\u001b[38;5;241m.\u001b[39mreadline())\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mfile\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreadline\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mValueError\u001b[0m: I/O operation on closed file."
     ]
    }
   ],
   "source": [
    "with open('data.csv', 'r') as file:\n",
    "    print(file.readline())\n",
    "    \n",
    "print(file.readline())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "NumPy extends Python to provide n-dimensional arrays along with a wealth of statistical and mathematical functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several ways to create arrays of a given size:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0. 0. 0.]\n",
      "  [0. 0. 0.]]\n",
      "\n",
      " [[0. 0. 0.]\n",
      "  [0. 0. 0.]]]\n",
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "zero = np.zeros((2, 2, 3))\n",
    "print(zero)\n",
    "one = np.ones((2, 4))\n",
    "print(one)\n",
    "empty = np.empty((3, 3))\n",
    "print(empty)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: empty fills the array with whatever happened to be in that bit of memory earlier!\n",
    "\n",
    "### Basic operations\n",
    "Arrays typically act element by element or try to cast the operations in \"obvious\" ways:\n",
    "\n",
    "![Array broadcasting](./images/array_broadcasting.png)\n",
    "\n",
    "-image ref: http://www.astroML.org"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "========\n",
      "[[ 2  4  6]\n",
      " [ 8 10 12]\n",
      " [14 16 18]]\n",
      "========\n",
      "[[ 3  6  9]\n",
      " [12 15 18]\n",
      " [21 24 27]]\n",
      "========\n",
      "[1 2 3]\n",
      "[[ 2  4  6]\n",
      " [ 5  7  9]\n",
      " [ 8 10 12]]\n",
      "========\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n",
      "[[ 2  3  4]\n",
      " [ 6  7  8]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "print(b)\n",
    "print('========')\n",
    "\n",
    "print (b + b)\n",
    "print('========')\n",
    "\n",
    "print (3 * b)\n",
    "print('========')\n",
    "\n",
    "d = np.array([1, 2, 3])\n",
    "print(d)\n",
    "print (b + d)\n",
    "print('========')\n",
    "\n",
    "e = np.array([[1], [2], [3]])\n",
    "print(e)\n",
    "print (b + e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods\n",
    "Arrays also have methods such as `sum()`, `min()`, `max()` and these also take axis arguments to operate just over one index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "[12 15 18]\n",
      "[ 6 15 24]\n"
     ]
    }
   ],
   "source": [
    "print(b.sum())\n",
    "print(b.sum(axis=0))\n",
    "print(b.sum(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slices\n",
    "Works the same as lists, just provide a slice for each dimension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n",
      "[[1 2]\n",
      " [4 5]\n",
      " [7 8]]\n",
      "[[3]\n",
      " [6]]\n"
     ]
    }
   ],
   "source": [
    "print(b[0, 0:2])\n",
    "print(b[:, 0:2])\n",
    "print(b[0:2, 2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating\n",
    "When using an array as an iterator it will loop over the first index of the array (e.g. for a 2d array it loops row-by-row).  Loop over the resulting object to loop over the second index, etc..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "1\n",
      "2\n",
      "3\n",
      "[4 5 6]\n",
      "4\n",
      "5\n",
      "6\n",
      "[7 8 9]\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for row in b:\n",
    "    print(row)\n",
    "    for col in row:\n",
    "        print(col)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Masking arrays\n",
    "Many times you want to find the values in an array to pass a particular condition (e.g. `B-V < 0.3`).  This can be done with array masks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False]\n",
      " [False  True  True]\n",
      " [ True  True  True]]\n",
      "[5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "mask = b >= 5\n",
    "print(mask)\n",
    "print(b[mask])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also combine multiple masks with the _bitwise_ comparison operators (`&`, `|`, `~`, `^`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True False False]]\n",
      "[5 6 7]\n",
      "[1 2 3 4 5 6 7 8 9]\n",
      "[1 2 3 4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "mask2 = b <= 7\n",
    "print(mask2)\n",
    "print(b[mask & mask2])\n",
    "print(b[mask | mask2])\n",
    "print(b[~mask | mask2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create masks based on parts of an array (e.g. the first column) and apply it to other parts of the array (e.g. the second column):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True False]\n",
      "[1 4]\n",
      "[2 5]\n",
      "[3 6]\n"
     ]
    }
   ],
   "source": [
    "mask3 = b[:, 0] <= 4\n",
    "print(mask3)\n",
    "print(b[:, 0][mask3])\n",
    "print(b[:, 1][mask3])\n",
    "print(b[:, 2][mask3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looking at source code\n",
    "`Numpy` also as a function that lets you take a look at source code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.source(plt.figure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Astropy\n",
    "The package is the magic that will make your astronomy code easier to write.  There are already functions for many of the things you would want to do, e.g. `.fits` reading/writing, data table reading/writing, sky coordinate transformations, cosmology calculations, and more.\n",
    "\n",
    "## Reading tables\n",
    "You won't want to type most data directly into your python code, instead you can use [`astropy.table`](http://docs.astropy.org/en/stable/io/unified.html) (see also: http://docs.astropy.org/en/stable/table/) to read the data in from a file.  The following data types are directly supported:\n",
    "\n",
    "+ fits\n",
    "+ ascii\n",
    "+ aastex\n",
    "+ basic\n",
    "+ cds\n",
    "+ daophot\n",
    "+ ecsv\n",
    "+ fixed_width\n",
    "+ html\n",
    "+ ipac\n",
    "+ latex\n",
    "+ rdb\n",
    "+ sextractor\n",
    "+ tab\n",
    "+ csv\n",
    "+ votable\n",
    "\n",
    "For other formats you can extend the existing `table` class to support it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.1\n"
     ]
    }
   ],
   "source": [
    "import astropy\n",
    "print(astropy.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><i>Table length=20</i>\n",
       "<table id=\"table4851267712\" class=\"table-striped table-bordered table-condensed\">\n",
       "<thead><tr><th>ID</th><th>x</th><th>y</th><th>sy</th><th>sx</th><th>pxy</th></tr></thead>\n",
       "<thead><tr><th>int64</th><th>int64</th><th>int64</th><th>int64</th><th>int64</th><th>float64</th></tr></thead>\n",
       "<tr><td>1</td><td>201</td><td>592</td><td>61</td><td>9</td><td>-0.84</td></tr>\n",
       "<tr><td>2</td><td>244</td><td>401</td><td>25</td><td>4</td><td>0.31</td></tr>\n",
       "<tr><td>3</td><td>47</td><td>583</td><td>38</td><td>11</td><td>0.64</td></tr>\n",
       "<tr><td>4</td><td>287</td><td>402</td><td>15</td><td>7</td><td>-0.27</td></tr>\n",
       "<tr><td>5</td><td>203</td><td>495</td><td>21</td><td>5</td><td>-0.33</td></tr>\n",
       "<tr><td>6</td><td>58</td><td>173</td><td>15</td><td>9</td><td>0.67</td></tr>\n",
       "<tr><td>7</td><td>202</td><td>479</td><td>27</td><td>4</td><td>-0.02</td></tr>\n",
       "<tr><td>8</td><td>202</td><td>504</td><td>14</td><td>4</td><td>-0.05</td></tr>\n",
       "<tr><td>9</td><td>198</td><td>510</td><td>30</td><td>11</td><td>-0.84</td></tr>\n",
       "<tr><td>10</td><td>158</td><td>416</td><td>16</td><td>7</td><td>-0.69</td></tr>\n",
       "<tr><td>11</td><td>165</td><td>393</td><td>14</td><td>5</td><td>0.3</td></tr>\n",
       "<tr><td>12</td><td>201</td><td>442</td><td>25</td><td>5</td><td>-0.46</td></tr>\n",
       "<tr><td>13</td><td>157</td><td>317</td><td>52</td><td>5</td><td>-0.03</td></tr>\n",
       "<tr><td>14</td><td>131</td><td>311</td><td>16</td><td>6</td><td>0.5</td></tr>\n",
       "<tr><td>15</td><td>166</td><td>400</td><td>34</td><td>6</td><td>0.73</td></tr>\n",
       "<tr><td>16</td><td>160</td><td>337</td><td>31</td><td>5</td><td>-0.52</td></tr>\n",
       "<tr><td>17</td><td>186</td><td>423</td><td>42</td><td>9</td><td>0.9</td></tr>\n",
       "<tr><td>18</td><td>125</td><td>334</td><td>26</td><td>8</td><td>0.4</td></tr>\n",
       "<tr><td>19</td><td>218</td><td>533</td><td>16</td><td>6</td><td>-0.78</td></tr>\n",
       "<tr><td>20</td><td>146</td><td>344</td><td>22</td><td>5</td><td>-0.56</td></tr>\n",
       "</table></div>"
      ],
      "text/plain": [
       "<Table length=20>\n",
       "  ID    x     y     sy    sx    pxy  \n",
       "int64 int64 int64 int64 int64 float64\n",
       "----- ----- ----- ----- ----- -------\n",
       "    1   201   592    61     9   -0.84\n",
       "    2   244   401    25     4    0.31\n",
       "    3    47   583    38    11    0.64\n",
       "    4   287   402    15     7   -0.27\n",
       "    5   203   495    21     5   -0.33\n",
       "    6    58   173    15     9    0.67\n",
       "    7   202   479    27     4   -0.02\n",
       "    8   202   504    14     4   -0.05\n",
       "    9   198   510    30    11   -0.84\n",
       "   10   158   416    16     7   -0.69\n",
       "   11   165   393    14     5     0.3\n",
       "   12   201   442    25     5   -0.46\n",
       "   13   157   317    52     5   -0.03\n",
       "   14   131   311    16     6     0.5\n",
       "   15   166   400    34     6    0.73\n",
       "   16   160   337    31     5   -0.52\n",
       "   17   186   423    42     9     0.9\n",
       "   18   125   334    26     8     0.4\n",
       "   19   218   533    16     6   -0.78\n",
       "   20   146   344    22     5   -0.56"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Table length=20>\n",
      "name  dtype \n",
      "---- -------\n",
      "  ID   int64\n",
      "   x   int64\n",
      "   y   int64\n",
      "  sy   int64\n",
      "  sx   int64\n",
      " pxy float64\n",
      "\n",
      "['ID', 'x', 'y', 'sy', 'sx', 'pxy']\n"
     ]
    }
   ],
   "source": [
    "from astropy.table import Table\n",
    "t = Table.read('data.csv', format='ascii.csv')\n",
    "display(t)\n",
    "print(t.info)\n",
    "print(t.colnames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The columns of `t` can be accessed by name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ID  pxy \n",
      "--- -----\n",
      "  1 -0.84\n",
      "  2  0.31\n",
      "  3  0.64\n",
      "  4 -0.27\n",
      "  5 -0.33\n",
      "  6  0.67\n",
      "  7 -0.02\n",
      "  8 -0.05\n",
      "  9 -0.84\n",
      " 10 -0.69\n",
      " 11   0.3\n",
      " 12 -0.46\n",
      " 13 -0.03\n",
      " 14   0.5\n",
      " 15  0.73\n",
      " 16 -0.52\n",
      " 17   0.9\n",
      " 18   0.4\n",
      " 19 -0.78\n",
      " 20 -0.56\n"
     ]
    }
   ],
   "source": [
    "print(t['ID', 'pxy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And math can be applied:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        sx        \n",
      "------------------\n",
      " 61.66036003787198\n",
      "25.317977802344327\n",
      " 39.56008088970496\n",
      " 16.55294535724685\n",
      "21.587033144922902\n",
      "  17.4928556845359\n",
      "27.294688127912362\n",
      "14.560219778561036\n",
      "31.953090617340916\n",
      " 17.46424919657298\n",
      "14.866068747318506\n",
      "25.495097567963924\n",
      " 52.23983154643591\n",
      " 17.08800749063506\n",
      " 34.52535300326414\n",
      "31.400636936215164\n",
      " 42.95346318982906\n",
      "27.202941017470888\n",
      " 17.08800749063506\n",
      "22.561028345356956\n"
     ]
    }
   ],
   "source": [
    "print(np.sqrt(t['sx']**2 + t['sy']**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have multiple data tables you can also stack them (vertically or horizontally) or join them (see http://docs.astropy.org/en/stable/table/operations.html)\n",
    "\n",
    "## Constants and Units\n",
    "Many of the constants you would need can be found in [`astropy.constants`](http://docs.astropy.org/en/stable/constants/).  You can also assign units to your values using [`astropy.units`](http://docs.astropy.org/en/stable/units/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Name   = Speed of light in vacuum\n",
      "  Value  = 299792458.0\n",
      "  Uncertainty  = 0.0\n",
      "  Unit  = m / s\n",
      "  Reference = CODATA 2018\n"
     ]
    }
   ],
   "source": [
    "from astropy import constants as const\n",
    "print(const.c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000. 2000. 3000.] nm\n",
      "[1.e-06 2.e-06 3.e-06] m\n",
      "[2.99792458e+14 1.49896229e+14 9.99308193e+13] Hz\n",
      "[-149896.229       0.     149896.229] km / s\n"
     ]
    }
   ],
   "source": [
    "from astropy import units as u\n",
    "wavelength = [1000.0, 2000.0, 3000.0] * u.nm\n",
    "print(wavelength)\n",
    "# convert to meters\n",
    "print(wavelength.to(u.m))\n",
    "# convert to frequncy\n",
    "freq = wavelength.to(u.Hz, equivalencies=u.spectral())\n",
    "print(freq)\n",
    "# convert to velocity from a rest wavelength of 2000 nm\n",
    "freq_to_vel = u.doppler_optical(2000 * u.nm)\n",
    "vel = freq.to(u.km / u.s, equivalencies=freq_to_vel)\n",
    "print(vel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas\n",
    "\n",
    "Data tables can also be read in with pandas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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>ID</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>sy</th>\n",
       "      <th>sx</th>\n",
       "      <th>pxy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>201</td>\n",
       "      <td>592</td>\n",
       "      <td>61</td>\n",
       "      <td>9</td>\n",
       "      <td>-0.84</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>244</td>\n",
       "      <td>401</td>\n",
       "      <td>25</td>\n",
       "      <td>4</td>\n",
       "      <td>0.31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>47</td>\n",
       "      <td>583</td>\n",
       "      <td>38</td>\n",
       "      <td>11</td>\n",
       "      <td>0.64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>287</td>\n",
       "      <td>402</td>\n",
       "      <td>15</td>\n",
       "      <td>7</td>\n",
       "      <td>-0.27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>203</td>\n",
       "      <td>495</td>\n",
       "      <td>21</td>\n",
       "      <td>5</td>\n",
       "      <td>-0.33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>58</td>\n",
       "      <td>173</td>\n",
       "      <td>15</td>\n",
       "      <td>9</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>202</td>\n",
       "      <td>479</td>\n",
       "      <td>27</td>\n",
       "      <td>4</td>\n",
       "      <td>-0.02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8</td>\n",
       "      <td>202</td>\n",
       "      <td>504</td>\n",
       "      <td>14</td>\n",
       "      <td>4</td>\n",
       "      <td>-0.05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9</td>\n",
       "      <td>198</td>\n",
       "      <td>510</td>\n",
       "      <td>30</td>\n",
       "      <td>11</td>\n",
       "      <td>-0.84</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10</td>\n",
       "      <td>158</td>\n",
       "      <td>416</td>\n",
       "      <td>16</td>\n",
       "      <td>7</td>\n",
       "      <td>-0.69</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>11</td>\n",
       "      <td>165</td>\n",
       "      <td>393</td>\n",
       "      <td>14</td>\n",
       "      <td>5</td>\n",
       "      <td>0.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>12</td>\n",
       "      <td>201</td>\n",
       "      <td>442</td>\n",
       "      <td>25</td>\n",
       "      <td>5</td>\n",
       "      <td>-0.46</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>13</td>\n",
       "      <td>157</td>\n",
       "      <td>317</td>\n",
       "      <td>52</td>\n",
       "      <td>5</td>\n",
       "      <td>-0.03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>14</td>\n",
       "      <td>131</td>\n",
       "      <td>311</td>\n",
       "      <td>16</td>\n",
       "      <td>6</td>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>15</td>\n",
       "      <td>166</td>\n",
       "      <td>400</td>\n",
       "      <td>34</td>\n",
       "      <td>6</td>\n",
       "      <td>0.73</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>16</td>\n",
       "      <td>160</td>\n",
       "      <td>337</td>\n",
       "      <td>31</td>\n",
       "      <td>5</td>\n",
       "      <td>-0.52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>17</td>\n",
       "      <td>186</td>\n",
       "      <td>423</td>\n",
       "      <td>42</td>\n",
       "      <td>9</td>\n",
       "      <td>0.90</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>18</td>\n",
       "      <td>125</td>\n",
       "      <td>334</td>\n",
       "      <td>26</td>\n",
       "      <td>8</td>\n",
       "      <td>0.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>19</td>\n",
       "      <td>218</td>\n",
       "      <td>533</td>\n",
       "      <td>16</td>\n",
       "      <td>6</td>\n",
       "      <td>-0.78</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>20</td>\n",
       "      <td>146</td>\n",
       "      <td>344</td>\n",
       "      <td>22</td>\n",
       "      <td>5</td>\n",
       "      <td>-0.56</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    ID    x    y  sy  sx   pxy\n",
       "0    1  201  592  61   9 -0.84\n",
       "1    2  244  401  25   4  0.31\n",
       "2    3   47  583  38  11  0.64\n",
       "3    4  287  402  15   7 -0.27\n",
       "4    5  203  495  21   5 -0.33\n",
       "5    6   58  173  15   9  0.67\n",
       "6    7  202  479  27   4 -0.02\n",
       "7    8  202  504  14   4 -0.05\n",
       "8    9  198  510  30  11 -0.84\n",
       "9   10  158  416  16   7 -0.69\n",
       "10  11  165  393  14   5  0.30\n",
       "11  12  201  442  25   5 -0.46\n",
       "12  13  157  317  52   5 -0.03\n",
       "13  14  131  311  16   6  0.50\n",
       "14  15  166  400  34   6  0.73\n",
       "15  16  160  337  31   5 -0.52\n",
       "16  17  186  423  42   9  0.90\n",
       "17  18  125  334  26   8  0.40\n",
       "18  19  218  533  16   6 -0.78\n",
       "19  20  146  344  22   5 -0.56"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['ID', 'x', 'y', 'sy', 'sx', 'pxy'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import pandas\n",
    "data = pandas.read_csv('data.csv')\n",
    "display(data)\n",
    "print(data.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The columns can be accessed with 'dot' notation or name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     201\n",
      "1     244\n",
      "2      47\n",
      "3     287\n",
      "4     203\n",
      "5      58\n",
      "6     202\n",
      "7     202\n",
      "8     198\n",
      "9     158\n",
      "10    165\n",
      "11    201\n",
      "12    157\n",
      "13    131\n",
      "14    166\n",
      "15    160\n",
      "16    186\n",
      "17    125\n",
      "18    218\n",
      "19    146\n",
      "Name: x, dtype: int64\n",
      "      x    y\n",
      "0   201  592\n",
      "1   244  401\n",
      "2    47  583\n",
      "3   287  402\n",
      "4   203  495\n",
      "5    58  173\n",
      "6   202  479\n",
      "7   202  504\n",
      "8   198  510\n",
      "9   158  416\n",
      "10  165  393\n",
      "11  201  442\n",
      "12  157  317\n",
      "13  131  311\n",
      "14  166  400\n",
      "15  160  337\n",
      "16  186  423\n",
      "17  125  334\n",
      "18  218  533\n",
      "19  146  344\n"
     ]
    }
   ],
   "source": [
    "print(data.x)\n",
    "print(data[['x', 'y']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before math can be done directly on the columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0     61.660360\n",
      "1     25.317978\n",
      "2     39.560081\n",
      "3     16.552945\n",
      "4     21.587033\n",
      "5     17.492856\n",
      "6     27.294688\n",
      "7     14.560220\n",
      "8     31.953091\n",
      "9     17.464249\n",
      "10    14.866069\n",
      "11    25.495098\n",
      "12    52.239832\n",
      "13    17.088007\n",
      "14    34.525353\n",
      "15    31.400637\n",
      "16    42.953463\n",
      "17    27.202941\n",
      "18    17.088007\n",
      "19    22.561028\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "print(np.sqrt(data.sx**2 + data.sy**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas teats these `DataFrames` like databases, so most database operations (e.g. join, merge, groupby, etc...) can be done on a data table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "lensing",
   "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.10.9"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}