Python_Fundamentals.ipynb

{
 "cells": [
  {
   "attachments": {
    "Screen%20Shot%202023-03-24%20at%207.30.56%20pm.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   # PYTHON FUNDAMENTALS - Rose Missier\n",
    "![Screen%20Shot%202023-03-24%20at%207.30.56%20pm.png](attachment:Screen%20Shot%202023-03-24%20at%207.30.56%20pm.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python is a programming language that is used to create**\n",
    "\n",
    "- web applications\n",
    "- data science\n",
    "- scripting : automating boring stuff!\n",
    "\n",
    "## FACTS\n",
    "- created by Guido Van Rossum\n",
    "- works on different platforms\n",
    "- procedural, object-oriented or functional\n",
    "- interpreter \n",
    "- text editor or IDE (IDLE3, Pycharm, Eclipse, Sublime, Jupyter,etc)\n",
    "\n",
    "## INSTALLATION & RUNNING CODE\n",
    "- Python Pre-installed nowadays\n",
    "- Run python file from terminal using command : python <filename.py>\n",
    "- Run instructions from cmd line - **python -c 'from printNum import *; printNum(9)'**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.8.5\r\n"
     ]
    }
   ],
   "source": [
    "#check python version and update to atleast Python 3, latest being 3.11\n",
    "!python --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VARIABLES, EXPRESSIONS, AND STATEMENTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "- **NO declaration required**\n",
    "- Local and global variables (**Global**)\n",
    "- Store a value in memory which can be reused and retrieved.\n",
    "- Variable names are case sensitive and can contain numbers, letters, or underscore. \n",
    "- Should not start with a number and cannot contain space - ex: 1first \n",
    "\n",
    "\n",
    "### Datatypes\n",
    "- The values belong to a category like numbers,iterables, text and hence the datatypes can be integer, float,complex, list, tuple,set, dict,str, etc\n",
    "- Use constructors to create variables of a particular datatype ( ex.dict(\"name\"='Rose', city=\"Melbourne\")\n",
    "\n",
    "### Basic Datatypes\n",
    "\n",
    "##### Numeric\n",
    "- Integer: 1,2,3\n",
    "- Float: 2.0, 2.4\n",
    "- Complex: 2+5j\n",
    "\n",
    "##### Text\n",
    "- String: 'Rose', \"Preet\"\n",
    "\n",
    "#### Boolean\n",
    "- bool: True, False\n",
    "\n",
    "#### Sequence\n",
    "- list,tuple,range\n",
    "\n",
    "#### Sets\n",
    "- set, frozenset ( cannot change - add/remove)\n",
    "\n",
    "#### Dictionary\n",
    "- dict\n",
    "\n",
    "#### Other types\n",
    "- NoneType ( ex.For null values in Python, assign variable as i = None and then check its type using command - type(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bluey'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a variable 'name'\n",
    "name = \"Bluey\"\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check type of name\n",
    "type(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reuse variable 'name' as an integer\n",
    "name = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recheck type of name\n",
    "type(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reuse variable 'name' as a float\n",
    "name = 6.5\n",
    "type(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check datatype\n",
    "type(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multi-assignment : assign more than one variable at a time\n",
    "a,b = 2,4\n",
    "a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# complex numbers that are real and imaginary\n",
    "d = 1 + 3j\n",
    "d.real + d.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Expressions \n",
    "Expression has a operator, operands(values) and equates to a single value. \n",
    "**z = y+z**\n",
    "\n",
    "**Dynamic typing** - do not declare datatype unlike other languages\n",
    "\n",
    "**Ternary Expressions** - shortcut to if-else\n",
    "\n",
    "### Operators\n",
    "#### Arithmetic operators \n",
    "- Exponent **\n",
    "- Modulus  %\n",
    "- Integer division  //\n",
    "- Division  /\n",
    "- Multiplication  *\n",
    "- Subtraction  -\n",
    "- Addition  +\n",
    "\n",
    "#### Comparison operators\n",
    "- Equal to ==\n",
    "- Not equal to !=\n",
    "- Less than <\n",
    "- Greater than > \n",
    "- Less than or equal to <=\n",
    "- Greater than or equal to >=\n",
    "\n",
    "#### Logical operators\n",
    "- and\n",
    "- or\n",
    "- not\n",
    "\n",
    "\n",
    "#### Assignment operators\n",
    "- =, +=, -=, *=, /=, %=, //=, **=, &=, |=, ^=, >>=, <<=\n",
    "\n",
    "\n",
    "#### Bitwise operators\n",
    "- &, |, ^, ~, <<, >>\n",
    "\n",
    "#### Membership operators\n",
    "- in,\n",
    "- not in\n",
    "\n",
    "#### Identity operators\n",
    "- is\n",
    "- is not\n",
    "\n",
    "### Operator Precedence\n",
    "- Parentheses ()\n",
    "- Exponentiation **\n",
    "- unary +,-, bitwise NOT\n",
    "- *,/,//,%\n",
    "- Add and Subtract\n",
    "- << >>\n",
    "- Bitwise &\n",
    "- Bitwise XOR ^\n",
    "- Bitwise OR|\n",
    "- Comparison, Identity, Membership\n",
    "- Logical - NOT, AND, OR\n",
    "\n",
    "### Statements\n",
    "Assignment statement is when a value is assigned to a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arithmetic operators without variables and expressions\n",
    "a = 5\n",
    "b = 4\n",
    "c = a+b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exponent ( power of)\n",
    "\n",
    "2 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Floor division gives quotient\n",
    "5 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modulus gives remainder\n",
    "5 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 2,4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Expressions - use **\n",
    "c =  a ** b\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assignment operators\n",
    "\n",
    "a += 1 # short cut for a = a+1\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operator Precedence\n",
    "2*3-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Operator Precedence\n",
    "2**3%3//2/1*3-2+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(((((2**3)%3)//2)/1)*3)-2+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-460fe503f4bf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Peter Pan'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mname\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "# Concatenation of name and a - will throw an Error, solve it by casting (see further below)\n",
    "\n",
    "name = 'Peter Pan'\n",
    "name + a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'FrozenFrozen'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenation using the +\n",
    "var = 'Frozen'\n",
    "var + var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'FrozenFrozenFrozen'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplying when variable is a string\n",
    "var*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison operators\n",
    "23 == 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Logical operators\n",
    "True or False and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison and Logical operators\n",
    "4 < 5 and 15 < 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Boolean for empty and non-empty content\n",
    "bool(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BUILT - IN FUNCTIONS \n",
    "\n",
    "There are many built-in functions which do not need modules to be loaded beforehand. Below is a small list out of the many you may find here https://docs.python.org/3/library/functions.html\n",
    "\n",
    "- input : get user input\n",
    "- print : output to the terminal\n",
    "- len : length of the string\n",
    "- int : convert to int\n",
    "- float : convert to float\n",
    "- str : convert to string\n",
    "\n",
    "- range : range of numbers starting from 0 to n, given n\n",
    "- sorted : sort an iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name Rose\n",
      "The length of the name is  4\n"
     ]
    }
   ],
   "source": [
    "# Get input and length\n",
    "artist = input(\"Enter your name \")\n",
    "print(\"The length of the name is \" , len(artist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rose is 27 years old\n"
     ]
    }
   ],
   "source": [
    "age = 27\n",
    "print(artist + \" is \"+str(age)+ ' years old') # example of casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'30 years'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#casting\n",
    "\n",
    "strAge = str(age)+\" years\"\n",
    "strAge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = int(3.4)\n",
    "z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = float(3)\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FLOW CONTROL STATEMENTS\n",
    "\n",
    "### if - elif - else\n",
    "\n",
    "- execute based on a condition\n",
    "- else : if condition fails\n",
    "- elif : need for a condtion other than the one present in the if clause\n",
    "\n",
    "### while\n",
    "\n",
    "- repeated execution based on a condition\n",
    "\n",
    "### for\n",
    "\n",
    "- repeated execution for a certain number of times\n",
    "\n",
    "### continue\n",
    "\n",
    "- jump to beginning of the loop\n",
    "\n",
    "### break\n",
    "\n",
    "- jump out of the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm a minor\n"
     ]
    }
   ],
   "source": [
    "# If condition\n",
    "age = 17\n",
    "if age > 18:\n",
    "    print(\"I'm an adult\")\n",
    "else:\n",
    "    print(\"I'm a minor\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm working\n"
     ]
    }
   ],
   "source": [
    "# elif\n",
    "age = 19\n",
    "if age < 18:\n",
    "    print(\"I'm a minor\")\n",
    "elif age > 70:\n",
    "    print(\"I'm retired\")\n",
    "else:\n",
    "    print(\"I'm working\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# while\n",
    "\n",
    "i = 0\n",
    "while i < 5:\n",
    "    print(i)\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# for\n",
    "for j in range(5): # 0,1,2,3,4\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "# continue : Given numbers between 0 and 10, exclude 2 \n",
    "\n",
    "for i in range(10):\n",
    "  if i == 2:\n",
    "    continue\n",
    "  print(i, end=\" \")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 "
     ]
    }
   ],
   "source": [
    "# break : Given numbers between 0 and 10, print numbers and exit at 2 \n",
    "\n",
    "for i in range(10):\n",
    "  if i == 2:\n",
    "    break\n",
    "  print(i, end=\" \")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 Exit\n"
     ]
    }
   ],
   "source": [
    "# Else for loops : Given numbers between 0 and 10, print numbers, print 'Exit' otherwise\n",
    "\n",
    "for j in range(10):\n",
    "    print(j, end =\" \")\n",
    "else:\n",
    "    print(\"Exit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MODULES\n",
    "\n",
    "- Modules are programs that have functions that can be used in your program\n",
    "- Use **'import'** keyword\n",
    "- Use **'from'** keyword to avoid using the module name in the function call\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.randint(1,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from random import *\n",
    "randint(1,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "from printNum import *\n",
    "n = 100\n",
    "printNum(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INACTIVE\n",
      "-1\n",
      "<enum 'MembershipStatus'>\n"
     ]
    }
   ],
   "source": [
    "from enum import Enum # for symbolic names, one variable and many values to select from\n",
    "\n",
    "class MembershipStatus(Enum):\n",
    "    INACTIVE = -1\n",
    "    ACTIVE = 0\n",
    "\n",
    "print(MembershipStatus.INACTIVE.name)\n",
    "print(MembershipStatus.INACTIVE.value)\n",
    "print(type(MembershipStatus.INACTIVE))"
   ]
  },
  {
   "attachments": {
    "Screen%20Shot%202023-03-25%20at%2011.45.58%20am.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SEQUENCE DATATYPES\n",
    "- Lists, Tuples, Strings, objects returned by range()\n",
    "- Set and Dictionary are hashtable types and hence lookups are faster\n",
    "- Sets might be very faster, however it comes at the cost of memory when there is a large collection of itesm\n",
    "- Tuples are slightly faster than lists since they occupy one memory block as they are immutable\n",
    "![Screen%20Shot%202023-03-25%20at%2011.45.58%20am.png](attachment:Screen%20Shot%202023-03-25%20at%2011.45.58%20am.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "- ordered\n",
    "- sequence\n",
    "- mutable\n",
    "- duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Empty List\n",
    "animals = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['RRR', 'Top Gun', 'Thor']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create list using a constructor\n",
    "\n",
    "movieLst = list((\"RRR\",\"Top Gun\",\"Thor\"))\n",
    "movieLst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'RRR'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access by index\n",
    "movieLst[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another way to initialize\n",
    "animals = ['cat','emu','kangaroo']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kangaroo'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# access last item\n",
    "animals[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('cat', 'emu', 'kangaroo')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# UNPACKING a list\n",
    "animal_1, animal_2, animal_3 = animals\n",
    "animal_1, animal_2, animal_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a list within a list\n",
    "planet=[animals,['plants','human']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['plants', 'human']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planet[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'plants'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "planet[1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'emu']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SLICING from start to end in steps - [startindex:end index:step]\n",
    "animals[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'emu', 'kangaroo']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'kangaroo']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Length \n",
    "len(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bat', 'emu', 'kangaroo']"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Change value\n",
    "animals[0]='bat'\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bat', 'Roadrunner', 'Boar', 'Deer', 'kangaroo']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# expanding list\n",
    "animals[1:2] = [\"Roadrunner\",\"Boar\",'Deer']\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bat',\n",
       " 'Roadrunner',\n",
       " 'Boar',\n",
       " 'Deer',\n",
       " 'kangaroo',\n",
       " 'bat',\n",
       " 'Roadrunner',\n",
       " 'Boar',\n",
       " 'Deer',\n",
       " 'kangaroo',\n",
       " 'bat',\n",
       " 'Roadrunner',\n",
       " 'Boar',\n",
       " 'Deer',\n",
       " 'kangaroo']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bat', 'Roadrunner', 'Boar', 'Deer', 'kangaroo']"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bird', 'duck', 'cat', 'emu', 'kangaroo']"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#add to the list. Does it save to the original list?\n",
    "animals = ['cat','emu','kangaroo']\n",
    "['bird','duck']+animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'emu', 'kangaroo']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# delete value at index\n",
    "del animals[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'kangaroo']"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal at index 0 : cat\n",
      "Animal at index 1 : kangaroo\n"
     ]
    }
   ],
   "source": [
    "#traverse throught a list\n",
    "\n",
    "for i in range(len(animals)):\n",
    "    print('Animal at index '+str(i)+' : '+animals[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal at index 0 : cat\n",
      "Animal at index 1 : kangaroo\n"
     ]
    }
   ],
   "source": [
    "#traverse through a list - preferred if you have the key\n",
    "for k,v in enumerate(animals):\n",
    "    print('Animal at index '+str(k)+ ' : ' + v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Membership operator to check for existence of a value\n",
    "'bat' in animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'cat' not in animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'kangaroo'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.choice(animals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['emu', 'cat', 'kangaroo']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals = ['cat', 'emu', 'kangaroo']\n",
    "random.shuffle(animals)\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List Methods\n",
    "animals.index('cat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['emu', 'cat', 'kangaroo', 'dog']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.append('dog')\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['emu', 'parrot', 'cat', 'kangaroo', 'dog']"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.insert(1,'parrot')\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['emu', 'parrot', 'kangaroo', 'dog']"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#remove value\n",
    "animals.remove('cat') \n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dog', 'emu', 'kangaroo', 'parrot']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.sort()#according to ASCII ordering so uppercase and then lowercase\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dog', 'emu', 'kangaroo', 'parrot', 'Koala']"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.append('Koala')\n",
    "animals\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dog', 'emu', 'kangaroo', 'Koala', 'parrot']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.sort(key=str.lower)\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['parrot', 'kangaroo', 'emu', 'dog', 'Koala']"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.sort(reverse=True)\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Koala', 'dog', 'emu', 'kangaroo', 'parrot']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animals.reverse()\n",
    "animals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Custom sort\n",
    "def mySort(n):\n",
    "    return abs(n-100)\n",
    "\n",
    "a1 = [1,2,3]\n",
    "a1.sort(key=mySort)\n",
    "a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, False, 1, True, 1.2]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List with multiple datatypes\n",
    "\n",
    "diff_typed_list = [0,1,False,True, 1.2]\n",
    "diff_typed_list.sort()\n",
    "diff_typed_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_movies = ['Shazam','Avatar']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['RRR', 'Top Gun', 'Thor', 'Shazam', 'Avatar']"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#extend any Iterable - tuple\n",
    "movieLst.extend(new_movies)\n",
    "movieLst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison of Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'banana'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = ['apple', 'banana']\n",
    "fruits[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "food = ['banana','apple']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fruits are not food\n"
     ]
    }
   ],
   "source": [
    "if fruits == food:\n",
    "    print(\"Fruits are food\")\n",
    "else:\n",
    "    print(\"Fruits are not food\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Healthy meals include fruits\n"
     ]
    }
   ],
   "source": [
    "healthy_meals = fruits\n",
    "if healthy_meals == fruits:\n",
    "    print(\"Healthy meals include fruits\")\n",
    "else:\n",
    "    print(\"These are not healthy meals\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana']"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banana', 'apple']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(fruits,reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['airpods']"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List comprehension\n",
    "# new = [expression for i in iterable if condition == True]\n",
    "\n",
    "tech = ['computer','keyboard','airpods']\n",
    "newLst = [i for i in tech if \"air\" in i]\n",
    "newLst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Shallow and Deep Copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "trees = ['pine','neem','eucalyptus',[1,2,3]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['pine', 'neem', 'eucalyptus', [1, 2, 3]]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Shallow copy\n",
    "cpy_trees1 = copy.copy(trees)\n",
    "trees.append(4)\n",
    "cpy_trees1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['pine', 'neem', 'eucalyptus', [1, 2, 3], 4]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Deep copy\n",
    "\n",
    "cpy_trees2 = copy.deepcopy(trees)\n",
    "cpy_trees2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "- immutable\n",
    "- ordered\n",
    "- duplicates\n",
    "- sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hi', 'hello', 'hola')"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tuple\n",
    "greetings = ('hi','hello','hola')\n",
    "greetings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 20, 30)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tuple using a constructor\n",
    "multiples_of_10 = tuple((10,20,30))\n",
    "multiples_of_10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access by index\n",
    "multiples_of_10[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-99-677557c4a48c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mgreetings\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'HI'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Cannot change value \n",
    "greetings[0] = 'HI'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2 = ('hello')\n",
    "t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hello',)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a single valued tuple - use comma\n",
    "t3 = ('hello',)\n",
    "t3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "capsicum\n",
      "squash\n",
      "['chilly', 'strawberry', 'raspberry']\n"
     ]
    }
   ],
   "source": [
    "# Asterisk - more items that can be fitted\n",
    "\n",
    "produce = (\"capsicum\", \"squash\", \"chilly\", \"strawberry\", \"raspberry\")\n",
    "\n",
    "(green, yellow, *red) = produce\n",
    "\n",
    "print(green)\n",
    "print(yellow)\n",
    "print(red)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "- no duplicates\n",
    "- unordered\n",
    "- mutable (remove and add but can't change item after creation)\n",
    "- unindexed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a set using constructor\n",
    "alphanums = set(('a1','b1','c1'))\n",
    "type(alphanums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a1', 'b1', 'c1'}"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphanums.add('a1') # no duplicates\n",
    "alphanums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a1', 'b1', 'c1', 'd1'}"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add one value the set\n",
    "alphanums.add('d1')\n",
    "alphanums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a1', 'b1', 'c1', 'd1', 'e1', 'f1'}"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add more than one value to the set\n",
    "alphanums.update(['e1','f1'])\n",
    "alphanums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a1', 'b1', 'c1', 'e1', 'f1'}"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# remove\n",
    "alphanums.discard(\"d1\")\n",
    "alphanums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a1', 'b1', 'c1', 'e1'}"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphanums.remove('f1')\n",
    "alphanums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "# discard non-existent value\n",
    "alphanums.discard(\"z1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'z1'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-110-60daf0fe7c32>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# remove non-existent value\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0malphanums\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"z1\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'z1'"
     ]
    }
   ],
   "source": [
    "# remove non-existent value throws an error using 'remove()' unlike discard()\n",
    "alphanums.remove(\"z1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "- key-value pairs\n",
    "- mutable\n",
    "- index / key can be of any datatype\n",
    "- ordered\n",
    "- no duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create using a constructor\n",
    "dict1 = dict({'a':1,'b':2})\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#access by index which is key\n",
    "person = {'name':\"Bheema\",\\\n",
    "          'age':16,'dob':2001}\n",
    "person['age']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name\n",
      "age\n",
      "dob\n"
     ]
    }
   ],
   "source": [
    "# Iterate over keys\n",
    "for i in person.keys():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterate over values\n",
    "for i in person.values():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key is  name  Value is  Bheema\n",
      "Key is  age  Value is  16\n",
      "Key is  dob  Value is  2001\n"
     ]
    }
   ],
   "source": [
    "# Iterate over items\n",
    "for k,v in person.items():\n",
    "    print(\"Key is \",k,\" Value is \",v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Membership in items\n",
    "'name' in person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Membership in keys\n",
    "'name' in person.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person.get('city')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# returns optional values if no key exists\n",
    "\n",
    "person.get('city','Delhi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creates key and sets value, if no key exists\n",
    "person.setdefault('state',\"None\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person['state']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update\n",
    "person.update({'city':'Melbourne'})\n",
    "person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p2 = {'name': 'Bhathri', 'age': 26, 'dob': 1999, 'city': 'Bangalore'}\n",
    "person.update(p2)\n",
    "person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pop\n",
    "name_age = {\n",
    "    \"Anu\" : 16,\n",
    "    \"Babu\" : 18,\n",
    "    \"Cathy\" : 12,\n",
    "    \"Dimple\" : 14,\n",
    "    \"Eftaar\" : 18\n",
    "}\n",
    "\n",
    "name_age.popitem()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pop by Index\n",
    "name_age.pop(\"Babu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete;\n",
    "del name_age[\"Anu\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name_age"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CODING EXERCISE - Count the number of characters given a sentence\n",
    "\n",
    "- Input - I am happy\n",
    "\n",
    "- Output - ' ':2, 'I'=1,'a'=2,'h'=1,'p'=2,'y=1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#count of characters in the sentence\n",
    "sentence = \" I am going to the festival today at 4pm!\"\n",
    "\n",
    "# What datastructure and flow control would you use?\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = {}\n",
    "for char in sentence:\n",
    "    count.setdefault(char,0)\n",
    "    count[char]=count[char]+1\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint # use pip to install pprint\n",
    "pprint.pprint(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pprint.pformat(count))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "- used for text\n",
    "- single or double quotes\n",
    "- ordered\n",
    "- immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monalisa'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = 'Monalisa'\n",
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-112-81eaceb3caad>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-112-81eaceb3caad>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print('Today's weather')\u001b[0m\n\u001b[0m                 ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# use of single quotes in a string when enclosed in a single quote string throws an error\n",
    "print('Today's weather')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today's weather\n"
     ]
    }
   ],
   "source": [
    "# use double quotes to solve the above error\n",
    "print(\"Today's weather\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today's weather\n"
     ]
    }
   ],
   "source": [
    "# use of - escape characters is also a solution\n",
    "print('Today\\'s weather')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Today\\'s weather\n"
     ]
    }
   ],
   "source": [
    "# use r to print the escape characters as-is\n",
    "print(r'Today\\'s weather')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi,\n",
      "It's fine.\n",
      "Thanks.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# print on separate lines\n",
    "print('''Hi,\n",
    "It's fine.\n",
    "Thanks.\n",
    "''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's a nice\r",
      " weather\n"
     ]
    }
   ],
   "source": [
    "# \\r truncates\n",
    "print('It\\'s a nice\\r weather')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's a nice\n",
      "weather\n"
     ]
    }
   ],
   "source": [
    "# \\n new line\n",
    "print('It\\'s a nice\\nweather')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formating Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Monalisa and my age is  19\n"
     ]
    }
   ],
   "source": [
    "# Simple way of printing\n",
    "\n",
    "print(\"My name is\",name,\"and my age is \", age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Monalisa and I am 55 years old\n"
     ]
    }
   ],
   "source": [
    "# Interpolation - use format specifiers\n",
    "age = 55\n",
    "print('My name is %s and I am %s years old'% (name,age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 Wins 3 Loss 4 Ties\n"
     ]
    }
   ],
   "source": [
    "# format strings\n",
    "w = 2\n",
    "l = 3\n",
    "t = 4\n",
    "print('{} Wins {} Loss {} Ties'.format(w,l,t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Monalisa and I am 55 years old\n"
     ]
    }
   ],
   "source": [
    "# f-strings\n",
    "\n",
    "print(f'My name is {name} and I am {age} years old')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a name Ed Sheeran\n",
      "Enter a age 30\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'My name is Ed Sheeran and I am 30'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Template Strings\n",
    "from string import Template\n",
    "c = Template('My name is ${name} and I am ${age}')\n",
    "c.substitute(name = input('Enter a name '),age = int(input('Enter a age ')))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a cityBengaluru\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Destination Bengaluru:-) is beautiful'"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# template strings with concatenated text\n",
    "\n",
    "\n",
    "c = Template('Destination ${city}:-) is beautiful')\n",
    "c.substitute(city = input('Enter a city '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String methods\n",
    "\n",
    "- isalpha, isisalnum, isdecimal, isspace,\n",
    "- islower, isupper,\n",
    "- startswith, endswith\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MONALISA'"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'monalisa'"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.istitle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_phrase = \"World this week\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return first occurance of character\n",
    "long_phrase.find(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return True or False\n",
    "long_phrase.startswith('World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "','"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# join character with list\n",
    "# does not change original value\n",
    "\n",
    "char = ','\n",
    "char.join(['a','b','c'])\n",
    "char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['World this ', 'eek']"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split based on character\n",
    "long_phrase.split('w')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('World this ', 'w', 'eek')"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# partition based on character\n",
    "long_phrase.partition('w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  World this week   '"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "long_phrase.center(20) #rjust, ljust"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   World this week  '"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_phrase = \"   \"+long_phrase+\"  \"\n",
    "long_phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'   World this week'"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_phrase.rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'World this week  '"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_phrase.lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'World this week'"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_phrase.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_phrase = long_phrase.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return occurance of string\n",
    "long_phrase.find('his')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return occurance of string\n",
    "long_phrase.index('his')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return occurance of string\n",
    "long_phrase.find('z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-143-a8c2e4bfb8f5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# throws an error if not found\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlong_phrase\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'z'\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: substring not found"
     ]
    }
   ],
   "source": [
    "# throws an error if not found\n",
    "long_phrase.index('z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'World this Week'"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# replace characters ( source, destination)\n",
    "long_phrase.replace(\"w\",\"W\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}