Tutorial_01/Intro_to_Python-Solved.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "We thank Vedant Shenoy and Soham Purohit for their contributions towards making this Assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is one of the most widely used programming languages ([source](https://octoverse.github.com/#top-languages)), and for a reason. It is very easy to pick-up, extremely versatile (as you will see) and most importantly well supported.\n",
    "\n",
    "Our focus through these tutorials is not just to learn Python however. We are here to learn [Astro](https://cdn130.picsart.com/283094903006201.jpg?type=webp&to=min&r=640). So, each tutorial will introduce a new concept, important in scientific computing, along with an application in Astronomy and Astrophysics.\n",
    "\n",
    "Some more great resources:\n",
    "1. [The Python Wiki](https://wiki.python.org/moin/)\n",
    "2. [SciPy lecture notes](http://scipy-lectures.org/)\n",
    "3. [SciPy reference](https://docs.scipy.org/doc/scipy/reference/)\n",
    "4. [AstroPy Documentation](https://docs.astropy.org/en/stable/) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note: This is meant to be an intensive 2 week long tutorial session. However, you are free to go ahead at your own pace. The tutorials will always be available at [github.com/krittikaiitb/tutorials](https://github.com/krittikaiitb/tutorials) and you can learn at your own time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Another Note** (I like notes): If you feel, at any point that you don't understand something, take a moment, relax and Google! The internet is your best friend when it comes to programming, and becoming self sufficient in your coding requires you to know how to google. So, don't worry if things feel a bit new; with some practice and a bit of tinkering around (you can do that in this environment very easily!), you will soon be ready to rumble..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### By the end of this tutorial, you will have been introduced to Python, and parsed a file to find how many moons each planet has!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our first task on Python?\n",
    "Hello World!<br>\n",
    "(Note the [escape character](http://python-ds.com/python-3-escape-sequences))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first thing we shall do is say\n",
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"The first thing we shall do is say\\nHello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print is a function (more on that later) that takes a string (that is the stuff enclosed in the double quotes) and displays it. <br>\n",
    "Of course, we can go quite crazy with just this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World \n",
      "\n",
      "Hello World\n",
      "\n",
      "Hello 'World'\n",
      "\n",
      "\"Hello\" World\n",
      "\n",
      "'Hello' \"World\" \n",
      "\n",
      "Hello\n",
      "World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\",\"World \\n\") # Python already puts a newline after each print(...) by default (this can be changed)\n",
    "print('Hello World\\n')    # BTW, this is how you comment :P\n",
    "print(\"Hello 'World'\\n\")\n",
    "print('\"Hello\" World\\n')\n",
    "print(\"'Hello' \\\"World\\\" \\n\")\n",
    "print('''Hello\n",
    "World''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With a bit of [string formatting](https://docs.python.org/3/library/string.html#format-string-syntax), you can make your print statements as customizable as you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is Krittika\n",
      "Hello, my name is Krittika\n",
      "Hello, my name is Krittika\n"
     ]
    }
   ],
   "source": [
    "name = \"Krittika\"\n",
    "print(\"Hello, my name is %s\"% name)\n",
    "print(\"Hello, my name is {}\".format(name))\n",
    "print(f\"Hello, my name is {name}\") # Will only work in Python 3.6+"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And in that cell, we went ahead of ourselves a bit. What was that first line?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Krittika, The Astronomy Club of IIT Bombay\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are assigning a value (which is the string above) to a variable.<br>\n",
    "Of course, strings aren't all we can assign to variables. There are different data types in Python, which you can explore below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "integer = 1\n",
    "floating_point = 3.14\n",
    "complex_number = 3 + 4j\n",
    "boolean_variable = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "print(f'{type(complex_number)}') # Try to re-write this with .format() instead"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use Python as a calculator!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a+b = 3\n",
      "a-b = -1\n",
      "a*b = 2\n",
      "a/b = 0.5\n",
      "a//b = 0\n",
      "a//b = 0\n",
      "a**b = 1\n"
     ]
    }
   ],
   "source": [
    "a = 1 # Explore with different values of a and b. Try using a complex number!\n",
    "b = 2 # Try using a string!\n",
    "print(\"a+b = {}\".format(a+b))\n",
    "print(\"a-b = {}\".format(a-b))\n",
    "print(\"a*b = {}\".format(a*b))\n",
    "print(\"a/b = {}\".format(a/b))\n",
    "print(\"a//b = {}\".format(a//b))\n",
    "print(\"a//b = {}\".format(a//b))\n",
    "print(\"a**b = {}\".format(a**b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have an idea of how to store a value now, and basic ways of manipulating it. However, what if we need to store many values?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples ()\n",
    "Sequence of values (which can be of mixed types) which are immutable(can't change it), written within parantheses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1=('a','b','c','d','e','f','g','h',1,2,3,4,5,6,7,8,9,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the elements, use the indices (starting from zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very useful trick is index slicing, where you can access a subset of the tuple. This works as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('e', 'f', 'g', 'h', 1)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[4:9] # [inclusive:exclusive]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The full syntax for index slicing is \\[inclusive_start:exclusive_end:step_size\\], so you can get something like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('c', 'e', 'g', 1, 3, 5, 7)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[2:15:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you leave inclusive_start or exclusive_end blank, then that is saying slice from the beginning, or till the end respectively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 'c', 'e', 'g', 1, 3)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[:12:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('f', 1, 4, 7, 10)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[5::3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Count backwards using negative indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index slicing works with negative indices too!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists []\n",
    "Lists are mutable. Otherwise, they have similar properties to a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_list=[[1,2,3],['a','b','c'],['astro','cosmo','gravity']] # You can also have nested tuples!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nested lists are essentially [lists within lists](https://en.wikipedia.org/wiki/Inception). Nested lists will feature a good deal in our tutorials later, so this is important. \n",
    "\n",
    "Nested lists (or tuples) have more than one index, which can be used as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['astro', 'cosmo', 'gravity']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nested_list[:][2] # Play around with this!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With a list, you can change entries, append new ones, or delete some"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['astro', 3.26, 2, 3, 'cosmo']\n"
     ]
    }
   ],
   "source": [
    "my_list=['astro',1,2,3,'cosmo']\n",
    "my_list[1]=3.26\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['astro', 3.26, 2, 3, 'cosmo', ['gravity', 'relativity']]\n"
     ]
    }
   ],
   "source": [
    "my_list.append(['gravity','relativity']) # This will be important later!\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['astro', 'cosmo', ['gravity', 'relativity']]\n"
     ]
    }
   ],
   "source": [
    "del my_list[1:4]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['astro', ['gravity', 'relativity']]\n"
     ]
    }
   ],
   "source": [
    "my_list.remove('cosmo')\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One more function, which works on any kind of collection data type (tuples, list, dictionaries ...) is `len`, which gives the length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(len(my_list)) # Note that the list inside the list is counted as one element."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a lot of operations on lists. One resource you can use to find out more is [this](https://www.geeksforgeeks.org/python-list/). Again, Google is your best friend!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A note on Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have seen strings before. They are, in a way, similar to tuples, where you can access each individual element (in this case the characters of the strings) using the indices; you can also use index slicing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Krittika: The Astronomy Club of IITB\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Krittika\n"
     ]
    }
   ],
   "source": [
    "# Try to get any substring that you want using index slicing\n",
    "print(my_string[:8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are also a few operations on strings, which we will list down below. You are not expected to memorize them. It takes time and experience in coding to be able to remember them, and even then you will still find yourself having to look up things. That is completely fine. \n",
    "\n",
    "You can find a whole list of these in the official Python documentation (https://docs.python.org/3.6/library/string.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Krittika:', 'The', 'Astronomy', 'Club', 'of', 'IITB']\n"
     ]
    }
   ],
   "source": [
    "print(my_string.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Krittika', ' The Astronomy Club of IITB']\n"
     ]
    }
   ],
   "source": [
    "print(my_string.split(':')) #Try putting in another character or a string and see how the output changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "string_with_spaces = \"   Why are there spaces here?   \" # Let's get rid of those spaces in 2 ways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Why', 'are', 'there', 'spaces', 'here?']\n"
     ]
    }
   ],
   "source": [
    "# Split using white space:\n",
    "list_of_words = string_with_spaces.split()\n",
    "print(list_of_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Why are there spaces here?'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a string, by joining the items of the list\n",
    "string_without_spaces = ' '.join(list_of_words) # what happens if you use '&' instead of ' '?\n",
    "string_without_spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Why are there spaces here?'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or, you can just use another function\n",
    "string_with_spaces.strip() # What if you use something like string.split(<some_string>)? It will remove that from the beginning and ending!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries {}\n",
    "Instead of indexing by strictly numbers from 0 to `len`-1, we can index a _value_ with any _key_ as long as the _key_ is immutable (can be a tuple)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dictionary = {'Phobos':'Mars', 'Ganymede':'Jupiter', 'Titan':'Saturn', 'Titania':'Uranus', 'Triton':'Neptune'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The largest moon of Mars is Phobos\n"
     ]
    }
   ],
   "source": [
    "moon = 'Phobos'\n",
    "print(f'The largest moon of {my_dictionary[moon]} is {moon}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "There are of course, a lot more to know about each of these. But this will be sufficient for this tutorial. With practice and experience, you will learn more and more about lists, tuples, dictionaries and sets(wait, what's that?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditionals in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Control flow statements like loops and conditionals have blocks indicated by indentation. Any number of whitespaces is syntactically correct as long as it is consistent within a block.\n",
    "\n",
    "The `if...elif...if` statement can be used to run different blocks based on truth values of boolean expressions.\n",
    "\n",
    "Wooo. Those were all certainly words. What this means is this:\n",
    "1. You can choose to run certain statements based on whether some condition is satisfied or not: conditionals\n",
    "2. You can run the same set of statements (perhaps with some changes) several times (this is called iteration): loops (imaginative names, I know)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Play around with these cells and see for yourself how this will work. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i am in the elif block\n",
      "5 is equal to 5\n"
     ]
    }
   ],
   "source": [
    "a=5\n",
    "if a<5:\n",
    "    print(\"i am in the if block\")\n",
    "    print(a,\"is less than 5\")\n",
    "elif a==5:\n",
    "    print(\"i am in the elif block\")\n",
    "    print(a, \"is equal to 5\")\n",
    "else:\n",
    "    print(\"i am in the else block\")\n",
    "    print(a, \"i more than 5\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is between 7 and 9\n"
     ]
    }
   ],
   "source": [
    "b=8\n",
    "if  7 < b < 9:\n",
    "    print(\"b is between 7 and 9\")\n",
    "elif b < 7:\n",
    "    print(\"b is smaller than 7\")\n",
    "else:\n",
    "    print(\"b is greater than 9\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical operations `and`, `or`, and `not` can also be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "a=True\n",
    "b=False\n",
    "print(a and b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ellipsis"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Try to use a logical operation in an if..elif..else statement. Find if a given value c is less than 0, \n",
    "# greater than 10, or in between the two\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "There are two types of loops: `for` and `while`. \n",
    "\n",
    "The usage is very straightforward, but there are nuances to both of these that we will explore in detail later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in [1,2,3,4]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 "
     ]
    }
   ],
   "source": [
    "for i in range(0,10,2): # range gives you a range of numbers! range(inclusive_start, exclusive_end, step). Seems familiar?\n",
    "    print(i, end=' ') # Foreshadowing, you can change the default behaviour of print to add a newline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 16 9 4 1 "
     ]
    }
   ],
   "source": [
    "my_iter=5\n",
    "while my_iter > 0:\n",
    "    print(my_iter**2, end=' ')\n",
    "    my_iter-=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parsing a file for data\n",
    "This is perhaps one of the more important parts in this tutorial, which will enable you to start working with actual data. In the file `Moons_and_planets.csv`, we can find the names of the moons of each planet as well as the planet they orbit (yes, we know we included Pluto. Cut it some slack!)\n",
    "\n",
    "The data has been taken from https://en.wikipedia.org/wiki/List_of_natural_satellites. This employs something called web scraping, which we will have a look at later. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are encouraged to play around with this set of code. Try removing some of the functions and seeing why they have been used (remove the `split('\\n')` in the next cell and see why it is necessary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Moons_and_planets.csv', 'r') as f:\n",
    "    lines = f.read().split('\\n') # split each line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['# Name of Moon, Name of Planet, Diameter (km)', 'Moon,Earth,1737.1', 'Phobos,Mars,11.1', 'Deimos,Mars,6.2', 'Io,Jupiter,1818.1']\n"
     ]
    }
   ],
   "source": [
    "print(lines[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_moons = [] # Define an empty list. We will append our values to this\n",
    "for line in lines:\n",
    "    data_moons.append(line.split(',')) # split each element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['# Name of Moon', ' Name of Planet', ' Diameter (km)'],\n",
       " ['Moon', 'Earth', '1737.1'],\n",
       " ['Phobos', 'Mars', '11.1'],\n",
       " ['Deimos', 'Mars', '6.2'],\n",
       " ['Io', 'Jupiter', '1818.1']]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_moons[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, this is not perfect; the diameter of the moons has been appended as a `string`, instead of a `float`. <br>\n",
    "Fixing this is up to you! (*hint*: you can convert a string to a float using `float(<string>)`)\n",
    "\n",
    "You will have to use a loop to access each row (nested loops here), and use indexing to access the elements you want."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your assignment...\n",
    "...should you choose to accept it, will be the following:\n",
    "1. Find the number of moons of each planet\n",
    "2. Order the moons (along with their planets) according to their sizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to verify these from the Wikipedia link that we took the data from. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions for Tutorial Assignment\n",
    "\n",
    "Note that this is just one possible solution for the assignment. We have not given you the best or most optimized way to solve the assignment. You are encouraged to keep searching for better, more Pythonic ways to solve these problems. We nevertheless give some hints on how to find them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, we will first open the file and read its contents by separating using ','"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Moons_and_planets.csv','r') as f:    #creating a list with lines of file as elements\n",
    "    lines=f.read().split('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "del lines[0] #first line was headings, hence deleted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we have now is entire lines as single strings, and a list of all such single-line strings, which means that the planet, moon and diameter aren't independent entities as of now. Hence, we perform the following operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_moons=[]   #splitting the lines according to commas, now you have a nested list with planet, moon, diameter\n",
    "for line in lines:\n",
    "    data_moons.append(line.split(','))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "mer,ven,ear,mar,jup,sat,ura,nep,plu=[0,0,0,0,0,0,0,0,0] #variables that store number of moons, i.e., 'counters'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Nix', 'Pluto', '23.0'], ['Hydra', 'Pluto', '30.5'], ['Kerberos', 'Pluto', '14.0'], ['Styx', 'Pluto', '10.0'], ['']]\n"
     ]
    }
   ],
   "source": [
    "print(data_moons[-5:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "del data_moons[len(data_moons)-1]  #last element is an empty list (see above). So we delete it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A simple if-elif construct that checks all names of planets, i.e., the second elements of all lists within the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(data_moons)):            #if-elif ladder to count number of moons\n",
    "    if data_moons[i][1] == 'Mercury':\n",
    "        mer=mer+1\n",
    "    elif data_moons[i][1]== 'Venus':\n",
    "        ven=ven+1\n",
    "    elif data_moons[i][1]== 'Earth':\n",
    "        ear=ear+1\n",
    "    elif data_moons[i][1]== 'Mars':\n",
    "        mar=mar+1\n",
    "    elif data_moons[i][1]== 'Jupiter':\n",
    "        jup=jup+1\n",
    "    elif data_moons[i][1]== 'Saturn':\n",
    "        sat=sat+1\n",
    "    elif data_moons[i][1]== 'Uranus':\n",
    "        ura=ura+1\n",
    "    elif data_moons[i][1]== 'Neptune':\n",
    "        nep=nep+1\n",
    "    elif data_moons[i][1]== 'Pluto':\n",
    "        plu=plu+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool trivia fact to explain the output you get below: In October 2019, 20 new moons of Saturn were discovered using the Subaru telescope on Mt. Maunakea, Hawaii, pushing Saturn's tally to the output you get below, and also making it overtake Jupiter as the planet with most moons. Read more: https://www.bbc.com/news/science-environment-49962134"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 1 2 79 82 27 14 5\n"
     ]
    }
   ],
   "source": [
    "# Output\n",
    "print(mer,ven,ear,mar,jup,sat,ura,nep,plu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to make the output bit fancier, you could use string formatting to print."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jupiter has 79 moons\n"
     ]
    }
   ],
   "source": [
    "print(f\"Jupiter has {jup} moons\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given below is the bubble sort algorithm which is commonly used. Selection sort or insertion sort are other algorithms you would wish to try out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "lis=[]\n",
    "for i in range(len(data_moons)):\n",
    "    lis.append(float(data_moons[i][2]))          #separate list with only float entries created,then bubble sort algorithm on \n",
    "for i in range(len(data_moons)):                 #both lists implemented\n",
    "    for j in range(0,len(data_moons)-1-i):\n",
    "        if lis[j]>lis[j+1]:\n",
    "            lis[j],lis[j+1]=lis[j+1],lis[j]\n",
    "            data_moons[j],data_moons[j+1]=data_moons[j+1],data_moons[j]       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is not a very Python-like way to do this task. You are encouraged to search for ways to sort a list. There are functions to do so, as well as a method for lists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moon           Planet  Diameter\n",
      "------------------------------\n",
      "S/2009 S 1     Saturn   0.15\n",
      "Aegaeon        Saturn   0.33\n",
      "S/2010 J 2     Jupiter   0.5\n",
      "S/2011 J 2     Jupiter   0.5\n",
      "Valetudo       Jupiter   0.5\n",
      "S/2017 J 8     Jupiter   0.5\n",
      "S/2011 J 1     Jupiter   0.5\n",
      "S/2003 J 9     Jupiter   0.5\n",
      "S/2003 J 12    Jupiter   0.5\n",
      "Euporie        Jupiter   1.0\n",
      "Orthosie       Jupiter   1.0\n",
      "Sponde         Jupiter   1.0\n",
      "Kale           Jupiter   1.0\n",
      "Pasithee       Jupiter   1.0\n",
      "Mneme          Jupiter   1.0\n",
      "Thelxinoe      Jupiter   1.0\n",
      "Kallichore     Jupiter   1.0\n",
      "Cyllene        Jupiter   1.0\n",
      "Kore           Jupiter   1.0\n",
      "Herse          Jupiter   1.0\n",
      "S/2010 J 1     Jupiter   1.0\n",
      "S/2003 J 18    Jupiter   1.0\n",
      "Philophrosyne  Jupiter   1.0\n",
      "Eupheme        Jupiter   1.0\n",
      "S/2003 J 19    Jupiter   1.0\n",
      "S/2017 J 2     Jupiter   1.0\n",
      "S/2017 J 3     Jupiter   1.0\n",
      "Pandia         Jupiter   1.0\n",
      "S/2017 J 5     Jupiter   1.0\n",
      "S/2017 J 6     Jupiter   1.0\n",
      "S/2017 J 7     Jupiter   1.0\n",
      "S/2017 J 9     Jupiter   1.0\n",
      "Ersa           Jupiter   1.0\n",
      "S/2003 J 2     Jupiter   1.0\n",
      "S/2003 J 4     Jupiter   1.0\n",
      "S/2003 J 10    Jupiter   1.0\n",
      "S/2003 J 16    Jupiter   1.0\n",
      "S/2003 J 23    Jupiter   1.0\n",
      "Anthe          Saturn    1.0\n",
      "Polydeuces     Saturn   1.25\n",
      "Aitne          Jupiter   1.5\n",
      "Eurydome       Jupiter   1.5\n",
      "Euanthe        Jupiter   1.5\n",
      "Hegemone       Jupiter   1.5\n",
      "Arche          Jupiter   1.5\n",
      "Carpo          Jupiter   1.5\n",
      "Erinome        Jupiter   1.6\n",
      "Methone        Saturn    1.6\n",
      "Chaldene       Jupiter   1.9\n",
      "Isonoe         Jupiter   1.9\n",
      "Autonoe        Jupiter   2.0\n",
      "Thyone         Jupiter   2.0\n",
      "Hermippe       Jupiter   2.0\n",
      "Aoede          Jupiter   2.0\n",
      "Helike         Jupiter   2.0\n",
      "Eukelade       Jupiter   2.0\n",
      "Dia            Jupiter   2.0\n",
      "Eirene         Jupiter   2.0\n",
      "S/2017 J 1     Jupiter   2.0\n",
      "Pallene        Saturn    2.0\n",
      "Fenrir         Saturn    2.0\n",
      "S/2004 S 17    Saturn    2.0\n",
      "Harpalyke      Jupiter   2.2\n",
      "Taygete        Jupiter   2.5\n",
      "Farbauti       Saturn    2.5\n",
      "S/2004 S 12    Saturn    2.5\n",
      "Kalyke         Jupiter   2.6\n",
      "Iocaste        Jupiter   2.6\n",
      "Megaclite      Jupiter   2.7\n",
      "S/2016 J 1     Jupiter   3.0\n",
      "Aegir          Saturn    3.0\n",
      "Bebhionn       Saturn    3.0\n",
      "Bergelmir      Saturn    3.0\n",
      "Fornjot        Saturn    3.0\n",
      "Hati           Saturn    3.0\n",
      "Loge           Saturn    3.0\n",
      "Skoll          Saturn    3.0\n",
      "Surtur         Saturn    3.0\n",
      "Jarnsaxa       Saturn    3.0\n",
      "Greip          Saturn    3.0\n",
      "S/2004 S 7     Saturn    3.0\n",
      "S/2004 S 13    Saturn    3.0\n",
      "S/2006 S 1     Saturn    3.0\n",
      "S/2006 S 3     Saturn    3.0\n",
      "S/2007 S 2     Saturn    3.0\n",
      "S/2007 S 3     Saturn    3.0\n",
      "S/2004 S 20    Saturn    3.0\n",
      "S/2004 S 21    Saturn    3.0\n",
      "S/2004 S 22    Saturn    3.0\n",
      "S/2004 S 24    Saturn    3.0\n",
      "S/2004 S 30    Saturn    3.0\n",
      "S/2004 S 34    Saturn    3.0\n",
      "S/2004 S 36    Saturn    3.0\n",
      "S/2004 S 39    Saturn    3.0\n",
      "Praxidike      Jupiter   3.4\n",
      "Suttungr       Saturn    3.5\n",
      "Mundilfari     Saturn    3.5\n",
      "Thrymr         Saturn    3.5\n",
      "Narvi          Saturn    3.5\n",
      "Bestla         Saturn    3.5\n",
      "Kari           Saturn    3.5\n",
      "Tarqeq         Saturn    3.5\n",
      "Daphnis        Saturn    3.8\n",
      "Themisto       Jupiter   4.0\n",
      "Skathi         Saturn    4.0\n",
      "Hyrrokkin      Saturn    4.0\n",
      "S/2004 S 23    Saturn    4.0\n",
      "S/2004 S 25    Saturn    4.0\n",
      "S/2004 S 26    Saturn    4.0\n",
      "S/2004 S 28    Saturn    4.0\n",
      "S/2004 S 29    Saturn    4.0\n",
      "S/2004 S 31    Saturn    4.0\n",
      "S/2004 S 32    Saturn    4.0\n",
      "S/2004 S 33    Saturn    4.0\n",
      "S/2004 S 37    Saturn    4.0\n",
      "S/2004 S 38    Saturn    4.0\n",
      "Callirrhoe     Jupiter   4.3\n",
      "Erriapus       Saturn    5.0\n",
      "Margaret       Uranus    5.5\n",
      "Ijiraq         Saturn    6.0\n",
      "S/2004 S 27    Saturn    6.0\n",
      "S/2004 S 35    Saturn    6.0\n",
      "Francisco      Uranus    6.0\n",
      "Ferdinand      Uranus    6.0\n",
      "Mab            Uranus    6.0\n",
      "Deimos         Mars      6.2\n",
      "Tarvos         Saturn    7.5\n",
      "Kiviuq         Saturn    8.0\n",
      "Adrastea       Jupiter   8.2\n",
      "Ymir           Saturn    9.0\n",
      "Trinculo       Uranus    9.0\n",
      "Cupid          Uranus    9.0\n",
      "Calypso        Saturn    9.5\n",
      "Leda           Jupiter  10.0\n",
      "Stephano       Uranus   10.0\n",
      "Styx           Pluto    10.0\n",
      "Paaliaq        Saturn   11.0\n",
      "Phobos         Mars     11.1\n",
      "Telesto        Saturn   12.0\n",
      "Pan            Saturn   12.8\n",
      "Ananke         Jupiter  14.0\n",
      "Kerberos       Pluto    14.0\n",
      "Perdita        Uranus   15.0\n",
      "Atlas          Saturn   15.3\n",
      "Helene         Saturn   16.0\n",
      "Albiorix       Saturn   16.0\n",
      "Hippocamp      Neptune  17.4\n",
      "Lysithea       Jupiter  18.0\n",
      "Sinope         Jupiter  19.0\n",
      "Siarnaq        Saturn   20.0\n",
      "Psamathe       Neptune  20.0\n",
      "Cordelia       Uranus   20.1\n",
      "Caliban        Uranus   21.0\n",
      "Laomedeia      Neptune  21.0\n",
      "Ophelia        Uranus   21.4\n",
      "Metis          Jupiter  21.5\n",
      "Sao            Neptune  22.0\n",
      "Carme          Jupiter  23.0\n",
      "Nix            Pluto    23.0\n",
      "Setebos        Uranus   24.0\n",
      "Prospero       Uranus   25.0\n",
      "Bianca         Uranus   25.7\n",
      "Pasiphae       Jupiter  30.0\n",
      "Neso           Neptune  30.0\n",
      "Hydra          Pluto    30.5\n",
      "Halimede       Neptune  31.0\n",
      "Desdemona      Uranus   32.0\n",
      "Naiad          Neptune  33.0\n",
      "Rosalind       Uranus   36.0\n",
      "Cressida       Uranus   39.8\n",
      "Belinda        Uranus   40.3\n",
      "Pandora        Saturn   40.6\n",
      "Thalassa       Neptune  41.0\n",
      "Elara          Jupiter  43.0\n",
      "Prometheus     Saturn   46.8\n",
      "Juliet         Uranus   46.8\n",
      "Thebe          Jupiter  49.3\n",
      "Epimetheus     Saturn   58.3\n",
      "Himalia        Jupiter  67.0\n",
      "Portia         Uranus   67.6\n",
      "Despina        Neptune  75.0\n",
      "Sycorax        Uranus   78.5\n",
      "Puck           Uranus   81.0\n",
      "Amalthea       Jupiter  83.5\n",
      "Galatea        Neptune  88.0\n",
      "Janus          Saturn   90.4\n",
      "Larissa        Neptune  97.0\n",
      "Phoebe         Saturn  106.6\n",
      "Hyperion       Saturn  138.6\n",
      "Nereid         Neptune 178.5\n",
      "Mimas          Saturn  198.2\n",
      "Proteus        Neptune 210.0\n",
      "Miranda        Uranus  235.8\n",
      "Enceladus      Saturn  252.3\n",
      "Tethys         Saturn  536.3\n",
      "Dione          Saturn  562.5\n",
      "Ariel          Uranus  578.9\n",
      "Umbriel        Uranus  584.7\n",
      "Charon         Pluto   606.0\n",
      "Iapetus        Saturn  734.5\n",
      "Oberon         Uranus  761.4\n",
      "Rhea           Saturn  764.5\n",
      "Titania        Uranus  788.9\n",
      "Triton         Neptune 1353.4\n",
      "Europa         Jupiter 1560.7\n",
      "Moon           Earth   1737.1\n",
      "Io             Jupiter 1818.1\n",
      "Callisto       Jupiter 2408.4\n",
      "Titan          Saturn  2575.5\n",
      "Ganymede       Jupiter 2634.1\n"
     ]
    }
   ],
   "source": [
    "print(\"{:<15}{:<8}{:>5}\".format(\"Moon\", \"Planet\", \"Diameter\"))\n",
    "print(\"-\"*30)\n",
    "for i in data_moons:\n",
    "    print(f\"{i[0]:<15}{i[1]:<8}{i[2]:>5}\")"
   ]
  }
 ],
 "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": 2
}