10-sequences.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## list\n",
    "- A list of comma separated values enclosed within square brackets.\n",
    "- heterogeneous (it can have values of any type)\n",
    "- mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2.5, 'diptangsu', 4, (4+5j)]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2.5, 'diptangsu', 4, 4+5j]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Empty list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = []\n",
      "c = []\n"
     ]
    }
   ],
   "source": [
    "b = []\n",
    "print('b =', b)\n",
    "\n",
    "c = list()\n",
    "print('c =', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Indexing\n",
    "\n",
    "```py\n",
    "a = [12, 32, 4, 39, 24]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| <font size=5>values</font> | <font size=5>12</font> | <font size=5>32</font> | <font size=5>4</font> | <font size=5>39</font> | <font size=5>39</font> |\n",
    "| --- | --- | --- | --- | --- | --- |\n",
    "| <font size=5>+ve indices</font> | <font size=5>0</font> | <font size=5>1</font> | <font size=5>2</font> | <font size=5>3 | <font size=5>4</font> |\n",
    "| <font size=5>-ve indices</font> | <font size=5>-5</font> | <font size=5>-4 | <font size=5>-3</font> | <font size=5>-2</font> | <font size=5>-1</font> |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[-1] = 24\n",
      "a[2] = 4\n",
      "a[-2] = 39\n"
     ]
    }
   ],
   "source": [
    "a = [12, 32, 4, 39, 24]\n",
    "print('a[-1] =', a[-1])  # a[len(a) - 1]\n",
    "print('a[2] =', a[2])\n",
    "print('a[-2] =', a[-2])  # a[len(a) - 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Changing the values in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 200, 3]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "print(a)\n",
    "a[1] = 200\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Length of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length = 6\n"
     ]
    }
   ],
   "source": [
    "a = [1, 3, 2, 5, 4, 6]\n",
    "l = len(a)\n",
    "print('Length =', l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Traversing a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [1, 3, 2, 5, 4, 6]\n",
    "l = len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "2\n",
      "5\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < l:\n",
    "    print(a[i])\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "2\n",
      "5\n",
      "4\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "for i in range(l):\n",
    "    print(a[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Traversing a list in a Pythonic way "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "32\n",
      "4\n",
      "39\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "for value in a:\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### We can add elements to a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### `append` will add an element to the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[1, 2, 3, 4, 10]\n",
      "[1, 2, 3, 4, 10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4]\n",
    "print(len(a))\n",
    "\n",
    "a.append(10)\n",
    "print(a)\n",
    "\n",
    "a.append(20)\n",
    "a.append(30)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Quick question\n",
    "\n",
    "```py\n",
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "a.append(b)\n",
    "print(a)\n",
    "```\n",
    "1. [1, 2, 3, 4, 5, 6]\n",
    "2. [1, 2, 3, [4, 5, 6]]\n",
    "3. Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "\n",
    "a.append(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### How do we add all elements from one list to another list?\n",
    "We use the `extend` function  \n",
    "or  \n",
    "We add the two lists using `+`  \n",
    "or  \n",
    "We use list unpacking  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[4, 5, 6]\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "\n",
    "c = a.extend(b)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# This is a bit advanced\n",
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "\n",
    "c = [*a, *b]\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### insert will insert an element at a particular index in the list\n",
    "```py\n",
    "list.insert(index, object)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 10, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 4]\n",
    "print(a)\n",
    "\n",
    "a.insert(1, 10)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Check if an element is present in a list\n",
    "We use the `in` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 is present\n",
      "121 is absent\n"
     ]
    }
   ],
   "source": [
    "a = [12, 32, 43, 54, 233, 4]\n",
    "\n",
    "n = 12\n",
    "if n in a:\n",
    "    print(n, 'is present')\n",
    "else:\n",
    "    print(n, 'is absent')\n",
    "    \n",
    "n = 121\n",
    "if n in a:\n",
    "    print(n, 'is present')\n",
    "else:\n",
    "    print(n, 'is absent')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Find the frequency of an element of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 2, 2, 4, 2]\n",
    "f = a.count(2)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Find the index of an element of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3, 2, 2, 4, 2]\n",
    "i = a.index(2)  # index of the first occurance of  2\n",
    "print(i)\n",
    "\n",
    "i = a.index(2, 5)  # index of 2 after index 5\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Reverse a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 23, 34, 43]\n",
      "[43, 34, 23, 12]\n"
     ]
    }
   ],
   "source": [
    "a = [12, 23, 34, 43]\n",
    "print(a)\n",
    "a.reverse()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sort a list\n",
    "The built-in sort function uses an algorithm known as [Tim Sort](https://en.wikipedia.org/wiki/Timsort)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[32, 2, 43, 45, 7]\n",
      "[2, 7, 32, 43, 45]\n"
     ]
    }
   ],
   "source": [
    "a = [32, 2, 43, 45, 7]\n",
    "print(a)\n",
    "a.sort()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Slicing\n",
    "\n",
    "```py\n",
    "sliced_list = some_list[<start-index> : <end-index> + 1 : <step>]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "x = a[3:7]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "y = a[2:9:3]\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = a[:5]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6, 7, 8, 9, 100]\n"
     ]
    }
   ],
   "source": [
    "y = a[3:]\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 7, 100]\n"
     ]
    }
   ],
   "source": [
    "x = a[::3]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Extended slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 100]\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "x = a[::-1]  # reversing a list\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Removing an element from a list\n",
    "\n",
    "```py\n",
    "list.remove(value)  # removes value from the list\n",
    "removed_value = list.pop(index)  # removes value at index and returns it\n",
    "last_value = list.pop()  # removes the last value and returns it\n",
    "del list[index]  # deletes value from list at index\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = [1, 2, 3, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 100]\n",
      "[1, 3, 4, 5, 6, 7, 8, 9, 100]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a.remove(2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 4, 5, 6, 7, 8, 9, 100]\n",
      "3 has been removed from the list\n",
      "[1, 4, 5, 6, 7, 8, 9, 100]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "r = a.pop(1)\n",
    "print(r, 'has been removed from the list')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 2, 3, 5]\n",
      "5 has been removed from the list\n",
      "[1, 3, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "r = a.pop()\n",
    "print(r, 'has been removed from the list')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## tuple\n",
    "- A list of comma separated values enclosed within parentheses.\n",
    "- heterogeneous (it can have values of any type)\n",
    "- immutable\n",
    "- supports negative indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "# Empty tuple\n",
    "t = ()\n",
    "print(t)\n",
    "\n",
    "t = tuple()\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 2, 5, 2)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t = (1, 2, 3, 4, 2, 5, 2)\n",
    "print(t)\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-59-88963aa635fa>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length = 7\n",
      "t[2] = 3\n",
      "2 is present 3 times\n",
      "Index of 3 = 2\n"
     ]
    }
   ],
   "source": [
    "print('Length =', len(t))\n",
    "print('t[2] =', t[2])\n",
    "print('2 is present', t.count(2), 'times')\n",
    "print('Index of 3 =', t.index(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Looping over a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "4\n",
      "10\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "t = (3, 2, 4, 10, 2)\n",
    "\n",
    "for i in t:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## str\n",
    "- list of 0 or more characters enclosed within single, double or triple quotes\n",
    "- immutable\n",
    "- supports +ve and -ve indexing\n",
    "- supports slicing\n",
    "\n",
    "\n",
    "- Python does not have a character type\n",
    "- A character is a string of length 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "These are within single quotes\n",
      "\n",
      "These are within double quotes\n",
      "\n",
      "This is a multiline string\n",
      "and can have multiple lines in them\n",
      "and are enclosed within triple quotes\n"
     ]
    }
   ],
   "source": [
    "s1 = 'These are within single quotes'\n",
    "s2 = \"These are within double quotes\"\n",
    "s3 = '''This is a multiline string\n",
    "and can have multiple lines in them\n",
    "and are enclosed within triple quotes'''\n",
    "\n",
    "print(s1, end='\\n\\n')\n",
    "print(s2, end='\\n\\n')\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We can have\n",
      "this in the next line\n",
      "by using the '\\n' escape character sequence\n"
     ]
    }
   ],
   "source": [
    "s = 'We can have\\nthis in the next line\\nby using the \\'\\\\n\\' escape character sequence'\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Diptangsu Goswami\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "s = 'My name is Diptangsu Goswami'\n",
    "print(s)\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Length of a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Diptangsu Goswami\n",
      "Length = 28\n"
     ]
    }
   ],
   "source": [
    "print(s)\n",
    "l = len(s)\n",
    "print('Length =', l) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### We can use extended slicing to reverse a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "revrese\n",
      "eserver\n"
     ]
    }
   ],
   "source": [
    "s = 'revrese'\n",
    "print(s)\n",
    "s = s[::-1]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Looping over a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = 'Loop over me'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n",
      "o\n",
      "o\n",
      "p\n",
      " \n",
      "o\n",
      "v\n",
      "e\n",
      "r\n",
      " \n",
      "m\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "l = len(s)\n",
    "for i in range(l):\n",
    "    print(s[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "cell_style": "split",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n",
      "o\n",
      "o\n",
      "p\n",
      " \n",
      "o\n",
      "v\n",
      "e\n",
      "r\n",
      " \n",
      "m\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for ch in s:\n",
    "    print(ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DiptangsuGoswami\n",
      "Diptangsu Goswami\n"
     ]
    }
   ],
   "source": [
    "name = 'Diptangsu'\n",
    "surname = 'Goswami'\n",
    "\n",
    "person_name = name + surname\n",
    "print(person_name)\n",
    "\n",
    "person_name = name + ' ' + surname\n",
    "print(person_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diptangsu\n",
      "DiptangsuDiptangsuDiptangsuDiptangsu\n"
     ]
    }
   ],
   "source": [
    "print(name)\n",
    "print(name * 4)\n",
    "# 2 * 3 -> 2 + 2 + 2\n",
    "# name * 4 -> name + name + name + name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Count number of occurrences of a particular substring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "s = 'ABCDEFABCEABC'\n",
    "sub = 'ABC'\n",
    "\n",
    "c = s.count(sub)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Get index of a substring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "s = 'my name is diptangsu is dipx'\n",
    "\n",
    "i = s.index('is dipx')\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Replace a substring with another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my nXme is diptXngsu goswXmi\n",
      "my nXme is diptangsu goswami\n"
     ]
    }
   ],
   "source": [
    "s = 'my name is diptangsu goswami'\n",
    "\n",
    "s2 = s.replace('a', 'X')\n",
    "print(s2)\n",
    "\n",
    "s3 = s.replace('a', 'X', 1)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Split a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['my', 'name', 'is', 'diptangsu', 'goswami']\n",
      "\n",
      "my\n",
      "name\n",
      "is\n",
      "diptangsu\n",
      "goswami\n"
     ]
    }
   ],
   "source": [
    "s = 'my name is diptangsu goswami'\n",
    "\n",
    "words = s.split()\n",
    "print(words)\n",
    "print()\n",
    "\n",
    "for word in words:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['my', 'name', 'is', 'diptangsu', 'goswami']\n"
     ]
    }
   ],
   "source": [
    "s = 'my@name@is@diptangsu@goswami'\n",
    "\n",
    "words = s.split('@')\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Join a list of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mynameisdiptangsugoswami\n",
      "my name is diptangsu goswami\n",
      "my____name____is____diptangsu____goswami\n"
     ]
    }
   ],
   "source": [
    "words = ['my', 'name', 'is', 'diptangsu', 'goswami']\n",
    "\n",
    "s = ''.join(words)\n",
    "print(s)\n",
    "\n",
    "s = ' '.join(words)\n",
    "print(s)\n",
    "\n",
    "s = '____'.join(words)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### A few extras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "88\n"
     ]
    }
   ],
   "source": [
    "ascii_value = 67\n",
    "character = chr(ascii_value)\n",
    "print(character)\n",
    "\n",
    "character = 'X'\n",
    "ascii_value = ord(character)\n",
    "print(ascii_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![questions.jpg](img/questions.jpg)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.7.0"
  },
  "livereveal": {
   "scroll": true,
   "theme": "sky"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}