01 - Preparing To Dive Into Astropy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing to Dive Into Astropy\n",
    "\n",
    "__Author: Kaustubh Vaghmare__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Astropy?\n",
    "\n",
    "Astropy is a third party Python module designed to be like a swiss army knife for common programming needs of Astronomers. Since it is a third party package, it needs to be installed.\n",
    "\n",
    "If you are using the full Anaconda distribution of Python, it is already available. If you are using an alternate distribution, you can install it by either saying,\n",
    "\n",
    "    pip install astropy\n",
    "   \n",
    "or\n",
    "\n",
    "    conda install astropy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Features of Astropy\n",
    "\n",
    "Astropy has several features present in it. Let us summarize some of them.\n",
    "\n",
    "- Support for typical I/O operations - FITS files, tables, VO etc.\n",
    "- Support for basic quantities, astronomical coordinates.\n",
    "- Statistics and Modeling\n",
    "- Cosmological Calculations\n",
    "- Other utilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Astropy Affiliated Packages\n",
    "\n",
    "Astropy is both the Python module as well as the community. And within the community, there exist a lot of other independently made packages. However, these packages strive to be consistent with the overall organizational theme of Astropy. These packages are called the Astropy Affiliated packages.\n",
    "\n",
    "Some of the packages include:\n",
    "\n",
    "- ccdproc (for CCD data processing)\n",
    "- photutils (for performing photometry using a variety of source detection and photometry algorithms)\n",
    "- specutils (for spectroscopic analyses)\n",
    "- astroquery (for querying commonly used astronomical data archives)\n",
    "- and many many more.\n",
    "\n",
    "For a full list of all packages, please visit: https://www.astropy.org/affiliated/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Useful Links\n",
    "\n",
    "Truth be told, there is very little to 'learn' per se when it comes to Astropy. There are some basic concepts for complete newcomers to Astronomy but beyond that, it is all about navigating the documentation and finding which sub-mobule of Astropy and which corresponding function best solves the problem you are trying to solve.\n",
    "\n",
    "To that effect, here are some useful links to make note of.\n",
    "\n",
    "- The full user documentation (https://docs.astropy.org/en/stable/)\n",
    "- A collection of tutorials for a variety of tasks. (http://learn.astropy.org/tutorials.html)\n",
    "- A compilation of example code snippets. (https://docs.astropy.org/en/stable/generated/examples/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Minimal Python Know How\n",
    "\n",
    "To successfully use Astropy it is very important to be aware of basic Python programming concepts. This includes\n",
    "\n",
    "- all the basic Python syntax (if, for, while etc.)\n",
    "- basic input and output\n",
    "- the data structures (lists, dictionaries etc.)\n",
    "- Some basic concepts of Object Oriented Programming.\n",
    "- Basic error catching (try / except)\n",
    "\n",
    "Behind the scenes, a lot of the astropy routines use other packages and the data structures provided by these packages. It is thus important for one to know\n",
    "\n",
    "- Numpy arrays\n",
    "- Pandas dataframes\n",
    "- Plotting librares (matplotlib basics, optionally seaborn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object Oriented Programming Basics\n",
    "\n",
    "Consider some objects - for eg. a Ferrari, a Lamborghini, a McLarenF1 etc.\n",
    "\n",
    "All these objects are unique.\n",
    "\n",
    "- They have a different color.\n",
    "- A different build.\n",
    "- A different engine power.\n",
    "- etc.\n",
    "\n",
    "But also, these objects have commonalities.\n",
    "\n",
    "- They all exhibit properties such as color, build, engine power etc.\n",
    "- They provide common functions such as 'changing a gear', 'pressing the accelerator', 'braking' and more.\n",
    "\n",
    "In computer programming, we often come across problems or codes whre it is needed that we work with objects which are unique in their own way but share common behavior. An effective way to write code where problems can be expressed an object interactions with this kind of behavior is Object Oriented Programming.\n",
    "\n",
    "__Enter the \"Class\"__\n",
    "\n",
    "A class describes\n",
    "\n",
    "- the common properties that objects of the given class possess\n",
    "- the methods or functions that can be performed on these objects.\n",
    "\n",
    "Once a class is in place, we can create many objects of that class. What will change from object to object, are its individual properties and what will remain common across the objects is some of the features coded in the class.\n",
    "\n",
    "__And You Have Been using OOP All Along!__\n",
    "\n",
    "Yes! For example. consider the following simple code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = \"Hello\"\n",
    "s2 = \"World\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'WORLD'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at another series of statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = {'a': 1, 'b': 2}\n",
    "d2 = {'c': True, 'd': [1,2,3]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['a', 'b'])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['c', 'd'])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2['c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you connect this with OOP?\n",
    "\n",
    "When we created the two strings 's1' and 's2', what we were actually doing is creating two objects of class 'String'.\n",
    "\n",
    "- Each string was unique, it was a different collection and order of characters.\n",
    "- But yet they had common behavior - you could `.upper()` on them, you could access their elements using `[-1]` syntax and so on.\n",
    "\n",
    "Same is the case with dictionaries. 'd1' and 'd2' are completely unique dictionaries but they exhibit a common behavior and structure.\n",
    "\n",
    "The behavior for String objects is defined in something known as the 'String' class and the behavior for the dictionaries is defined in a 'Dictionary' class.\n",
    "\n",
    "__But why all this?__\n",
    "\n",
    "Because creating objects of different kinds is a common pattern in many Astropy utilities. The way an object is created is something like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = dict()\n",
    "d1['a'] = 'Hello'\n",
    "d1['b'] = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use `dict()` to get a dictionary object and then changed the properties of the dictionary elements. This is call 'instantiation'.\n",
    "\n",
    "The general syntax is\n",
    "\n",
    "    obj = Class(prop1, prop2...)\n",
    "    \n",
    "where prop1, prop2 etc. can can optional or compulsory depending on how the class is designed.\n",
    "\n",
    "When we want to make a FITS file, for example, we will create an object of a corresponding class. When we want to create a search routine, we define the properties of how it should conducts its search for celestial objects and create it from a search routine class. When we want to define a new quantity, we use the Quantity class and supply necessary properties, when we want to work with Cosmological models, we define an object of some Cosmology class and so on.\n",
    "\n",
    "It is for this reason, it is worthwhile for us to remind ourselves these basics of Class and Object concepts in Python."
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}