2. Python Advanced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Advanced\n",
    "\n",
    "***Disclaimer*** *-* *This document is only meant to serve as a reference for the attendees of the workshop. It does not cover all the concepts or implementation details discussed during the actual workshop.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Variable Scope\n",
    "\n",
    "When you program, you'll often find that similar ideas come up again and again. You'll use variables for things like counting, iterating and accumulating values to return. In order to write readable code, you'll find yourself wanting to use similar names for similar ideas. As soon as you put multiple piece of code together (for instance, multiple functions or function calls in a single script) you might find that you want to use the same name for two separate concepts.   \n",
    "\n",
    "Fortunately, you don't need to come up with new names endlessly. Reusing names for objects is OK as long as you keep them in separate scope. \"Scope\" refers to which parts of a program a variable can be referenced from.   \n",
    "\n",
    "If a variable is created inside a function, it can only be used within that function.   \n",
    "\n",
    "Consider these two functions, word_count and nearest_square. Both functions include a answer variable, but they are distinct variables that only exist within their respective functions:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def word_count(document, search_term):\n",
    "    \"\"\" Count how many times search_term appears in document. \"\"\"\n",
    "    words = document.split()    \n",
    "    answer = 0\n",
    "    for word in words:\n",
    "        if word == search_term:\n",
    "            answer += 1\n",
    "    return answer\n",
    "\n",
    "def nearest_square(limit):\n",
    "    \"\"\" Find the largest square number smaller than limit. \"\"\"\n",
    "    answer = 0\n",
    "    while (answer+1)**2 < limit:\n",
    "        answer += 1\n",
    "    return answer**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the variable answer here is defined within each function seperately, you can reuse the same name of the variable, as the scope of the variables itself is different. \n",
    "Note : Functions, however, can  access variables that are defined outside of its scope or in the larger scope, but can only read the value of the variable, not modify it. This is shown by the `UnboundLocalError` in the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "egg_count = 0\n",
    "\n",
    "def buy_eggs():\n",
    "    egg_count += 12 # purchase a dozen eggs\n",
    "\n",
    "# buy_eggs()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In such situations its better to redefine the functions as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "egg_count = 0\n",
    "\n",
    "def buy_eggs():\n",
    "    return egg_count + 12\n",
    "\n",
    "egg_count = buy_eggs()\n",
    "print(egg_count)\n",
    "egg_count = buy_eggs()\n",
    "print(egg_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## List Basics\n",
    "\n",
    "In Python, it is possible to create a list of values. Each item in the list is called an *element* and can be accessed individually using a zero-based index. Hence avoiding the need to create multiple variables to store individual values.  \n",
    "Note: negative indexes help access elements from the end of the array. `-1` refers to the last element and `-2` refers to the second last element and so on.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List : [1, 2, 3, 4, 5]\n",
      "Second element : 2\n",
      "Length of list : 5\n",
      "\n",
      "List : ['red', 'blue', 'green']\n",
      "First color : red\n",
      "Third color : green\n",
      "Last color : green\n",
      "Second last color : blue\n",
      "Length of list : 3\n",
      "\n",
      "List : ['Shantanu Kamath', 'Computer Science', 20, 1000000]\n",
      "Fourth element : 1000000\n",
      "Length of list : 4\n"
     ]
    }
   ],
   "source": [
    "# list of numbers of type Integer\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "print(\"List :\", numbers)\n",
    "print(\"Second element :\", numbers[1])    ## 2\n",
    "print(\"Length of list :\",len(numbers))   ## 5\n",
    "print() # Empty line\n",
    "\n",
    "# list of strings\n",
    "colors = ['red', 'blue', 'green']\n",
    "print(\"List :\", colors)\n",
    "print (\"First color :\", colors[0])        ## red\n",
    "print (\"Third color :\", colors[2])        ## green\n",
    "print (\"Last color :\", colors[-1])        ## green\n",
    "print (\"Second last color :\", colors[-2]) ## blue\n",
    "print (\"Length of list :\",len(colors))    ## 3\n",
    "print() # Empty line\n",
    "\n",
    "# list with multiple variable types\n",
    "me = ['Shantanu Kamath', 'Computer Science', 20, 1000000]\n",
    "print(\"List :\", me)\n",
    "print(\"Fourth element :\", me[3])        ## 1000000\n",
    "print(\"Length of list :\", len(me))      ## 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since lists are considered to be sequentially ordered, they support a number of operations that can be applied to any Python sequence. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|Operation Name|Operator|Explanation|\n",
    "|:-------------|:-------|:----------|\n",
    "|Indexing|`[ ]`|Access an element of a sequence|\n",
    "|Concatenation|`+`|Combine sequences together|\n",
    "|Repetition|`*`|Concatenate a repeated number of times|\n",
    "|Membership|`in`|Ask whether an item is in a sequence|\n",
    "|Length|`len`|Ask the number of items in the sequence|\n",
    "|Slicing|`[ : ]`|Extract a part of a sequence|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[3, 3, 3]\n",
      "[1, 2, 3, 4, 3, 3, 3]\n",
      "True\n",
      "4\n",
      "[2, 3]\n",
      "[2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "myList = [1,2,3,4]\n",
    "\n",
    "# Indexing\n",
    "A = myList[2]\n",
    "print(A)\n",
    "\n",
    "# Repititoin\n",
    "A = [A]*3\n",
    "print(A)\n",
    "\n",
    "# Concatenation\n",
    "print(myList + A)\n",
    "\n",
    "# Membership\n",
    "print(1 in myList)\n",
    "\n",
    "# Length\n",
    "print(len(myList))\n",
    "\n",
    "# Slicing [inclusive : exclusive]\n",
    "print(myList[1:3])\n",
    "\n",
    "# Leaving the exclusive parameter empty\n",
    "print(myList[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutability\n",
    "Strings are immutable and list are mutable.    \n",
    "For example : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o\n",
      "Python\n",
      "['Welcome', 'to', 'coding', 'with', 'Python', 'v2.7']\n"
     ]
    }
   ],
   "source": [
    "# Creating sentence and list form of sentence\n",
    "name = \"Welcome to coding with Python v3.6\"\n",
    "words = [\"Welcome\", \"to\", \"coding\", \"with\", \"Python\", \"v3.6\"]\n",
    "\n",
    "print(name[4])\n",
    "print(words[4])\n",
    "\n",
    "# This is okay\n",
    "words[5] = \"v2.7\"\n",
    "print(words)\n",
    "\n",
    "# This is not\n",
    "# name[5] = \"d\"\n",
    "# print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Passed by reference\n",
    "The list is stored at a memory locations and only a reference of this memory location is what the variable holds. So changes applied to one variable reflect in other variables as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Python', 'Java', 'C++', 'C', 'C#']\n",
      "['Python', 'Java', 'C++', 'C', 'C#']\n"
     ]
    }
   ],
   "source": [
    "langs = [\"Python\", \"Java\", \"C++\", \"C\"]\n",
    "languages = langs\n",
    "langs.append(\"C#\")\n",
    "print(langs)\n",
    "print(languages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## List Methods\n",
    "\n",
    "Besides simple accessing of values, lists have a large variety of methods that are used to performed different useful manipulations on them.  \n",
    "Some of them are:  \n",
    "\n",
    "- **list.append(element):** adds a single element to the end of the list. Common error: does not return the new list, just modifies the original.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New list : ['Hermione Granger', 'Ronald Weasley', 'Harry Potter']\n"
     ]
    }
   ],
   "source": [
    "# list.append example\n",
    "names = ['Hermione Granger', 'Ronald Weasley']\n",
    "names.append('Harry Potter')\n",
    "print(\"New list :\", names)  ## ['Hermione Granger', 'Ronald Weasley', 'Harry Potter']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **list.insert(index, element):** inserts the element at the given index, shifting elements to the right.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New list : ['Ronald Weasley', 'Harry Potter', 'Hermione Granger']\n"
     ]
    }
   ],
   "source": [
    "# list.insert example\n",
    "names = ['Ronald Weasley', 'Hermione Granger']\n",
    "names.insert(1, 'Harry Potter')\n",
    "print(\"New list :\", names)  ## ['Ronald Weasley', 'Harry Potter', 'Hermione Granger']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **list.extend(list2):** adds the elements in list2 to the end of the list. Using + or += on a list is similar to using extend().\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full list : ['Ronald Weasley', 'Harry Potter', 'Hermione Granger', 'Neville Longbottom', 'Luna Lovegood']\n"
     ]
    }
   ],
   "source": [
    "# list.extend example\n",
    "MainChar = ['Ronald Weasley', 'Harry Potter', 'Hermione Granger']\n",
    "SupChar = ['Neville Longbottom', 'Luna Lovegood']\n",
    "MainChar.extend(SupChar)\n",
    "print(\"Full list :\", MainChar)  ## ['Ronald Weasley', 'Harry Potter', 'Hermione Granger', 'Neville Longbottom', 'Luna Lovegood']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **list.index(element):** searches for the given element from the start of the list and returns its index. Throws a ValueError if the element does not appear (use 'in' to check without a ValueError).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index of Harry Potter in list : 1\n"
     ]
    }
   ],
   "source": [
    "# list.index example\n",
    "names = ['Ronald Weasley', 'Harry Potter', 'Hermione Granger']\n",
    "index = names.index('Harry Potter')  \n",
    "print(\"Index of Harry Potter in list :\",index)  ## 1\n",
    "\n",
    "# Throws a ValueError (Uncomment to see error.)\n",
    "# index = names.index('Albus Dumbledore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **list.remove(element):** searches for the first instance of the given element and removes it (throws ValueError if not present)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified list : ['Ronald Weasley', 'Hermione Granger']\n"
     ]
    }
   ],
   "source": [
    "names = ['Ronald Weasley', 'Harry Potter', 'Hermione Granger']\n",
    "index = names.remove('Harry Potter')  ## ['Ronald Weasley', 'Hermione Granger']\n",
    "print(\"Modified list :\", names)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **list.pop(index):** removes and returns the element at the given index. Returns the rightmost element if index is omitted (roughly the opposite of append()).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified list : ['Ronald Weasley', 'Hermione Granger']\n"
     ]
    }
   ],
   "source": [
    "names = ['Ronald Weasley', 'Harry Potter', 'Hermione Granger']\n",
    "index = names.pop(1)\n",
    "print(\"Modified list :\", names)  ## ['Ronald Weasley', 'Hermione Granger']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **list.sort():** sorts the list in place (does not return it). (The sorted() function shown below is preferred.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list : ['a', 'b', 'c', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "alphabets = ['a', 'f','c', 'e','b', 'd']\n",
    "alphabets.sort();\n",
    "print (\"Sorted list :\", alphabets) ## ['a', 'b', 'c', 'd', 'e', 'f']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **list.reverse():** reverses the list in place (does not return it).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversed list : ['f', 'e', 'd', 'c', 'b', 'a']\n"
     ]
    }
   ],
   "source": [
    "alphabets = ['a', 'b', 'c', 'd', 'e', 'f']\n",
    "alphabets.reverse()\n",
    "print(\"Reversed list :\", alphabets)  ## ['f', 'e', 'd', 'c', 'b', 'a']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Others methods include :\n",
    "- Count : **list.count()**  \n",
    "- Delete : **del list[index]**\n",
    "- Join : **\"[Seperator string]\".join(list)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## List Comprehensions\n",
    "In Python, List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence, or to create a subsequence of those elements that satisfy a certain condition.\n",
    "\n",
    "It can be used to construct lists in a very natural, easy way, like a mathematician is used to do.\n",
    "This is how we can explain sets in maths:\n",
    "- Squares = {x² : x in {0 ... 9}}\n",
    "- Exponents = (1, 2, 4, 8, ..., 2¹²)\n",
    "- EvenSquares = {x | x in S and x even}\n",
    "\n",
    "Lets try to do this in Python using normal loops and list methods:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squares : [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "Exponents : [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]\n",
      "Even Squares : [0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# Using loops and list methods\n",
    "\n",
    "squares = []\n",
    "for x in range(10):\n",
    "  squares.append(x**2)\n",
    "print(\"Squares :\", squares)           ## [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
    " \n",
    "exponents = []\n",
    "for i in range(13):\n",
    "  exponents.append(2**i)\n",
    "print(\"Exponents :\", exponents)       ## [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]\n",
    "\n",
    "evenSquares = []\n",
    "for x in squares:\n",
    "  if x % 2 == 0:\n",
    "    evenSquares.append(x)\n",
    "print(\"Even Squares :\", evenSquares)  ## [0, 4, 16, 36, 64]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These extend to more than one line. But by using list comprehensions you can bring it down to just one line.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squares : [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "Exponents : [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]\n",
      "Even Squares : [0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# Using list comprehensions\n",
    "\n",
    "squares = [x**2 for x in range(10)]\n",
    "exponents = [2**i for i in range(13)]\n",
    "evenSquares = [x for x in squares if x % 2 == 0]\n",
    "print(\"Squares :\", squares)           ## [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
    "print(\"Exponents :\", exponents)       ## [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096]\n",
    "print(\"Even Squares :\", evenSquares)  ## [0, 4, 16, 36, 64]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Searching\n",
    "Searching is the process of finding a particular item in a collections of items. It is one of the most common problems that arise in computer programming. A search typically answers either True or False as to whether the item is present.\n",
    "\n",
    "In Python, there is a very easy way to ask whether an item is in a list of items. We use the ***in*** operator.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Using in to check if number is present in the list.\n",
    "\n",
    "print(15 in [3,5,2,4,1])\n",
    "print('Work' in 'Python Advanced Workshop')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it can be important to get the position of the searched value. In that case, we can use ***index*** method for lists and the ***find*** method for strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value present at 1\n",
      "Found 'is' in the sentence at position 2\n",
      "There is no 'is' here!\n"
     ]
    }
   ],
   "source": [
    "# Using index to get position of the number if present in list.\n",
    "# In case of lists, its important to remember that the index function will throw an error if the value isn't present in the list.\n",
    "\n",
    "values = [3,5,2,4,1]\n",
    "if 5 in values:\n",
    "  print(\"Value present at\",values.index(5))  ## 1\n",
    "else:\n",
    "  print(\"Value not present in list\")\n",
    "\n",
    "# Using find to get the index of the first occurrence of the word in a sentence.\n",
    "\n",
    "sentence = \"This be a string\"\n",
    "index = sentence.find(\"is\")\n",
    "if index == -1:\n",
    "  print(\"There is no 'is' here!\")\n",
    "else:\n",
    "  print(\"Found 'is' in the sentence at position \"+str(index))\n",
    "\n",
    "# Using index to find words in a list of words\n",
    "sentence = \"This be a string\"\n",
    "words = sentence.split(' ')\n",
    "if 'is' in words:\n",
    "  print(\"Found 'is' in the list at position \"+str(words.index('is')))\n",
    "else:\n",
    "  print(\"There is no 'is' here!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*For more efficient Search Algorithms, look through the  Algorithm Implementation section of this repository*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Sorting\n",
    "Sorting is the process of placing elements from a collection in some kind of order.   \n",
    "For example, a list of words could be sorted alphabetically or by length.    \n",
    "A list of cities could be sorted by population, by area, or by zip code.\n",
    "\n",
    "Python lists have a ***built-in sort()*** method that modifies the *list in-place* and a ***sorted() built-in*** function that builds a *new* sorted list from an iterable.\n",
    "\n",
    "- ***list.sort():***  Modifies existing list and can be used only with lists.\n",
    "- ***sorted(list):*** Creates a new list when called and can be used with other iterables.\n",
    "\n",
    "##### Basic sorting functions\n",
    "The most basic use of the sorted function can be seen below :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unsorted list : [7, 4, 3, 6, 1, 2, 5]\n",
      "New list : None\n",
      "Old list : [1, 2, 3, 4, 5, 6, 7]\n",
      "\n",
      "Unsorted list : [7, 4, 3, 6, 1, 2, 5]\n",
      "New list : [1, 2, 3, 4, 5, 6, 7]\n",
      "Old list : [7, 4, 3, 6, 1, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "# Using sort() with a list.\n",
    "\n",
    "values = [7, 4, 3, 6, 1, 2, 5]\n",
    "print(\"Unsorted list :\", values)     ## [7, 4, 3, 6, 1, 2, 5]\n",
    "newValues = values.sort()\n",
    "print(\"New list :\", newValues)       ## None\n",
    "print(\"Old list :\", values)          ## [1, 2, 3, 4, 5, 6, 7]\n",
    "print()\n",
    "# Using sorted() with a list.\n",
    "\n",
    "values = [7, 4, 3, 6, 1, 2, 5]\n",
    "print(\"Unsorted list :\", values)     ## [7, 4, 3, 6, 1, 2, 5]\n",
    "newValues = sorted(values)\n",
    "print(\"New list :\", newValues)       ## [1, 2, 3, 4, 5, 6, 7]\n",
    "print(\"Old list :\", values)          ## [7, 4, 3, 6, 1, 2, 5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Sorting using additional key\n",
    "For more complex custom sorting, sorted() takes an optional \"key=\" specifying a \"key\" function that transforms each element before comparison.    \n",
    "The key function takes in 1 value and returns 1 value, and the returned \"proxy\" value is used for the comparisons within the sort."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['d', 'bb', 'ccc', 'aaaa']\n",
      "['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']\n",
      "['BB', 'CC', 'aa', 'zz']\n",
      "['zz', 'aa', 'CC', 'BB']\n"
     ]
    }
   ],
   "source": [
    "# Using key in sorted\n",
    "\n",
    "values = ['ccc', 'aaaa', 'd', 'bb']\n",
    "print (sorted(values, key=len))            ## ['d', 'bb', 'ccc', 'aaaa']\n",
    "\n",
    "# Remember case sensitivity :  All upper case characters come before lower case character in an ascending sequence.\n",
    "sentence = \"This is a test string from Andrew\"\n",
    "print(sorted(sentence.split(), key=str.lower))    ## ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']\n",
    "\n",
    "# Using reverse for ascending and descending\n",
    "strs = ['aa', 'BB', 'zz', 'CC']\n",
    "print (sorted(strs))                         ## ['BB', 'CC', 'aa', 'zz'] (case sensitive)\n",
    "print (sorted(strs, reverse=True))          ## ['zz', 'aa', 'CC', 'BB']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Basics on Class and OOP\n",
    "\n",
    "This section is built around the fundamental of *Object Oriented Programming (OOP)*.\n",
    "It aims strengthening basics but doesn't justify the broad topic itself. As OOP is a very important programming concept you should read further to better get a grip on python as well as go deep in understanding how it is useful and essential to programming.\n",
    "Below are some essential resources :\n",
    "- [Improve Your Python: Python Classes and Object Oriented Programming](https://jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/)\n",
    "- [Learn Python The Hard Way](https://learnpythonthehardway.org/book/ex40.html)\n",
    "- [Python For Beginners](http://www.pythonforbeginners.com)\n",
    "- [A Byte Of Python](https://python.swaroopch.com/oop.html)\n",
    "\n",
    "### OOP\n",
    "In all the code we wrote till now, we have designed our program around functions i.e. blocks of statements which manipulate data. This is called the procedure-oriented way of programming.\n",
    "\n",
    "There is another way of organizing your program which is to combine data and functionality and wrap it inside something called an object. This is called the object oriented programming paradigm.   \n",
    "\n",
    "Most of the time you can use procedural programming, but when writing large programs or have a problem that is better suited to this method, you can use object oriented programming techniques.\n",
    "\n",
    "### Classes and Objects\n",
    "Classes and objects are the two main aspects of object oriented programming. A ***class*** creates a new type where ***objects*** are ***instances*** of the class.   \n",
    "\n",
    "Objects can store data using ordinary variables that belong to the object. Variables that belong to an object or class are referred to as ***fields*** or ***attributes***.\n",
    "\n",
    "Objects can also have functionality by using functions that belong to a class. Such functions are called ***methods*** of the class.\n",
    "\n",
    "The simplest class possible is shown in the following example :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x1049b64a8>\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    pass  # An empty block\n",
    "\n",
    "p = Person()\n",
    "print(p)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods\n",
    "\n",
    "Class methods have only one specific difference from ordinary functions - they must have an extra first name that has to be added to the beginning of the parameter list, but you do not give a value for this parameter when you call the method, Python will provide it. This particular variable refers to the object itself, and by convention, it is given the name self.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, how are you?\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def say_hi(self):\n",
    "        print('Hello, how are you?')\n",
    "\n",
    "p = Person()\n",
    "p.say_hi()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The __init__\n",
    "There are many method names which have special significance in Python classes. We will see the significance of the __init__ method now.   \n",
    "\n",
    "The __init__ method is run as soon as an object of a class is instantiated. The method is useful to do any initialization you want to do with your object. Notice the double underscores both at the beginning and at the end of the name.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is Shantanu\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def say_hi(self):\n",
    "        print('Hello, my name is', self.name)\n",
    "\n",
    "p = Person('Shantanu')\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Object variables\n",
    "Now let us learn about the data part. The data part, i.e. fields, are nothing but ordinary variables that are bound to the namespaces of the classes and objects. This means that these names are valid within the context of these classes and objects only. That's why they are called name spaces.   \n",
    "\n",
    "There are two types of fields - class variables and object variables which are classified depending on whether the class or the object owns the variables respectively.   \n",
    "\n",
    "***Class variables*** are shared - they can be accessed by all instances of that class. There is only one copy of the class variable and when any one object makes a change to a class variable, that change will be seen by all the other instances.   \n",
    "\n",
    "***Object variables*** are owned by each individual object/instance of the class. In this case, each object has its own copy of the field i.e. they are not shared and are not related in any way to the field by the same name in a different instance.\n",
    "\n",
    " An example will make this easy to understand.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Initializing R2-D2)\n",
      "Greetings, my masters call me R2-D2.\n",
      "We have 1 robots.\n",
      "(Initializing C-3PO)\n",
      "Greetings, my masters call me C-3PO.\n",
      "We have 2 robots.\n",
      "\n",
      "Robots can do some work here.\n",
      "\n",
      "Robots have finished their work. So let's destroy them.\n",
      "R2-D2 is being destroyed!\n",
      "There are still 1 robots working.\n",
      "C-3PO is being destroyed!\n",
      "C-3PO was the last one.\n",
      "We have 0 robots.\n"
     ]
    }
   ],
   "source": [
    "class Robot:\n",
    "    ##   Represents a robot, with a name.\n",
    "\n",
    "    # A class variable, counting the number of robots\n",
    "    population = 0\n",
    "\n",
    "    def __init__(self, name):\n",
    "        ##   Initializes the data.\n",
    "        self.name = name\n",
    "        print(\"(Initializing {})\".format(self.name))\n",
    "\n",
    "        # When this person is created, the robot\n",
    "        # adds to the population\n",
    "        Robot.population += 1\n",
    "\n",
    "    def die(self):\n",
    "        ##   I am dying.\n",
    "        print(\"{} is being destroyed!\".format(self.name))\n",
    "\n",
    "        Robot.population -= 1\n",
    "\n",
    "        if Robot.population == 0:\n",
    "            print(\"{} was the last one.\".format(self.name))\n",
    "        else:\n",
    "            print(\"There are still {:d} robots working.\".format(\n",
    "                Robot.population))\n",
    "\n",
    "    def say_hi(self):\n",
    "        ##   Greeting by the robot. Yeah, they can do that.\n",
    "        print(\"Greetings, my masters call me {}.\".format(self.name))\n",
    "\n",
    "    @classmethod\n",
    "    def how_many(cls):\n",
    "        ##   Prints the current population.\n",
    "        print(\"We have {:d} robots.\".format(cls.population))\n",
    "\n",
    "\n",
    "droid1 = Robot(\"R2-D2\")\n",
    "droid1.say_hi()\n",
    "Robot.how_many()\n",
    "\n",
    "droid2 = Robot(\"C-3PO\")\n",
    "droid2.say_hi()\n",
    "Robot.how_many()\n",
    "\n",
    "print(\"\\nRobots can do some work here.\\n\")\n",
    "\n",
    "print(\"Robots have finished their work. So let's destroy them.\")\n",
    "droid1.die()\n",
    "droid2.die()\n",
    "\n",
    "Robot.how_many()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How It Works\n",
    "This is a long example but helps demonstrate the nature of class and object variables. Here, population belongs to the Robot class and hence is a class variable. The name variable belongs to the object (it is assigned using self) and hence is an object variable.  \n",
    "\n",
    "Thus, we refer to the population class variable as Robot.population and not as self.population. We refer to the object variable name using self.name notation in the methods of that object. Remember this simple difference between class and object variables. Also note that an object variable with the same name as a class variable will hide the class variable!   \n",
    "\n",
    "Instead of Robot.population, we could have also used self.__class__.population because every object refers to its class via the self.__class__ attribute.   \n",
    "\n",
    "The how_many is actually a method that belongs to the class and not to the object. This means we can define it as either a classmethod or a staticmethod depending on whether we need to know which class we are part of. Since we refer to a class variable, let's use classmethod.\n",
    "\n",
    "\n",
    "We have marked the how_many method as a class method using a decorator.\n",
    "Decorators can be imagined to be a shortcut to calling a wrapper function, so applying the @classmethod decorator is same as calling:\n",
    "how_many = classmethod(how_many)\n",
    "\n",
    "Observe that the __init__ method is used to initialize the Robot instance with a name. In this method, we increase the population count by 1 since we have one more robot being added. Also observe that the values of self.name is specific to each object which indicates the nature of object variables.\n",
    "Remember, that you must refer to the variables and methods of the same object using the self only. This is called an attribute reference.\n",
    "\n",
    "All class members are public. One exception: If you use data members with names using the double underscore prefix such as ***__privatevar*** , Python uses name-mangling to effectively make it a private variable.\n",
    "\n",
    "Thus, the convention followed is that any variable that is to be used only within the class or object should begin with an underscore and all other names are public and can be used by other classes/objects. Remember that this is only a convention and is not enforced by Python (except for the double underscore prefix).\n",
    "\n",
    "\n",
    "*There are more concepts in OOP such as Inheritance, Abstraction and Polymorphism, which would require a lot more time to cover. You may refer to reference material for explanation on these topics.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## File I/O\n",
    "File handling is super simplified in Python compared to other programming languages.\n",
    "The first thing you’ll need to know is Python’s built-in ***open*** function to get a ***file object***.   \n",
    "The ***open*** function opens a ***file***. When you use the ***open*** function, it returns something called a ***file object***. File objects contain ***methods*** and ***attributes*** that can be used to collect information about the file you opened. They can also be used to manipulate said file.\n",
    "\n",
    "For example, the ***mode*** attribute of a file object tells you which mode a ***file*** was opened in. And the ***name*** attribute tells you the name of the file that the ***file object*** has opened.\n",
    "\n",
    "#### File Types\n",
    "In Python, a file is categorized as either ***text*** or ***binary***, and the difference between the two file types is important.\n",
    "\n",
    "***Text files*** are structured as a sequence of lines, where each line includes a sequence of characters. This is what you know as code or syntax.\n",
    "\n",
    "Each line is terminated with a special character, called the ***EOL*** or ***End of Line*** character. There are several types, but the most common is the ***comma*** {,} or ***newline*** character. It ends the current line and tells the interpreter a new one has begun.\n",
    "\n",
    "A ***backslash*** character can also be used, and it tells the interpreter that the next character – following the slash – should be treated as a new line. This character is useful when you don’t want to start a new line in the text itself but in the code.\n",
    "\n",
    "A ***binary file*** is any type of file that is not a text file. Because of their nature, binary files can only be processed by an application that know or understand the file’s structure. In other words, they must be applications that can ***read and interpret*** binary.\n",
    "\n",
    "#### Open ( ) Function\n",
    "The syntax to open a file object in Python is:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "file_object  = open(\"filename\", \"mode\") ## where file_object is the variable to add the file object.\n",
    "```\n",
    "The second argument you see – mode – tells the interpreter and developer which way the file will be used.\n",
    "\n",
    "#### Mode\n",
    "Including a mode argument is optional because a default value of ***r*** will be assumed if it is omitted.\n",
    "\n",
    "The modes are:\n",
    "\n",
    "- ***r*** – Read mode which is used when the file is only being read\n",
    "- ***w*** – Write mode which is used to edit and write new information to the file (any existing files with the same name will be erased when this mode is activated)\n",
    "- ***a*** – Appending mode, which is used to add new data to the end of the file; that is new information is automatically amended to the end\n",
    "- ***r+*** – Special read and write mode, which is used to handle both actions when working with a file\n",
    "\n",
    "#### Create a text file\n",
    "Using a simple text editor, let’s create a file. You can name it anything you like, and it’s better to use something you’ll identify with.\n",
    "For the purpose of this workshop, however, we are going to call it \"testfile.txt\".\n",
    "Just create the file and leave it blank.\n",
    "\n",
    "To manipulate the file :\n",
    "```python\n",
    "file = open(\"testfile.txt\",\"w\")\n",
    "\n",
    "file.write(\"Hello World\")\n",
    "file.write(\"This is our new text file\")\n",
    "file.write(\"and this is another line.\")\n",
    "file.write(\"Why? Because we can.\")\n",
    "\n",
    "file.close()\n",
    "```\n",
    "\n",
    "#### Reading a text file\n",
    "Following methods allow reading a file :\n",
    "- ***file.read():*** extract a string that contains all characters in the file.\n",
    "```python\n",
    "file = open(\"testfile.text\", \"r\")\n",
    "print(file.read())\n",
    "```\n",
    "- ***file.read(numberOfCharacters):*** extract only a certain number of characters.  \n",
    "```python\n",
    "file = open(\"testfile.txt\", \"r\")\n",
    "print(file.read(5))\n",
    "```\n",
    "- ***file.readline():*** read a file line by line – as opposed to pulling the content of the entire file at once.\n",
    "```python\n",
    "file = open(\"testfile.txt\", \"r\")\n",
    "print(file.readline())\n",
    "```\n",
    "- ***file.readline(lineNumber):*** return a specific line\n",
    "```python\n",
    "file = open(\"testfile.txt\", \"r\")\n",
    "print(file.readline(3))\n",
    "```\n",
    "- ***file.readlines():*** return every line in the file, properly separated in a list\n",
    "```python\n",
    "file = open(\"testfile.txt\", \"r\")\n",
    "print (file.readlines())\n",
    "```\n",
    "\n",
    "#### Looping over file\n",
    "When you want to read – or return – all the lines from a file in a more memory efficient, and fast manner, you can use the loop over method. The advantage to using this method is that the related code is both simple and easy to read.\n",
    "\n",
    "```python\n",
    "file = open(\"testfile.txt\", \"r\")\n",
    "for line in file:\n",
    "print line\n",
    "```\n",
    "\n",
    "#### Using the File Write Method\n",
    "This method is used to add information or content to an existing file. To start a new line after you write data to the file, you can add an ***EOL*** (\"\\n\")) character.\n",
    "```python\n",
    "file = open(\"testfile.txt\", \"w\")\n",
    "\n",
    "file.write(\"This is a test\")\n",
    "file.write(\"To add more lines.\")\n",
    "\n",
    "file.close()\n",
    "```\n",
    "#### Closing a file\n",
    "When you’re done working, you can use the fh.close() command to end things. What this does is close the file completely, terminating resources in use, in turn freeing them up for the system to deploy elsewhere.\n",
    "\n",
    "It’s important to understand that when you use the fh.close() method, any further attempts to use the file object will fail.\n",
    "```python\n",
    "file.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Exception Handling\n",
    "There are two types of errors that typically occur when writing programs. The first, known as a ***syntax error***, simply means that the programmer has made a mistake in the structure of a statement or expression. For example, it is incorrect to write a for statement and forget the colon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ( Uncomment to see Syntax error. )\n",
    "# for i in range(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other type of error, known as a ***logic error***, denotes a situation where the program executes but gives the wrong result. This can be due to an error in the underlying algorithm or an error in your translation of that algorithm. In some cases, logic errors lead to very bad situations such as trying to *dividing by zero* or trying to access an item in a list where the index of the item is outside the bounds of the list. In this case, the logic error leads to a ***runtime error*** that causes the program to terminate. These types of runtime errors are typically called ***exceptions***.    \n",
    "    \n",
    "When an exception occurs, we say that it has been ***raised***. You can ***handle*** the exception that has been raised by using a **`try`** statement. For example, consider the following session that asks the user for an integer and then calls the square root function from the math library. If the user enters a value that is greater than or equal to `0`, the print will show the square root. However, if the user enters a negative value, the square root function will report a **`ValueError`** exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter an integer -10\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "math domain error",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-ef0cdd33095c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0manumber\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Please enter an integer \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Give input as negative number and also see output from next code snippet\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: math domain error"
     ]
    }
   ],
   "source": [
    "import math\n",
    "anumber = int(input(\"Please enter an integer \"))\n",
    "# Give input as negative number and also see output from next code snippet\n",
    "print(math.sqrt(anumber))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can ***handle*** this exception by calling the print function from within a **`try`** block. A corresponding **`except`** block ***catches*** the exception and prints a message back to the user in the event that an exception occurs. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bad Value for square root\n",
      "Using absolute value instead\n",
      "3.1622776601683795\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "   print(math.sqrt(anumber))\n",
    "except:\n",
    "   print(\"Bad Value for square root\")\n",
    "   print(\"Using absolute value instead\")\n",
    "   print(math.sqrt(abs(anumber)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible for a programmer to cause a runtime exception by using the **`raise`** statement. For example, instead of calling the square root function with a negative number, we could have checked the value first and then raised our own exception. The code fragment below shows the result of creating a new **`RuntimeError`** exception. Note that the program would still terminate but now the exception that caused the termination is something explicitly created by the programmer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "You can't use a negative number",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-c2dee6db69a9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0manumber\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"You can't use a negative number\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: You can't use a negative number"
     ]
    }
   ],
   "source": [
    "if anumber < 0:\n",
    "    raise RuntimeError(\"You can't use a negative number\")\n",
    "else:\n",
    "    print(math.sqrt(anumber))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many kinds of exceptions that can be raised in addition to the **`RuntimeError`** shown above. See the Python reference manual for a list of all the available exception types and for how to create your own."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Importing Modules\n",
    "So far we haven't explained what a Python module is. To put it in a nutshell: every file, which has the file extension .py and consists of proper Python code, can be seen or is a module.   \n",
    "There is no special syntax required to make such a file a module. A module can contain arbitrary objects, for example files, classes or attributes.   \n",
    "All those objects can be accessed after an import. There are different ways to import a modules.   \n",
    "\n",
    "#### Import one module:\n",
    "```python\n",
    ">>> import math\n",
    ">>> math.pi\n",
    "3.141592653589793\n",
    ">>> math.sin(math.pi/2)\n",
    "1.0\n",
    ">>> math.cos(math.pi/2)\n",
    "6.123031769111886e-17\n",
    ">>> math.cos(math.pi)\n",
    "-1.0\n",
    "```\n",
    "#### Import more than one module in one import statement:\n",
    "```python\n",
    "import math, random\n",
    "```\n",
    "If only certain objects of a module are needed, we can import only those:\n",
    "```python\n",
    "from math import sin, pi\n",
    "```\n",
    "Instead of explicitly importing certain objects from a module, it's also possible to import everything in the namespace of the importing module:\n",
    "```python\n",
    ">>> from math import *\n",
    ">>> sin(3.01) + tan(cos(2.1)) + e\n",
    "2.2968833711382604\n",
    ">>> e\n",
    "2.718281828459045\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Scripting\n",
    "This topic is a little more complex than you would have expected it to be.\n",
    "Probably practice more python before you venture into this topic.\n",
    "But just to get you to understand what this topic consists of and also appreciate the powerful nature of python,\n",
    "Here are a few video clips to showing the result of various python scripts.  \n",
    "[Articles showcasing python scripts](https://www.quora.com/What-are-the-best-Python-scripts-youve-ever-written)   \n",
    "[Movie subtitle downloader](https://youtu.be/Q5YWEqgw9X8)   \n",
    "[Python Script to download course content from Blackboard learn](https://github.com/NasaGeek/blackboard-export)   \n"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}