1_Python_Essentials.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notes by Girijesh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Essentials (Part:1)\n",
    "\n",
    "Hi Guys,<br>\n",
    "Welcome to the Python Essentials <br>\n",
    "\n",
    "&#9989; <font style=\"font-size:14px;color:green;\">*If you already have a good knowledge of Python and / or working experience in any other language, you can skip this . **However, a quick review is recommended to brush-up the basics.** * </font><br>\n",
    "\n",
    "In this lecture, we are going to discuss the key concepts of Python. We need them throughout in this course. This section is carefully designed for all levels and if you don't have any programming experience in Python, it is still very easy to follow.\n",
    "\n",
    "For those who want to explore more in further details, following resources are very useful: <br>\n",
    "“[python.org](https://www.python.org/about/gettingstarted/)”.<br>\n",
    "\"[learning-python’s documentation](http://learning-python.readthedocs.io/en/latest/index.html)\".<br>\n",
    "“[Learning Python, 5th Ed.](http://shop.oreilly.com/product/0636920028154.do)” by Mark Lutz is a great resource book for the beginners.<br>\n",
    "\n",
    "We will go through the following concepts in this section:\n",
    "* Python data types:\n",
    "    * Numbers\n",
    "    * Strings & print formatting\n",
    "    * Lists\n",
    "    * Dictionaries\n",
    "    * Tuples\n",
    "    * Sets\n",
    "    * Booleans. \n",
    "    \n",
    "    \n",
    "<br>\n",
    "\n",
    "#### Important Note:\n",
    "\n",
    "<font style=\"font-size:12px;color:green;\">* Concise information and key concepts on every topic is provided in the resource note book. At several places, you will find comments along with the code as well. **Remember**, Writing comments, while coding, is a very good practice. Comments help a lot when you come back to check your own code and you can easily recall what you have done before. Comments are specially helpful when you are working in a team on a common project.*</font>\n",
    "\n",
    "## Python data types:\n",
    "\n",
    "### Numbers \n",
    "Python has two basic number types, <b>integer</b> and <b>float</b>. <br>\n",
    "\n",
    "For example, 2 is an integer and 2.0 is a floating point number which has a decimal attached to it. <br>We can perform arithmetic operations to either of these numbers types. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# addition\n",
    "5 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subtraction\n",
    "5 - 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplication\n",
    "5 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can divide them with a forward slash between them (note, two integers are giving floating point in results).<br> \n",
    "<font style=\"font-size:12px;\">*If you are using Python 2, you need to add 2.0 in the expression (e.g. 5 / 2.0) to get the same results.*</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can calculate the power of some number `(exponent)` with two **Asterix** ** together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python follow the order of arithmetic operations, for example:<br>\n",
    "**for 1 + 2 * 3 + 4**<br>\n",
    "Python will **first multiply 2 & 3** then perform the other operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2 * 3 + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A good practice is to use parentheses `\"( )\"`** to tell the Python, which operation needs to be performed and clarify the order. <br> \n",
    "The operations in the parentheses will be performed first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 + 2) * (3 + 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Modulus** or **mod** operation is a \"**`%`**\" (percentage sign) in Python. It **returns what remains after a division**.<br>\n",
    "\n",
    "*With Mod operation, we can check weather the number is even or odd.*\n",
    "* If mod `(%)` **returns 0**, the number is **even** <br>\n",
    "* If mod `(%)` **returns 1**, the number is **odd**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 % 2 # returns 0, 6 is even no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 % 2 # returns 1, 5 is odd no. (if we divide 5 by 2, remainder is 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables:\n",
    "At many occasions, we pick a variable with some name and assign object or a data type to that variable. We can do this in Python using equal sign operator **`“=“`**. <br>\n",
    "For example, if we assign a value of 5 to a variable `“x”`. Whenever we call `x`, this will return 5 in the output. <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's try x = 5 and y = 3\n",
    "x = 5\n",
    "y = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what is x now!\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what is y now!\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform arithmetic operations using these variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Adding x and y\n",
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplying x and y\n",
    "x * y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform any arithmetic operation and assign the result to a new variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Subtraction of the variables and assigning the result to a new variable\n",
    "z = x - y # 5 - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "We can **re-assign** the value to the variables. This **will replace the existing value to its new value.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = x * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a common practice to use a **variable with multiple names**. <br>\n",
    "Proper syntax in Python is to separate them with **underscore `“_”` between the words**. By doing this, you will easily identify them. e.g. **total_profit, total_loss, first_name** etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "name_of_the_variable = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name_of_the_variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important regarding variable name**<br>\n",
    "Before we move on to the next data type, we should know:<br>\n",
    "\n",
    "In Python,\n",
    "* variable name can not be started with number (e.g. `1var, 2x` etc)<br>\n",
    "* variable name can not be started with special characters (e.g. *var, !y etc)<br>\n",
    "* variable name are case sensitive, \"Name\" is not the same as \"name\"\n",
    "* reserved words can not be a variable name, e.g. `\"class\"` is a reserve word in Python, it can not be used as a variable name, but \"klass\" and `\"Class\"` work fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-21-460332d99e8f>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-21-460332d99e8f>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    1var = 1\u001b[0m\n\u001b[0m       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "1var = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "$var = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "One of the most popular and useful data types in Python are strings. They can be created by enclosing characters in single **' '** or double **\" \"** quotes. <br>\n",
    "Python consider singe and double quotes in the same way. <br>\n",
    "Strings are used to record text information (e.g. person name) as well as arbitrary collection of bytes (e.g. contents of an image file) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# creating single quotes string\n",
    "'creating single quotes string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# creating double quotes string\n",
    "\"creating double quotes string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# we have lot's of other quotes, let's wrap them in double quotes \n",
    "\"we have lot's of other quotes, let's wrap them in double quotes\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can **pass a string to a variable** as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X = \"String\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the **`print()`** method to output the variable `X`. This is a **proper and official way** to display the results in Python.<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, let me introduce a very useful built-in method **“`format()`”** with a use example. <br>\n",
    "\n",
    "If we have two variable <br>\n",
    "* name = 'Girijesh'\n",
    "* number = 30\n",
    "\n",
    "using **“`format()`”**, we can put the values of name and number at specified locations with the print statement. <br>\n",
    "\n",
    "Take a string, create **place holders** using curly brackets **`\"{}\"`** and pass that string to **`print()`** with **`format()`** containing values for the place holders. <br>\n",
    "\n",
    "Python reads the curly brackets **`\"{}\"`** in the string and then **`format()`** method. It will put the values in the order, we have given in the **`format()`** method. <br>\n",
    "\n",
    "This is a convenient way of writing the desired values in the place holder instead of writing those values (Qazi and 30) again and again. <br>\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "name = 'Girijesh'\n",
    "number = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('My name is {} and my number is {}'.format(name, number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is another very useful way to write the values in the place holders. In this case, we don't need to worry about the order in the `format` method!<br>\n",
    "Let's try this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('My name is {one} and my number is {two}'\n",
    "      .format(one=name, two=number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can put **more than one placeholder `\"{}\"`** for the same values "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('My name is {one} and my number is {two}, {one} again and {two} again'\n",
    "      .format(one=name, two=number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Little more about strings:\n",
    "* A string is a sequence (a positionally ordered collection) of other objects or elements.<br> \n",
    "* Maintain a left-to-right order among the contained items.<br>\n",
    "* Items are stored and fetched by their relative position.<br>\n",
    "* Stings are **immutable** in Python — they cannot be changed in place after they are created.<br>\n",
    "In simple words, immutable objects can never be overwriten, e.g. we can’t change a string by assigning to one of its positions, but we can always build a new one and assign it to the same name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's create a string\n",
    "X = \"String\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String is a sequence, we can grab any of its letter using its index position in the square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing the first letter in the String\n",
    "X[0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing last item\n",
    "X[-1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing a slice (everything after index 1) \n",
    "X[1:] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing a slice (everything from index 0 upto 4 (not included))\n",
    "X[:4] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing a slice (with first and last given positions) \n",
    "X[0:4] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some important methods to know: \n",
    "Ok, I hope that you already got a good understanding of strings. This is a good point to introduce some commonly used methods such as `lower()`, `upper()`, `split()` etc<br>\n",
    "Let's see how they work with strings!\n",
    "\n",
    "**Remember, `<shift+tab>` for the docstring!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Hi I am Girijesh'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi i am girijesh'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HI I AM GIRIJESH'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`s.split()` return a list of the words in a string, using `sep` (separator) parameter as the\n",
    "delimiter string. If `sep` is not specified, any whitespace string is a separator and empty strings are removed from the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tweet = 'Go Flames Go! #Hockey'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tweet.split('#') # or (sep = '#')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tweet.split('#')[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "As discussed, string is a sequence of items, lets move on with this idea to the another very useful data type in Python which is List. Before we move on, some key points for the lists are:<br> \n",
    "* **Lists** are positionally ordered collections of arbitrarily typed objects (it **can take any data type**). <br>\n",
    "* It is a sequence of elements separated by commas in a set of square brackets.<br> \n",
    "* Lists have no fixed size.<br>\n",
    "* Lists are mutable — unlike strings, lists can be modified.<br>\n",
    "* Lists can be indexed and sliced, like strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# a list of numbers \n",
    "[4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We can have a list of stings 'd', 'e', 'f' -- Note strings are in quotes \n",
    "['d','e','f']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We can assign a list to a variable \"my_list\".\n",
    "my_list = ['d','e','f']\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can grow and shrink on demand.<br>\n",
    "* We can add an element in the list using **`\"append()\"`** method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_list.append('g')\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`\"pop()\"`** method removes and returns the last item from the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_list.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_list # \"g\" is no more in the list after pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grab the first item in the list\n",
    "my_list[0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grab everything after first element\n",
    "my_list[1:] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grab a slice, not including index 3\n",
    "my_list[1:3] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can **re-assign** position using index. We want first element in my_list to be ‘hi’"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# pass in the element 'hi' to the index 0\n",
    "my_list[0]='hi' \n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Nesting in Lists\n",
    "We can nest a list with-in a list and grab any element in the nested list.<br> A very useful *feature applied to represent matrixes or multidimensional arrays.* <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# nested list  \n",
    "nested_1 = [1,2,3,[4,5,6]]\n",
    "nested_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing nested list\n",
    "nested_1[3] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing element from nested list\n",
    "nested_1[3][0]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# another example of nested lits\n",
    "nested_2 = [1,2,[3,4,['a','b']]]\n",
    "nested_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# grabbing 'a' from nested_2\n",
    "nested_2[2][2][0] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "We have learnt about the **strings** and **lists**, they are somehow related to each other as they are just sequences of items and we can use same index notation to grab the elements. <br>\n",
    "* **Dictionaries** are something completely different as they are not sequences at all.<br>\n",
    "* **Dictionaries** are ***key-value pairs*** in curly brackets **`\"{}\"`**<br>\n",
    "* **Dictionaries** store objects by **‘key’** instead of by relative position and don’t maintain any reliable let-to-right order; they simply **map key to associated values**.<br>\n",
    "* **Dictionaries can grow and shrink** on demand, Like lists. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# lets create a simple Dictionaries, d1.\n",
    "d1 = {'key1':'value1','key2':'value2', 'key3':'value3'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access any value in the dictionary using its key.<br> \n",
    "Like in lists and strings, **index `\"dic[0]\"` is not going to work for dictionaries** and raise an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d1['key1']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Dictionaries can take any item as their values**, e.g. we can have a list with associate key in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d2 = {'k1':[1,2,3],'k2':['a','b']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d2['k1']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index the list after accessing it with a key in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d2['k1'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can **nest dictionary with-in a dictionary** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nested_d = {'k1':{'k_in':[1,2,3]}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nested_d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Now we can access the element in the list which is a nested dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nested_d['k1']['k_in'][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`keys()`** and **`values()`** are very useful built-in methods and returns all the **`keys`** and **`values`** from any dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We have a dictionary \n",
    "d1 = {'key1':'value1','key2':'value2', 'key3':'value3'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d1.keys() #list(d1.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d1.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "d1.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>So, let's talk about **Tuples** Now!\n",
    "### Tuples \n",
    "\n",
    "Tuples are:\n",
    "* Similar to the list but can not be changed. <br>\n",
    "* Sequences, like lists, but immutable, like strings.<br> \n",
    "* Used to represent fixed collection of items.<br>\n",
    "* Coded in parentheses **`\"()\"`** instead of square brackets "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# lets create a tuple \"t\"\n",
    "t = (3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# we can grab any element using index\n",
    "t[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuples are immutable** and can not be re-assigned.<br>\n",
    "we can not do operation like `t[0] = 'NEW'`, as discussed, this is possible in lists\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t[0] = 'New'\n",
    "\n",
    "# TypeError: 'tuple' object does not support item assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "A **collection of unique elements** in a pair of curly brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "{2,3,4}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An **item appears only once in a set**, no matter how many times it is added. <br>\n",
    "For example, if we put multiples of the same element in a set, it will reduce it down to a single unique element is a set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = {2,2,2,3,3,3,4,4,4,4}\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use **`add()`** method to add a new element in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s.add(5)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to add 5 again, it will not give an error. The output will be the same as set can only have unique elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s.add(5)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans\n",
    "Are simply **`True`** and **`False`** with capital **`T`** and Capital **`F`** -- just a customized version of **1** and **0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_list = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# check is the item is in the list\n",
    "1 in my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "5 in my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Great job!\n",
    "**A quick review on what we did So far**:<br>\n",
    "We have gone through the basic Python data types, **Numbers, Strings & print formatting, Lists, Dictionaries, Tuples, Sets and Booleans**. <br>\n",
    "We have learned these data types with examples. <br>\n",
    "If you are interested to explore more about these data types, please read Python documentation or consult any basic book on Python. There are lots of good and free books available on Python.<br>\n",
    "<br>\n",
    "\n",
    "### Excellent Work!  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}