PY0101EN-2-1-Tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/IDSNlogo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\"  />\n",
    "</center>\n",
    "\n",
    "# Tuples in Python\n",
    "\n",
    "Estimated time needed: **15** minutes\n",
    "\n",
    "## Objectives\n",
    "\n",
    "After completing this lab you will be able to:\n",
    "\n",
    "*   Perform the basics tuple operations in Python, including indexing, slicing and sorting\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Table of Contents</h2>\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "    <ul>\n",
    "        <li>\n",
    "            <a href=\"https://#dataset\">About the Dataset</a>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"https://#tuple\">Tuples</a>\n",
    "            <ul>\n",
    "                <li><a href=\"https://index/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Indexing</a></li>\n",
    "                <li><a href=\"https://slice/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Slicing</a></li>\n",
    "                <li><a href=\"https://sort/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Sorting</a></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li>\n",
    "            <a href=\"https://#escape\">Quiz on Tuples</a>\n",
    "        </li>\n",
    "    </ul>\n",
    "\n",
    "</div>\n",
    "\n",
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"dataset\">About the Dataset</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine you received album recommendations from your friends and compiled all of the recommendations into a table, with specific information about each album.\n",
    "\n",
    "The table has one row for each movie and several columns:\n",
    "\n",
    "*   **artist** - Name of the artist\n",
    "*   **album** - Name of the album\n",
    "*   **released_year** - Year the album was released\n",
    "*   **length_min_sec** - Length of the album (hours,minutes,seconds)\n",
    "*   **genre** - Genre of the album\n",
    "*   **music_recording_sales_millions** - Music recording sales (millions in USD) on [SONG://DATABASE](http://www.song-database.com/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01)\n",
    "*   **claimed_sales_millions** - Album's claimed sales (millions in USD) on [SONG://DATABASE](http://www.song-database.com/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01)\n",
    "*   **date_released** - Date on which the album was released\n",
    "*   **soundtrack** - Indicates if the album is the movie soundtrack (Y) or (N)\n",
    "*   **rating_of_friends** - Indicates the rating from your friends from 1 to 10\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "The dataset can be seen below:\n",
    "\n",
    "<font size=\"1\">\n",
    "<table font-size:xx-small>\n",
    "  <tr>\n",
    "    <th>Artist</th>\n",
    "    <th>Album</th> \n",
    "    <th>Released</th>\n",
    "    <th>Length</th>\n",
    "    <th>Genre</th> \n",
    "    <th>Music recording sales (millions)</th>\n",
    "    <th>Claimed sales (millions)</th>\n",
    "    <th>Released</th>\n",
    "    <th>Soundtrack</th>\n",
    "    <th>Rating (friends)</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>Michael Jackson</td>\n",
    "    <td>Thriller</td> \n",
    "    <td>1982</td>\n",
    "    <td>00:42:19</td>\n",
    "    <td>Pop, rock, R&B</td>\n",
    "    <td>46</td>\n",
    "    <td>65</td>\n",
    "    <td>30-Nov-82</td>\n",
    "    <td></td>\n",
    "    <td>10.0</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>AC/DC</td>\n",
    "    <td>Back in Black</td> \n",
    "    <td>1980</td>\n",
    "    <td>00:42:11</td>\n",
    "    <td>Hard rock</td>\n",
    "    <td>26.1</td>\n",
    "    <td>50</td>\n",
    "    <td>25-Jul-80</td>\n",
    "    <td></td>\n",
    "    <td>8.5</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Pink Floyd</td>\n",
    "    <td>The Dark Side of the Moon</td> \n",
    "    <td>1973</td>\n",
    "    <td>00:42:49</td>\n",
    "    <td>Progressive rock</td>\n",
    "    <td>24.2</td>\n",
    "    <td>45</td>\n",
    "    <td>01-Mar-73</td>\n",
    "    <td></td>\n",
    "    <td>9.5</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Whitney Houston</td>\n",
    "    <td>The Bodyguard</td> \n",
    "    <td>1992</td>\n",
    "    <td>00:57:44</td>\n",
    "    <td>Soundtrack/R&B, soul, pop</td>\n",
    "    <td>26.1</td>\n",
    "    <td>50</td>\n",
    "    <td>25-Jul-80</td>\n",
    "    <td>Y</td>\n",
    "    <td>7.0</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Meat Loaf</td>\n",
    "    <td>Bat Out of Hell</td> \n",
    "    <td>1977</td>\n",
    "    <td>00:46:33</td>\n",
    "    <td>Hard rock, progressive rock</td>\n",
    "    <td>20.6</td>\n",
    "    <td>43</td>\n",
    "    <td>21-Oct-77</td>\n",
    "    <td></td>\n",
    "    <td>7.0</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Eagles</td>\n",
    "    <td>Their Greatest Hits (1971-1975)</td> \n",
    "    <td>1976</td>\n",
    "    <td>00:43:08</td>\n",
    "    <td>Rock, soft rock, folk rock</td>\n",
    "    <td>32.2</td>\n",
    "    <td>42</td>\n",
    "    <td>17-Feb-76</td>\n",
    "    <td></td>\n",
    "    <td>9.5</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Bee Gees</td>\n",
    "    <td>Saturday Night Fever</td> \n",
    "    <td>1977</td>\n",
    "    <td>1:15:54</td>\n",
    "    <td>Disco</td>\n",
    "    <td>20.6</td>\n",
    "    <td>40</td>\n",
    "    <td>15-Nov-77</td>\n",
    "    <td>Y</td>\n",
    "    <td>9.0</td>\n",
    "  </tr>\n",
    "    <tr>\n",
    "    <td>Fleetwood Mac</td>\n",
    "    <td>Rumours</td> \n",
    "    <td>1977</td>\n",
    "    <td>00:40:01</td>\n",
    "    <td>Soft rock</td>\n",
    "    <td>27.9</td>\n",
    "    <td>40</td>\n",
    "    <td>04-Feb-77</td>\n",
    "    <td></td>\n",
    "    <td>9.5</td>\n",
    "  </tr>\n",
    "</table></font>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"tuple\">Tuples</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, there are different data types: string, integer, and float. These data types can all be contained in a tuple as follows:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesType.png\" width=\"750\" align=\"center\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us create your first tuple with string, integer and float.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('disco', 10, 1.2)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create your first tuple\n",
    "\n",
    "tuple1 = (\"disco\",10,1.2 )\n",
    "tuple1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of variable is a **tuple**.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the type of the tuple you created\n",
    "\n",
    "type(tuple1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"index\">Indexing</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each element of a tuple can be accessed via an index. The following table represents the relationship between the index and the items in the tuple. Each element can be obtained by the name of the tuple followed by a square bracket with the index number:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesIndex.gif\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can print out each value in the tuple:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "disco\n",
      "10\n",
      "1.2\n"
     ]
    }
   ],
   "source": [
    "# Print the variable on each index\n",
    "\n",
    "print(tuple1[0])\n",
    "print(tuple1[1])\n",
    "print(tuple1[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can print out the **type** of each value in the tuple:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# Print the type of value on each index\n",
    "\n",
    "print(type(tuple1[0]))\n",
    "print(type(tuple1[1]))\n",
    "print(type(tuple1[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use negative indexing. We use the same table above with corresponding negative values:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesNeg.png\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can obtain the last element as follows (this time we will not use the print statement to display the values):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use negative index to get the value of the last element\n",
    "\n",
    "tuple1[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can display the next two elements as follows:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use negative index to get the value of the second last element\n",
    "\n",
    "tuple1[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'disco'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use negative index to get the value of the third last element\n",
    "\n",
    "tuple1[-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"concate\">Concatenate Tuples</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can concatenate or combine tuples by using the **+** sign:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('disco', 10, 1.2, 'hard rock', 10)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Concatenate two tuples\n",
    "\n",
    "tuple2 = tuple1 + (\"hard rock\", 10)\n",
    "tuple2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can slice tuples obtaining multiple values as demonstrated by the figure below:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesSlice.gif\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"slice\">Slicing</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can slice tuples, obtaining new tuples with the corresponding elements:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('disco', 10, 1.2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slice from index 0 to index 2\n",
    "\n",
    "tuple2[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can obtain the last two elements of the tuple:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hard rock', 10)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slice from index 3 to index 4\n",
    "\n",
    "tuple2[3:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can obtain the length of a tuple using the length command:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the length of tuple\n",
    "\n",
    "len(tuple2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This figure shows the number of elements:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesElement.png\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"sort\">Sorting</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following tuple:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# A sample tuple\n",
    "\n",
    "Ratings = (0, 9, 6, 5, 10, 8, 9, 6, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can sort the values in a tuple and save it to a new tuple:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 5, 6, 6, 8, 9, 9, 10]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sort the tuple\n",
    "\n",
    "RatingsSorted = sorted(Ratings)\n",
    "RatingsSorted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 id=\"nest\">Nested Tuple</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple can contain another tuple as well as other more complex data types. This process is called 'nesting'. Consider the following tuple with several elements:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create a nest tuple\n",
    "\n",
    "NestedT =(1, 2, (\"pop\", \"rock\") ,(3,4),(\"disco\",(1,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each element in the tuple, including other tuples, can be obtained via an index as shown in the figure:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesNestOne.png\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element 0 of Tuple:  1\n",
      "Element 1 of Tuple:  2\n",
      "Element 2 of Tuple:  ('pop', 'rock')\n",
      "Element 3 of Tuple:  (3, 4)\n",
      "Element 4 of Tuple:  ('disco', (1, 2))\n"
     ]
    }
   ],
   "source": [
    "# Print element on each index\n",
    "\n",
    "print(\"Element 0 of Tuple: \", NestedT[0])\n",
    "print(\"Element 1 of Tuple: \", NestedT[1])\n",
    "print(\"Element 2 of Tuple: \", NestedT[2])\n",
    "print(\"Element 3 of Tuple: \", NestedT[3])\n",
    "print(\"Element 4 of Tuple: \", NestedT[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the second index to access other tuples as demonstrated in the figure:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesNestTwo.png\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the nested tuples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element 2, 0 of Tuple:  pop\n",
      "Element 2, 1 of Tuple:  rock\n",
      "Element 3, 0 of Tuple:  3\n",
      "Element 3, 1 of Tuple:  4\n",
      "Element 4, 0 of Tuple:  disco\n",
      "Element 4, 1 of Tuple:  (1, 2)\n"
     ]
    }
   ],
   "source": [
    "# Print element on each index, including nest indexes\n",
    "\n",
    "print(\"Element 2, 0 of Tuple: \",   NestedT[2][0])\n",
    "print(\"Element 2, 1 of Tuple: \",   NestedT[2][1])\n",
    "print(\"Element 3, 0 of Tuple: \",   NestedT[3][0])\n",
    "print(\"Element 3, 1 of Tuple: \",   NestedT[3][1])\n",
    "print(\"Element 4, 0 of Tuple: \",   NestedT[4][0])\n",
    "print(\"Element 4, 1 of Tuple: \",   NestedT[4][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access strings in the second nested tuples using a third index:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the first element in the second nested tuples\n",
    "\n",
    "NestedT[2][1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the second element in the second nested tuples\n",
    "\n",
    "NestedT[2][1][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a tree to visualise the process. Each new index corresponds to a deeper level in the tree:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesNestThree.gif\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can access elements nested deeper in the tree with a third index:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the first element in the second nested tuples\n",
    "\n",
    "NestedT[4][1][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the second element in the second nested tuples\n",
    "\n",
    "NestedT[4][1][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following figure shows the relationship of the tree and the element <code>NestedT\\[4]\\[1]\\[1]</code>:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesNestFour.gif\" width=\"750\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 id=\"quiz\">Quiz on Tuples</h2>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following tuple:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('pop',\n",
       " 'rock',\n",
       " 'soul',\n",
       " 'hard rock',\n",
       " 'soft rock',\n",
       " 'R&B',\n",
       " 'progressive rock',\n",
       " 'disco')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sample tuple\n",
    "\n",
    "genres_tuple = (\"pop\", \"rock\", \"soul\", \"hard rock\", \"soft rock\", \\\n",
    "                \"R&B\", \"progressive rock\", \"disco\") \n",
    "genres_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the length of the tuple, <code>genres_tuple</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "len(genres_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-PY0101EN-SkillsNetwork/labs/Module%202/images/TuplesQuiz.png\" width=\"1100\" align=\"center\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "len(genres_tuple)\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access the element, with respect to index 3:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hard rock'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "genres_tuple[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "genres_tuple[3]\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use slicing to obtain indexes 3, 4 and 5:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('hard rock', 'soft rock', 'R&B')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "genres_tuple[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "genres_tuple[3:6]\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the first two elements of the tuple <code>genres_tuple</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('pop', 'rock')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "genres_tuple[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "genres_tuple[0:2]\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the first index of <code>\"disco\"</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "genres_tuple.index(\"disco\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "genres_tuple.index(\"disco\")\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate a sorted List from the Tuple <code>C_tuple=(-5, 1, -3)</code>:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-5, -3, 1]\n"
     ]
    }
   ],
   "source": [
    "# Write your code below and press Shift+Enter to execute\n",
    "C_tuple=(-5, 1, -3)\n",
    "print(sorted(C_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "C_tuple = (-5, 1, -3)\n",
    "C_list = sorted(C_tuple)\n",
    "C_list\n",
    "\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Author\n",
    "\n",
    "<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\" target=\"_blank\">Joseph Santarcangelo</a>\n",
    "\n",
    "## Other contributors\n",
    "\n",
    "<a href=\"https://www.linkedin.com/in/jiahui-mavis-zhou-a4537814a?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkPY0101ENSkillsNetwork19487395-2021-01-01\">Mavis Zhou</a>\n",
    "\n",
    "## Change Log\n",
    "\n",
    "| Date (YYYY-MM-DD) | Version | Changed By | Change Description                 |\n",
    "| ----------------- | ------- | ---------- | ---------------------------------- |\n",
    "| 2022-01-10        | 2.1     | Malika     | Removed the readme for GitShare    |\n",
    "| 2020-08-26        | 2.0     | Lavanya    | Moved lab to course repo in GitLab |\n",
    "|                   |         |            |                                    |\n",
    "|                   |         |            |                                    |\n",
    "\n",
    "## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}