DS_Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Structures or Derived data Types in Python:\n",
    "\n",
    "Storing multiple values of same or different types under a single name.\n",
    "They are collection of data.\n",
    "\n",
    "1. List\n",
    "2. Tuple\n",
    "3. String\n",
    "4. Dictionary\n",
    "5. Set  \n",
    "In this notebook, we'll discuss indepth on Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple:\n",
    "Tuples are ordered collection of data. Unlike Lists they are immutable.\n",
    "Represented by parenthesis '( )'  \n",
    "```python\n",
    "tuple : (10, 20, 30, 'Hello', -2.0)\n",
    "```\n",
    "\n",
    "Each value in the tuple is called a element  \n",
    "order of elements: index of element  \n",
    "Index - may be positive or negative  \n",
    "\n",
    "|Order (element) | First | Second | Third |...|Last|  \n",
    "|---|---|---|---|---|---|  \n",
    "|Positive Index| 0| 1| 2| ...| n-1|  \n",
    "|Negative Index| -n| -n+1| -n+2| ...| -1|  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a tuple:\n",
    "\n",
    "1. '( )'\n",
    "2. tuple()\n",
    "\n",
    "### 1. '( )'\n",
    "```python\n",
    "l = (10, 20, 30)\n",
    "```  \n",
    "add a comma ',' if tuple is singleton,\n",
    "\n",
    "```python\n",
    "t = (10,)\n",
    "```\n",
    "### 2. tuple()\n",
    "Syntax: \n",
    "```python\n",
    "tuple(iterable = None)\n",
    "```  \n",
    "iterable: any data structures listed above  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 30)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t = (10, 30)\n",
    "print(t)\n",
    "print(type(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t1 = (10,)\n",
    "print(t1)\n",
    "print(type(t1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "t2 = tuple()\n",
    "print(t2)\n",
    "print(type(t2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with tuples:\n",
    "\n",
    "1. Concatenation\n",
    "2. Appending\n",
    "3. Multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Concatenation:\n",
    "Two tuples can be concatenated by using `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30)\n"
     ]
    }
   ],
   "source": [
    "t1 = (10, 20)\n",
    "t2 = (30,)\n",
    "print(t1 + t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Appending:\n",
    "A tuples can be appended to string using `+=` operator or by reassignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30)\n"
     ]
    }
   ],
   "source": [
    "t1 = (10, 20)\n",
    "t2 = (30,)\n",
    "t1 += t2\n",
    "print(t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Tuple Multiplication:\n",
    "Tuple multiplication results a new tuple with repitition. It can be done using `*` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 10, 20, 10, 20, 10, 20, 10, 20)\n"
     ]
    }
   ],
   "source": [
    "t1 = (10, 20)\n",
    "print(t1 * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods or Functions in tuple:\n",
    "There are various methods or functions that are used to work on tuples.  \n",
    "\n",
    "1. map\n",
    "5. filter\n",
    "7. sorted\n",
    "9. index\n",
    "11. reduce\n",
    "12. reversed\n",
    "13. len\n",
    "14. count\n",
    "15. sum\n",
    "16. max\n",
    "17. min\n",
    "18. enumerate\n",
    "20. zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. map:\n",
    "Applies the given function to every element in a iterable.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "map(function, iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "def sample_fn(x):\n",
    "    return x + 2\n",
    "t = [1, 2, 3, 4]\n",
    "t = tuple(map(sample_fn, t))\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. filter:\n",
    "Filters out the elements that match the given condition\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "filter(condition, iterable)\n",
    "```\n",
    "\n",
    "The condition should be given as a function definition which can be mapped to each variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 100)\n"
     ]
    }
   ],
   "source": [
    "t = (1, -1, 0, 3, -10, 100)\n",
    "t2 = tuple(filter(lambda x: x>0, t)) # A Lambda function used for condition\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. sorted:\n",
    "Sorts the given tuple and returns a copy\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "sorted(iterable, key = None, reverse = False)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-10, -1, 0, 10, 20, 50, 100)\n"
     ]
    }
   ],
   "source": [
    "l2 = (10, 20, 50, 0, -10, -1, 100)\n",
    "l2 = tuple(sorted(l2))\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. index:\n",
    "Returns the index of the element in the tuple. If multiple elements exist, it gives the index of first occurrence. If the element is not in the tuple, it raises an error\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "tuple.index(element)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "l = (10, 20, 30, 40, 10)\n",
    "print(l.index(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. reduce:\n",
    "Sequentially applies the elements in the tuple to a function to give the final value. To use this we need to call *functools* module. In depth study of modules will be dealt later\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "reduce(function, tuple)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "def add(x, y):\n",
    "    return x+y\n",
    "\n",
    "l = (10, 20, 30, 40)\n",
    "c = reduce(add, l)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Explanation:\n",
    "*Step 1:*\n",
    "applies 10 and 20 to the function. result = 30\n",
    "\n",
    "*Step 2:*\n",
    "applies the result and next element (30). result = 60\n",
    "\n",
    "*Step 3:*\n",
    "applies the result and next element (40). result = 100\n",
    "\n",
    "End is reached. so the result 100 is returned"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. reversed:\n",
    "Returns iterator object of reversed tuple.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "revrsed(sequence)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 20 10 "
     ]
    }
   ],
   "source": [
    "s = (10, 20, 30)\n",
    "for i in reversed(s):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. len:\n",
    "Returns the length of the given iterable\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "len(iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "list2 = (10, 20, 30, -1, 123, 10.0)\n",
    "print(len(list2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. count:\n",
    "Returns the count of the element specified\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "tuple.count(element)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "l = (10, 20, 30, 10, 20, 25, 20, 50)\n",
    "print(l.count(20))\n",
    "print(l.count(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. sum:\n",
    "Returns the sum elements in the tuple.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "sum(tuple, start = 0)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "l = (10, -10, 20, -30, 40)\n",
    "print(sum(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. max:\n",
    "Returns the maximum value in the tuple.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "max(tuple, key = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n"
     ]
    }
   ],
   "source": [
    "l = (10, 15, 50, 21, -7)\n",
    "print(max(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-7\n"
     ]
    }
   ],
   "source": [
    "l = (10, 15, 50, 21, -7, 7)\n",
    "print(max(l, key=lambda x: x % 5)) # Maximum reminder when divided by 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. min:\n",
    "Returns minimum value in the iterable\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "min(iterable, key = None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-7\n"
     ]
    }
   ],
   "source": [
    "l = (10, 15, 50, 21, -7)\n",
    "print(min(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-7\n"
     ]
    }
   ],
   "source": [
    "l = (10, 15, 50, 21, -7, 10.0)\n",
    "print(min(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. enumerate:\n",
    "Returns the enumerate object for given tuple. An enumerate object is an iterable which contains ordered pair of the form `(index, value)`  \n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "enumerate(iterable, start = 0)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((0, 10), (1, 20), (2, 'Hello'), (3, 'a'), (4, -1))\n"
     ]
    }
   ],
   "source": [
    "l = (10, 20, 'Hello', 'a', -1)\n",
    "print(tuple(enumerate(l)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13. zip:\n",
    "Returns zipped object containing order pairs of elements from given iterables.\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "zip(iterables)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 'Ten') (15, 'Fifteen') (50, 'Fifty') (21, 'Twenty One') (-7, 'Negative Seven')\n"
     ]
    }
   ],
   "source": [
    "l = (10, 15, 50, 21, -7, 8)\n",
    "t = ['Ten', 'Fifteen', 'Fifty', 'Twenty One', 'Negative Seven']\n",
    "print(*zip(l, t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing Elements in a tuple:\n",
    "\n",
    "Elements of a tuple can be accessed using index.\n",
    "\n",
    "*Example:*  \n",
    "Consider a tuple, \n",
    "```python\n",
    "t = (10, 20, 30, 40, 50)\n",
    "```\n",
    "Length = 5\n",
    "\n",
    "| Element | 10 | 20 | 30 | 40 | 50 |  \n",
    "|---|---|---|---|---|---|  \n",
    "|Position| 1| 2| 3| 4| 5|  \n",
    "|Positive Index| 0 | 1 | 2 | 3 | 4 |  \n",
    "|Negative Index| -5 | -4 | -3 | -2 | -1|  \n",
    "\n",
    "Calling $i^{th}$ element:   \n",
    "positive index: t [i-1]  \n",
    "negative index: t [i - 1 - length]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing operator:\n",
    "Used to get / set a sub-tuple of a tuple. Denoted by `[]`\n",
    "\n",
    "Syntax: \n",
    "```python\n",
    "tuple_name[start = 0 : stop = length : step = 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30)\n"
     ]
    }
   ],
   "source": [
    "t = (10, 20, 30, 40)\n",
    "print(t[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing the elements in a tuples:\n",
    "1. Using loops\n",
    "2. Using  * \n",
    "\n",
    "### 1. Looping:\n",
    "Use *for* or *while* loop to access elements.\n",
    "\n",
    "### 2. Using * :\n",
    "Using `*` will convert the tuple elements into individual arguments of print method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40 50 "
     ]
    }
   ],
   "source": [
    "# for loop to get index\n",
    "l = (10, 20, 30, 40, 50)\n",
    "for i in range(len(l)):\n",
    "    print(l[i], end= ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40 50\n"
     ]
    }
   ],
   "source": [
    "# Using *\n",
    "l = (10, 20, 30, 40, 50)\n",
    "print(*l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension in tuples: \n",
    "It follows the form of the mathematical set-builder notation unlike the use of map and filter functions. It is used to create tuples from either an existing one or a completely new tuple.\n",
    " \n",
    "Set bulider form:\n",
    "$\\{x: x ~\\rm{\\epsilon~ iterable}\\}$  \n",
    "Example: \n",
    "```python\n",
    "t = tuple(expression (loops))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 400 900 1600 2500\n",
      "100 400 900 1600 2500\n"
     ]
    }
   ],
   "source": [
    "# comprehension\n",
    "l = [10, 20, 30, 40, 50]\n",
    "s = tuple(i**2 for i in l) # squares of elements in list l using comprehension\n",
    "sq = list(map(lambda x: x**2, l)) # Using map\n",
    "print(*s)\n",
    "print(*sq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-dimensional tuples or matrices:\n",
    "Like Lists, tuples / lists in a tuple is called a multidimensional tuple or nested tuple. They are generally used to store matrices.\n",
    "\n",
    "Example: \n",
    "```python\n",
    "t = ((10, 20, 30), (40, 50, 60))\n",
    "# Two dimensional tuple\n",
    "```\n",
    "\n",
    "### Accessing elements using index:\n",
    "Syntax: \n",
    "```python\n",
    "tuple_name[outermost_tuple_index][inner]...[inner_most_index]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix:\n",
    "A rectangular array of elements. Two dimensional lists or tuples are used to work with matrices.\n",
    "\n",
    "Each row of matrix is stored as a list / tuple\n",
    "\n",
    "Example: \n",
    "```python\n",
    "matrix = ([10, 20, 30], (40, 50, 60))\n",
    "```\n",
    "\n",
    "### Matrix input:\n",
    "Matrix can be taken as input using loops or list comprehension."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output:\n",
    "Output is printed using for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable length argument Tuples:\n",
    "The input given to variable length arguements are gathered together to form a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple Comparison:\n",
    "Python allows usage of relational operators on Tuples.\n",
    "\n",
    "Python compares two tuples using the elements present in them. Whenever a greater element is encounter the boolean value is returned."
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}