004_Python_Tuple.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Datatypes** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** are available @ **[GitHub](https://github.com/milaan9/02_Python_Datatypes)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tuple\n",
    "\n",
    "In this class, you'll learn everything about Python tuples. More specifically, what are tuples, how to create them, when to use them and various methods you should be familiar with."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## What is Tuple in Python?\n",
    "\n",
    "A tuple in Python is similar to a **[list](https://github.com/milaan9/02_Python_Datatypes/blob/main/003_Python_List.ipynb)**. \n",
    "Only the difference is that list is enclosed between **square bracket** **`[]`**, tuple between **parentheses** **`()`** and we cannot change the elements of a tuple once it is assigned, i.e., **immutable** whereas we can change the elements of a list i.e., **mutable**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Python Tuple\n",
    "\n",
    "A tuple is created by placing all the items (elements) inside **parentheses `()`**, separated by **commas `,`**. The parentheses are optional, however, it is a good practice to use them.\n",
    "\n",
    "A tuple can have any number of items and they may be of different types (integer, float, list, **[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)**, etc.).\n",
    "\n",
    "<div>\n",
    "<img src=\"img/t0.png\" width=\"500\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.212519Z",
     "start_time": "2021-10-03T13:20:25.179314Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "(1, 2, 3)\n",
      "(1, 'Hello', 3.4)\n",
      "('mouse', [8, 4, 6], (1, 2, 3))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "# Different types of tuples\n",
    "\n",
    "# Empty tuple\n",
    "my_tuple = ()\n",
    "print(my_tuple)\n",
    "\n",
    "# Tuple having integers\n",
    "my_tuple = (1, 2, 3)\n",
    "print(my_tuple)\n",
    "\n",
    "# tuple with mixed datatypes\n",
    "my_tuple = (1, \"Hello\", 3.4)\n",
    "print(my_tuple)\n",
    "\n",
    "# nested tuple\n",
    "my_tuple = (\"mouse\", [8, 4, 6], (1, 2, 3))\n",
    "print(my_tuple)\n",
    "len(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.335083Z",
     "start_time": "2021-10-03T13:20:25.215448Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 1, 2, 3.14, 'HelloWorld')\n",
      "('a', 'b', 'c', 'd')\n",
      "(1, 2, 3, ['a', 'b', 'c'], ('z', 26))\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "t1=('a','b',1,2,3.14,\"HelloWorld\")\n",
    "t2=\"a\", \"b\", \"c\", \"d\"\n",
    "\n",
    "#tuple contain other list and tuple\n",
    "t3 =(1,2,3,['a','b','c'],('z',26))\n",
    "\n",
    "print(t1)\n",
    "print(t2)\n",
    "print(t3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple can also be created without using parentheses. This is known as tuple packing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.472791Z",
     "start_time": "2021-10-03T13:20:25.340945Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4.6, 'dog')\n",
      "3\n",
      "4.6\n",
      "dog\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "my_tuple = 3, 4.6, \"dog\"\n",
    "print(my_tuple)\n",
    "\n",
    "# tuple unpacking is also possible\n",
    "a, b, c = my_tuple\n",
    "\n",
    "print(a)      # 3\n",
    "print(b)      # 4.6\n",
    "print(c)      # dog"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* For a single valued tuple, there must be a comma **`,`** at the end of the value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.612449Z",
     "start_time": "2021-10-03T13:20:25.476697Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "t1=(5,)\n",
    "print(t1)\n",
    "print(type(t1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a tuple with one element is a bit tricky.\n",
    "\n",
    "Having one element within parentheses is not enough. We will need a trailing comma to indicate that it is, in fact, a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.717435Z",
     "start_time": "2021-10-03T13:20:25.624171Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'tuple'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "my_tuple = (\"hello\")\n",
    "print(type(my_tuple))  # <class 'str'>\n",
    "\n",
    "# Creating a tuple having one element\n",
    "my_tuple = (\"hello\",)\n",
    "print(type(my_tuple))  # <class 'tuple'>\n",
    "\n",
    "# Parentheses is optional\n",
    "my_tuple = \"hello\",\n",
    "print(type(my_tuple))  # <class 'tuple'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Access Tuple Elements\n",
    "\n",
    "There are various ways in which we can access the elements of a tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Indexing\n",
    "\n",
    "We can use the **index operator** **`[]`** to access an item in a tuple, where the index starts from 0.\n",
    "\n",
    "So, a tuple having 6 elements will have indices from 0 to 5. Trying to access an index outside of the tuple index range(6,7,... in this example) will raise an **`IndexError`**.\n",
    "\n",
    "The index must be an integer, so we cannot use float or other types. This will result in **`TypeError`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.840491Z",
     "start_time": "2021-10-03T13:20:25.723783Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p\n",
      "t\n",
      "Last index: 5\n",
      "Last element: t\n"
     ]
    }
   ],
   "source": [
    "# Accessing tuple elements using indexing\n",
    "\n",
    "my_tuple = ('p','e','r','m','i','t')\n",
    "\n",
    "print(my_tuple[0])   # 'p' \n",
    "print(my_tuple[5])   # 't'\n",
    "\n",
    "print(\"Last index:\", len(my_tuple) - 1)\n",
    "print(\"Last element:\", my_tuple[len(my_tuple) - 1])\n",
    "\n",
    "# IndexError: list index out of range\n",
    "# print(my_tuple[6])\n",
    "\n",
    "# Index must be an integer\n",
    "# TypeError: list indices must be integers, not float\n",
    "# my_tuple[2.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.978686Z",
     "start_time": "2021-10-03T13:20:25.844398Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "helloworld\n",
      "xyz\n",
      "1\n",
      "-2\n",
      "3.6\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "t=(\"helloworld\",'xyz',1,-2,3.6)\n",
    "for x in t:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:25.993823Z",
     "start_time": "2021-10-03T13:20:25.984544Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Example: nested tuple\n",
    "\n",
    "n_tuple = (\"mouse\", [8, 4, 6], (1, 2, 3))\n",
    "\n",
    "# nested index\n",
    "print(n_tuple[0][3])       # s\n",
    "print(n_tuple[1][1])       # 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Negative Indexing\n",
    "\n",
    "Python allows negative indexing for its sequences.\n",
    "\n",
    "The index of -1 refers to the last item, -2 to the second last item and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:26.009447Z",
     "start_time": "2021-10-03T13:20:25.997727Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t\n",
      "p\n"
     ]
    }
   ],
   "source": [
    "# Example: Negative indexing for accessing tuple elements\n",
    "\n",
    "my_tuple = ('p', 'e', 'r', 'm', 'i', 't')\n",
    "\n",
    "print(my_tuple[-1])   # Output: 't'\n",
    "print(my_tuple[-6])   # Output: 'p'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "<img src=\"img/t5.png\" width=\"300\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:26.223332Z",
     "start_time": "2021-10-03T13:20:26.013841Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "(7, 4)\n",
      "7\n",
      "(3, 7)\n",
      "(2, 4, 7, 3)\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "t=(3,7,4,2)\n",
    "\n",
    "print(t[2])           # 4\n",
    "print(t[1:3])         # 7,4\n",
    "print(t[-3])          # 7\n",
    "print(t[-4:-2])       # 3,7\n",
    "print(t[-1 :  : -1])  # start from -1 and step =-1 so its basicly return reverse tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Slicing\n",
    "\n",
    "We can access a range of items in a tuple by using the slicing operator **`:`**(colon).\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "tuple[start : stop : step]\n",
    "```\n",
    "by default step is +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:26.362989Z",
     "start_time": "2021-10-03T13:20:26.228702Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('r', 'o', 'g')\n",
      "('p', 'r', 'o')\n",
      "('i', 'n', 'g')\n",
      "('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'n', 'g')\n"
     ]
    }
   ],
   "source": [
    "# Example: Accessing tuple elements using slicing\n",
    "\n",
    "my_tuple = ('p','r','o','g','r','a','m','i','n','g')\n",
    "\n",
    "# elements 2nd to 4th\n",
    "print(my_tuple[1:4])   # Output: ('r', 'o', 'g')\n",
    "\n",
    "# elements beginning to 2nd\n",
    "print(my_tuple[:-7])   # Output: ('p', 'r')\n",
    "\n",
    "# elements 8th to end\n",
    "print(my_tuple[7:])    # Output: ('i', 'z')\n",
    "\n",
    "# elements beginning to end\n",
    "print(my_tuple[:])     # Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'n','g')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing can be best visualized by considering the index to be between the elements as shown below. So if we want to access a range, we need the index that will slice the portion from the tuple.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/t6.png\" width=\"300\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Changing a Tuple\n",
    "\n",
    "Unlike lists, **tuples are immutable**.\n",
    "\n",
    "This means that elements of a tuple cannot be changed once they have been assigned. But, if the element is itself a mutable data type like a list, its nested items can be changed.\n",
    "\n",
    "We can also assign a tuple to different values (reassignment)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:26.516318Z",
     "start_time": "2021-10-03T13:20:26.366893Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 2, 3, [9, 5])\n",
      "('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'n', 'g')\n"
     ]
    }
   ],
   "source": [
    "# Changing tuple values\n",
    "my_tuple = (4, 2, 3, [6, 5])\n",
    "\n",
    "\n",
    "# TypeError: 'tuple' object does not support item assignment\n",
    "# my_tuple[1] = 9\n",
    "\n",
    "# However, item of mutable element can be changed\n",
    "my_tuple[3][0] = 9    # Output: (4, 2, 3, [9, 5])\n",
    "print(my_tuple)\n",
    "\n",
    "# Tuples can be reassigned\n",
    "my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'n', 'g')\n",
    "\n",
    "# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', ''n', 'g')\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use **`+`** operator to combine two tuples. This is called **concatenation**.\n",
    "\n",
    "We can also repeat the elements in a tuple for a given number of times using the **`*`** operator.\n",
    "\n",
    "Both **`+`** and **`*`** operations result in a new tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:26.623261Z",
     "start_time": "2021-10-03T13:20:26.521201Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n",
      "('Repeat', 'Repeat', 'Repeat')\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "# Concatenation\n",
    "print((1, 2, 3) + (4, 5, 6))  # Output: (1, 2, 3, 4, 5, 6)\n",
    "\n",
    "# Repeat\n",
    "print((\"Repeat\",) * 3)       # Output: ('Repeat', 'Repeat', 'Repeat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:26.778056Z",
     "start_time": "2021-10-03T13:20:26.629119Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 'x', 'y', 'z')\n",
      "(1, 2, 3, 1, 2, 3)\n",
      "('x', 'y', 'z', 'x', 'y', 'z', 'x', 'y', 'z')\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "t1=(1,2,3)\n",
    "t2=('x','y','z')\n",
    "t3=t1+t2\n",
    "print(t3)\n",
    "print(t1*2)\n",
    "print(t2*3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:26.931386Z",
     "start_time": "2021-10-03T13:20:26.780985Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 'abc', 'xyz', 'hey')\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "t1 = (1, 2,3)\n",
    "t2 = ('abc', 'xyz')\n",
    "\n",
    "# Following action is not valid for tuples\n",
    "# t1[0] = 4;\n",
    "# So let's create a new tuple as follows\n",
    "t3 = t1 + t2 + (\"hey\",)  # () is must when adding or multiply tuples\n",
    "print (t3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Deleting a Tuple\n",
    "\n",
    "As discussed above, we cannot change the elements in a tuple. It means that we cannot delete or remove items from a tuple.\n",
    "\n",
    "Deleting a tuple entirely, however, is possible using the keyword **[del](https://github.com/milaan9/01_Python_Introduction/blob/main/Python_Keywords_List.ipynb)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:27.619422Z",
     "start_time": "2021-10-03T13:20:26.934805Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'my_tuple' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-568bebe8ebeb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[1;31m# NameError: name 'my_tuple' is not defined\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_tuple\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'my_tuple' is not defined"
     ]
    }
   ],
   "source": [
    "# Example 1: Deleting tuples\n",
    "\n",
    "my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'n', 'g')\n",
    "\n",
    "# can't delete items\n",
    "# TypeError: 'tuple' object doesn't support item deletion\n",
    "# del my_tuple[3]\n",
    "\n",
    "# Can delete an entire tuple\n",
    "del my_tuple\n",
    "\n",
    "# NameError: name 'my_tuple' is not defined\n",
    "print(my_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:45.518587Z",
     "start_time": "2021-10-03T13:20:45.493198Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('helloWorld', 'python', 1, 2.7)\n",
      "After deleting t :\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 't' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-965174e3758e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m;\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"After deleting t :\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 't' is not defined"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "t = ('helloWorld', \"python\", 1, 2.7);\n",
    "\n",
    "print (t)\n",
    "\n",
    "# can't delete items\n",
    "# TypeError: 'tuple' object doesn't support item deletion\n",
    "# del my_tuple[3]\n",
    "\n",
    "del t;\n",
    "print (\"After deleting t :\")\n",
    "print (t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Built-in Tuple Functions\n",
    "\n",
    "| Function | Description |\n",
    "|:----| :--- |\n",
    "| **[len()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/040_Python_len%28%29.ipynb)** |  Returns number of elements in a tuple. | \n",
    "| **[max()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/041_Python_max%28%29.ipynb)** |  Returns item from the tuple with max value. | \n",
    "| **[min()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/042_Python_min%28%29.ipynb)** |  Returns item from the tuple with min value.  | \n",
    "| **[sorted()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/060_Python_sorted%28%29.ipynb)** |  Returns a new sorted list of sequence in the tuple. | \n",
    "| **tuple()** |  Converts a sequence into tuple.  | \n",
    "| **cmp()** |  Compares items of two tuples. (Not available in Python 3).  | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`len(tuple)`** - The `len()` method returns the number of elements in the tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:48.359114Z",
     "start_time": "2021-10-03T13:20:48.348370Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "t1= (1,2,3,4,5)\n",
    "t2 = ('x','y','z',[1,2],3)\n",
    "print(len(t1))\n",
    "print(len(t2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`max(tuple)`** - The `max()` method returns the elements from the tuple with maximum value. Type of element should be same otherwise complier throw `TypeError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:49.362113Z",
     "start_time": "2021-10-03T13:20:49.349414Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "z\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "t1= (1,2,3,4,5)\n",
    "t2 = ('x','y','z')\n",
    "print(max(t1))\n",
    "print(max(t2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`min(tuple)`** - The `min()` method returns the elements from the tuple with minimum value. Type of element should be same otherwise complier throw `TypeError`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:50.532114Z",
     "start_time": "2021-10-03T13:20:50.524300Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "x\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "t1= (1,2,3,4,5)\n",
    "t2 = ('x','y','z')\n",
    "print(min(t1))\n",
    "print(min(t2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`sorted(dict)`** - The `sorted()` function sorts the elements of a given iterable in a specific order (either **ascending** or **descending**) and returns the sorted iterable as a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:51.132248Z",
     "start_time": "2021-10-03T13:20:51.116627Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'e', 'i', 'o', 'u']\n",
      "['u', 'o', 'i', 'e', 'a']\n"
     ]
    }
   ],
   "source": [
    "# vowels tuple\n",
    "py_tuple = ('e', 'a', 'u', 'o', 'i')\n",
    "print(sorted(py_tuple))\n",
    "print(sorted(py_tuple, reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`tuple(seq)`** - The `tuple()` method converts a list of items into tuples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:51.858862Z",
     "start_time": "2021-10-03T13:20:51.839333Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd')\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "s=\"helloworld\"\n",
    "t1=tuple(s)\n",
    "list=[1,2,3]\n",
    "t2=tuple(list)\n",
    "\n",
    "print(t1)\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple Methods\n",
    "\n",
    "Methods that add items or remove items are not available with tuple. Only the following two methods are available.\n",
    "\n",
    "Some examples of Python tuple methods:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:52.503440Z",
     "start_time": "2021-10-03T13:20:52.492699Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "my_tuple = ('a', 'p', 'p', 'l', 'e',)\n",
    "\n",
    "print(my_tuple.count('p'))  # Output: 2\n",
    "print(my_tuple.index('l'))  # Output: 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a complete list of all the **[built-in methods to work with Tuples in Python](https://github.com/milaan9/02_Python_Datatypes/tree/main/004_Python_Tuple_Methods)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Tuple Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Tuple Membership Test\n",
    "\n",
    "We can test if an item exists in a tuple or not, using the keyword **`in`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:53.796496Z",
     "start_time": "2021-10-03T13:20:53.775009Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Example: Membership test in tuple\n",
    "\n",
    "my_tuple = ('a', 'p', 'p', 'l', 'e',)\n",
    "\n",
    "# In operation\n",
    "print('a' in my_tuple)\n",
    "print('b' in my_tuple)\n",
    "\n",
    "# Not in operation\n",
    "print('g' not in my_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Iterating Through a Tuple\n",
    "\n",
    "We can use a **`for`** loop to iterate through each item in a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-03T13:20:54.393216Z",
     "start_time": "2021-10-03T13:20:54.383451Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello John\n",
      "Hello Kate\n"
     ]
    }
   ],
   "source": [
    "# Example: Using a for loop to iterate through a tuple\n",
    "\n",
    "for name in ('John', 'Kate'):\n",
    "    print(\"Hello\", name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why should we use Tuple? (Advantages of Tuple)\n",
    "\n",
    "* Processing of Tuples are **faster** than Lists. \n",
    "* It makes the data **safe** as Tuples are **immutable** and hence cannot be changed.\n",
    "* Tuples are used for **string formatting**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advantages of Tuple over List\n",
    "\n",
    "Since tuples are quite similar to lists, both of them are used in similar situations. However, there are certain advantages of implementing a tuple over a list. Below listed are some of the main advantages:\n",
    "\n",
    "* We generally use tuples for heterogeneous (different) data types and lists for homogeneous (similar) data types.\n",
    "\n",
    "* Since tuples are immutable, iterating through a tuple is faster than with list. So there is a slight performance boost.\n",
    "\n",
    "* Tuples that contain immutable elements can be used as a key for a dictionary. With lists, this is not possible.\n",
    "\n",
    "* If you have data that doesn't change, implementing it as tuple will guarantee that it remains write-protected.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Tuple</span>\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
    "\n",
    "1. Create a tuple containing names of **`fruits`** and **`vegetables`**\n",
    "2. Join **`fruits`** and **`vegetables`** tuples and assign it to **`fruits_vegetables`**\n",
    "3. How many **`fruits_vegetables`** do you have?\n",
    "4. Modify the **`fruits_vegetables`** tuple and add the name of your favorite mushroom and beverage and assign it to **`food_tuple`**\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
    "\n",
    "1. Unpack **`fruits_vegetables`** and mushroom and beverage from **`food_tuple`**\n",
    "2. Change the about **`food_tuple`** tuple to a **`food_list`** list\n",
    "3. Slice out the middle item or items from the **`food_tuple`** tuple or **`food_list`** list.\n",
    "4. Slice out the first three items and the last three items from **`food_list`** list\n",
    "5. Delete the **`food_tuple`** tuple completely\n",
    "6. Check if an item exists in tuple:\n",
    "    - Check if **`'Finland'`** is a asian country\n",
    "    - Check if **`'India'`** is a asian country\n",
    "    ```python\n",
    "asian_countries = ('India','China','Singapore','Thailand','Indonesia')\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}