py7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tuple\n",
    "Python Tuple is used to store the sequence of immutable Python objects. The tuple is similar to lists since the value of the items stored in the list can be changed, whereas the tuple is immutable, and the value of the items stored in the tuple cannot be changed.\n",
    "\n",
    "## Creating a tuple\n",
    "A tuple can be written as the collection of comma-separated (,) values enclosed with the small () brackets. The parentheses are optional but it is good practice to use. \n",
    "\n",
    "A tuple can be defined as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "<class 'tuple'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "T1 = (101, \"Peter\", 22)    \n",
    "T2 = (\"Apple\", \"Banana\", \"Orange\")     \n",
    "T3 = 10,20,30,40,50  \n",
    "  \n",
    "print(type(T1))  \n",
    "print(type(T2))  \n",
    "print(type(T3))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating a tuple with single element is slightly different. We will need to put comma after the element to declare the tuple.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "tup1 = (\"DataTrained\")  \n",
    "print(type(tup1))  \n",
    "#Creating a tuple with single element   \n",
    "tup2 = (\"DataTrained\",)  \n",
    "print(type(tup2))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple is indexed in the same way as the lists. The items in the tuple can be accessed by using their specific index value.\n",
    "\n",
    "Consider the following example of tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30, 40, 50, 60)\n",
      "tuple1[0] = 10\n",
      "tuple1[1] = 20\n",
      "tuple1[2] = 30\n",
      "tuple1[3] = 40\n",
      "tuple1[4] = 50\n",
      "tuple1[5] = 60\n"
     ]
    }
   ],
   "source": [
    "tuple1 = (10, 20, 30, 40, 50, 60)    \n",
    "print(tuple1)    \n",
    "count = 0    \n",
    "for i in tuple1:    \n",
    "    print(\"tuple1[%d] = %d\"%(count, i))   \n",
    "    count = count+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the tuple elements ...1\n",
      "('1',)\n",
      "tuple1[0] = 1\n"
     ]
    }
   ],
   "source": [
    "# Example - 2\n",
    "tuple1 = tuple(input(\"Enter the tuple elements ...\"))  \n",
    "print(tuple1)    \n",
    "count = 0    \n",
    "for i in tuple1:    \n",
    "    print(\"tuple1[%d] = %s\"%(count, i))   \n",
    "    count = count+1 \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple indexing and slicing\n",
    "\n",
    "A tuple is indexed in the same way as the lists. The items in the tuple can be accessed by using their specific index value.The indexing in the tuple starts from 0 and goes to length(tuple) - 1.\n",
    "\n",
    "The items in the tuple can be accessed by using the index [] operator. Python also allows us to use the colon operator to access multiple items in the tuple.\n",
    "\n",
    "#### Consider the following example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "tuple index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-c97ad0435f77>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# It will give the IndexError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: tuple index out of range"
     ]
    }
   ],
   "source": [
    "\n",
    "tup = (1,2,3,4,5,6,7)  \n",
    "print(tup[0])  \n",
    "print(tup[1])  \n",
    "print(tup[2])  \n",
    "# It will give the IndexError  \n",
    "print(tup[8])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above code, the tuple has 7 elements which denote 0 to 6. We tried to access an element outside of tuple that raised an IndexError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4, 5, 6, 7)\n",
      "(1, 2, 3, 4)\n",
      "(2, 3, 4, 5)\n",
      "(1, 3, 5)\n"
     ]
    }
   ],
   "source": [
    "tuple = (1,2,3,4,5,6,7)  \n",
    "#element 1 to end  \n",
    "print(tuple[1:])  \n",
    "#element 0 to 3 element   \n",
    "print(tuple[:4])  \n",
    "#element 1 to 4 element  \n",
    "print(tuple[1:5])   \n",
    "# element 0 to 6 and take step of 2  \n",
    "print(tuple[0:6:2])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Negative Indexing\n",
    "The tuple element can also access by using negative indexing. The index of -1 denotes the rightmost element and -2 to the second last item and so on.\n",
    "\n",
    "The elements from left to right are traversed using the negative indexing. Consider the following example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "2\n",
      "(3, 4)\n",
      "(1, 2, 3, 4)\n",
      "(4, 5)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "tuple1 = (1, 2, 3, 4, 5)    \n",
    "print(tuple1[-1])    \n",
    "print(tuple1[-4])    \n",
    "print(tuple1[-3:-1])  \n",
    "print(tuple1[:-1])  \n",
    "print(tuple1[-2:])  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting Tuple\n",
    "Unlike lists, the tuple items cannot be deleted by using the del keyword as tuples are immutable. To delete an entire tuple, we can use the del keyword with the tuple name.\n",
    "\n",
    "Consider the following example.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4, 5, 6)\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'tuple1' 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-7-5f3689cb3045>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtuple1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mtuple1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtuple1\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 'tuple1' is not defined"
     ]
    }
   ],
   "source": [
    "tuple1 = (1, 2, 3, 4, 5, 6)    \n",
    "   \n",
    "print(tuple1)    \n",
    "del tuple1    \n",
    "print(tuple1)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Tuple operations\n",
    "The operators like concatenation (+), repetition (*), Membership (in) works in the same way as they work with the list. Consider the following table for more detail.\n",
    "\n",
    "Let's say Tuple t = (1, 2, 3, 4, 5) and Tuple t1 = (6, 7, 8, 9) are declared."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Operator\t           Description\n",
    "\n",
    "Repetition\t    The repetition operator enables the\n",
    "                tuple elements to be repeated \n",
    "                multiple times.\t\n",
    "                \n",
    "                T1*2 = (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)\n",
    "\n",
    "Concatenation\tIt concatenates the tuple mentioned\n",
    "                on either side of the operator.\t\n",
    "                \n",
    "                T1+T2 = (1, 2, 3, 4, 5, 6, 7, 8, 9)\n",
    "                \n",
    "Membership\t    It returns true if a particular item\n",
    "                exists in the tuple otherwise false\t\n",
    "                \n",
    "                print (2 in T1) prints True.\n",
    "                \n",
    "Iteration\t    The for loop is used to iterate over\n",
    "                the tuple elements.\t\n",
    "                \n",
    "                for i in T1: \n",
    "                    print(i)\n",
    "                Output\n",
    "                1\n",
    "                2\n",
    "                3\n",
    "                4\n",
    "                5\n",
    "                \n",
    "Length\t        It is used to get the length of the\n",
    "                tuple.\t\n",
    "                \n",
    "                len(T1) = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Tuple inbuilt functions\n",
    "\n",
    "Function              \tDescription\n",
    "\n",
    "cmp(tuple1, tuple2)\t   It compares two tuples and\n",
    "                       returns true if tuple1 is\n",
    "                       greater than tuple2 otherwise\n",
    "                       false.\n",
    "\n",
    "len(tuple)\t           It calculates the length of\n",
    "                       the tuple.\n",
    "\n",
    "max(tuple)\t           It returns the maximum element\n",
    "                       of the tuple\n",
    "\n",
    "min(tuple)\t           It returns the minimum element\n",
    "                       of the tuple.\n",
    "\n",
    "tuple(seq)\t           It converts the specified\n",
    "                       sequence to the tupl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Where use tuple?\n",
    "Using tuple instead of list is used in the following scenario.\n",
    "\n",
    "1. Using tuple instead of list gives us a clear idea that tuple data is constant and must not be changed.\n",
    "\n",
    "2. Tuple can simulate a dictionary without keys. Consider the following nested structure, which can be used as a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(101, 'John', 22), (102, 'Mike', 28), (103, 'Dustin', 30)]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(101, \"John\", 22), (102, \"Mike\", 28),  (103, \"Dustin\", 30)]  "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "List vs. Tuple\n",
    "\n",
    "List\t                                                                             Tuple\n",
    "\n",
    "1.The literal syntax of list is shown by the [].\t            1.The literal syntax of the tuple is shown by the ().\n",
    "\n",
    "2.The List is mutable.                                        \t2.The tuple is immutable.\n",
    "\n",
    "3.The List has the a variable length.\t                        3.The tuple has the fixed length.\n",
    "\n",
    "4.The list provides more functionality than a tuple.\t        4.The tuple provides less functionality than the list.\n",
    "\n",
    "5.The list is used in the scenario in which we need \n",
    "to store the simple collections with no constraints\n",
    "where the value of the items can be changed.\t                5.The tuple is used in the cases where we need to store\n",
    "                                                                the read-only collections i.e., the value of the items\n",
    "                                                                cannot be changed. It can be used as the key inside \n",
    "                                                                the dictionary.\n",
    "\n",
    "6.The lists are less memory efficient than a tuple.\t            6.The tuples are more memory efficient because of its immutability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}