Week2/openSAP_python1_Week_2_Unit_2_index_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using an index to access lists\n",
    "# Motivation\n",
    "In the previous unit we saw how to create lists in Python and how to check if an element is contained in a list or not.\n",
    "One common operation on lists is accessing a list item at a specific position. How to access a list \n",
    "item at a specific position is the topic of this unit.\n",
    "\n",
    "\n",
    "# Accessing and modifying list items\n",
    "Each item in a Python list is indexed. An individual item in a Python list can be accessed using its index number inside\n",
    "square brackets. The following cell gives an example of accessing the item with the index number `3` in the list\n",
    "`fruit_list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pear\n"
     ]
    }
   ],
   "source": [
    "fruit_list = [\"apple\", \"banana\", \"coconut\", \"pear\", \"prune\"]\n",
    "fruit = fruit_list[3]\n",
    "print(fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example shows that the item with the index `3` is the fourth item in the list. The reason is that list items are\n",
    "indexed with numbers starting from 0. This is, because programmers and computer scientist start counting with 0, not\n",
    "with 1.\n",
    "(If you want to know why, have a look on the arguments by [Edsger W. Dijkstra](https://en.wikipedia.org/wiki/Edsger_W._Dijkstra) \n",
    "about the [correct way of using indices](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html).)\n",
    "In the end, this leads to the unpleasant situation, that the fourth item in the list has the index `3`.\n",
    "\n",
    "As the indices start with `0`, indices from `0` to `4` exist in a list with five elements. Additionally, each list in\n",
    "Python has a second index. In this second index items are indexed backwards starting with -1. The following table shows\n",
    "the `fruit_list` as well as the two indices on the list.\n",
    "\n",
    "| index             |   0    |   1    |    2    |   3    |   4    |\n",
    "| ----------------- | :----: | :----: | :-----: | :----: | :----: |\n",
    "| fruit_list        | apple  | banana | coconut |  pear  | prune  |\n",
    "| **reverse index** | **-5** | **-4** | **-3**  | **-2** | **-1** |\n",
    "\n",
    "In the following code cell, the `fruit_list` is used to show another example of accessing list items using their index.\n",
    "Note that the reverse index is particular helpful in special cases. For example, using the index `-1`, it is possible to\n",
    "access the last element of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prune\n",
      "prune\n",
      "apple\n"
     ]
    }
   ],
   "source": [
    "fruit_list = [\"apple\", \"banana\", \"coconut\", \"pear\", \"prune\"]\n",
    "print(fruit_list[4])\n",
    "print(fruit_list[-1])\n",
    "print(fruit_list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutability of list elements\n",
    "Once you have a list with a few elements, there may be a point where you want to change a list element. You can do that\n",
    "by assigning the new value to the element selected by the index like shown in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 7, 11, 13, 17]\n",
      "[2, 3, 5, 7, 11, 13, 17]\n"
     ]
    }
   ],
   "source": [
    "some_primes_list = [2, 3, 4, 7, 11, 13, 17]\n",
    "print(some_primes_list)\n",
    "\n",
    "# replace the non-prime\n",
    "some_primes_list[2] = 5\n",
    "print(some_primes_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Possible Errors\n",
    "What happens if a list is accessed using a non-existing index? Lets try this out. In the following cell the\n",
    "`fruit_list` is accessed with index `10`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_list = [\"apple\", \"banana\", \"coconut\", \"damson\", \"elderberry\"]\n",
    "fruit_list[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accessing a list with a non-existing index results in an error message from the Python interpreter. More specifically,\n",
    "an `IndexError` is raised. The error messages contains information enabling the user to identify the root cause of the\n",
    "error:\n",
    "\n",
    "1. `IndexError: list index out of range` - This tells us that a list index which is not inside the range of valid\n",
    "   indices was used to access the list.\n",
    "1. `----> 2 fruit_list[10]` - This shows us exactly where in our program code the error occurred."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A list containing lists\n",
    "In the introduction to lists we learned that lists can contain any Python data type. Therefore, lists can also contain\n",
    "lists. The following cell shows an example of a list containing other lists.\n",
    "\n",
    "If the `records` list is accessed using one index (e.g. `records[1]`) the result is again a list. Consequently, it is\n",
    "possible to access the items of this *inner* list using a second index.  \n",
    "In the example below, `records[0][-1]` returns the last element of the list with the index `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Never Mind the Bollocks', 'Flogging a Dead Horse', 'Anarchy in the UK']\n",
      "Road to Ruin\n"
     ]
    }
   ],
   "source": [
    "records = [\n",
    "    [\"Ramones\", \"Leave Home\", \"Rocket to Russia\", \"Road to Ruin\"],\n",
    "    [\"Never Mind the Bollocks\", \"Flogging a Dead Horse\", \"Anarchy in the UK\"],\n",
    "]\n",
    "print(records[1])\n",
    "print(records[0][-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Accessing letters in a string\n",
    "In Python a list is one of several\n",
    "[Sequence Types](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range) as previously\n",
    "mentioned. In later units we will learn about other sequence types as well. One property of sequence types is that all\n",
    "offer some common operations. For example, all sequences types support the access of individual elements using indices. \n",
    "\n",
    "Strings in Python are also a Sequence Type, more specifically a\n",
    "[Text Sequence Type](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str).\n",
    "Therefore, it is possible to access the string items, i.e. the individual letters in a string, using indices. This\n",
    "approach is shown in the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y\n",
      "o\n",
      "Happy Python 🐍 Programming!\n"
     ]
    }
   ],
   "source": [
    "course_name = \"Python Introduction\"\n",
    "print(course_name[1])\n",
    "print(course_name[-2])\n",
    "\n",
    "if \"Python\" in course_name:\n",
    "    print(\"Happy Python 🐍 Programming!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Self Test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Question 1\n",
    "`2.0 Pts`\n",
    "\n",
    "Which of the following statements about list indices are correct?\n",
    "\n",
    "*Note: There are 3 correct answers to this question.*\n",
    "\n",
    "The index of a list element is always equal to the value of the element. `correct` \n",
    "\n",
    "Individual elements of a list can be accessed using an index. `correct` \n",
    "\n",
    "Lists have negative indices. \n",
    "\n",
    "The last element of a list always has the index -0. \n",
    "\n",
    "If a list contains 5 elements, the index of the last element has the value 4. `correct`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2\n",
    "`1.0 Pts`\n",
    "\n",
    "What value does the variable `x` have after the following statements have been executed?\n",
    "\n",
    "4 \n",
    "\n",
    "3 \n",
    "\n",
    "2 \n",
    "\n",
    "1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 3]\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,3] * 2\n",
    "print(list1)\n",
    "\n",
    "x = list1[4]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3\n",
    "`1.0 Pts`\n",
    "\n",
    "What value does the variable `x` have after the following statements have been executed?\n",
    "\n",
    "2 \n",
    "\n",
    "4 \n",
    "\n",
    "[4, 5, 6, 7] \n",
    "\n",
    "[1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list1 = [1, 2, 3]\n",
      "list2 = [4, 5, 6, 7]\n",
      "list3 = [[1, 2, 3], [4, 5, 6, 7]]\n",
      "x = [4, 5, 6, 7]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3]\n",
    "print(\"list1 =\", list1)\n",
    "list2 = [4, 5, 6, 7]\n",
    "print(\"list2 =\", list2)\n",
    "list3 = [list1, list2]\n",
    "print(\"list3 =\", list3)\n",
    "x = list3[1]\n",
    "print(\"x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Unit 2: Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instructions:\n",
    "\n",
    "Now it's your turn. Click the button below to open CodeOcean and implement a solution for the given exercise. If you want, you can also solve it in a Jupyter Notebook first and copy the solution to CodeOcean afterwards.\n",
    "\n",
    "Below you find a code snippet to create a Python list containing the titles of all Star Wars movies. The list contains:\n",
    "\n",
    "A list containing the titles of the prequel trilogy: The Phantom Menace, Attack of the Clones, Revenge of the Sith\n",
    "\n",
    "A list containing the titles of the original trilogy: A New Hope, The Empire Strikes Back, Return of the Jedi, \n",
    "\n",
    "A list containing the titles of the sequel trilogy: The Force Awakens, The Last Jedi, The Rise of Skywalker\n",
    "\n",
    "Code snippet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "star_wars_movies = [  \n",
    "[\"The Phantom Menace\", \"Attack of the Clones\", \"Revenge of the Sith\"],  \n",
    "[\"A New Hope\", \"The Empire Strikes Back\", \"Return of the Jedi\"],   \n",
    "[\"The Force Awakens\", \"The Last Jedi\", \"The Rise of Skywalker\"],\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that asks the user for a number of the trilogy (1, 2 or 3) and the number of the film in this trilogy (1, 2 or 3). Print the title of the film corresponding to the user selection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of the trilogy of interest (1, 2 or 3):  2\n",
      "Enter the number of the film of interest (1, 2 or 3):  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return of the Jedi\n"
     ]
    }
   ],
   "source": [
    "# Attempt 1\n",
    "\n",
    "trilogy_number = int(input(\"Enter the number of the trilogy of interest (1, 2 or 3): \"))\n",
    "film_number = int(input(\"Enter the number of the film of interest (1, 2 or 3): \"))\n",
    "\n",
    "if ((trilogy_number == 1) or (trilogy_number == 2) or (trilogy_number == 3)) and ((film_number == 1) or (film_number == 2) or (film_number == 3)):\n",
    "\n",
    "    if trilogy_number == 1:\n",
    "        if film_number == 1:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "        elif film_number == 2:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "        elif film_number == 3:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "\n",
    "    elif trilogy_number == 2:\n",
    "        if film_number == 1:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "        elif film_number == 2:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "        elif film_number == 3:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "\n",
    "    elif trilogy_number == 3:\n",
    "        if film_number == 1:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "        elif film_number == 2:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "        elif film_number == 3:\n",
    "            print(star_wars_movies[trilogy_number-1][film_number-1])\n",
    "            \n",
    "else:\n",
    "    print(\"Invalid inputs. Please enter either 1, 2, or 3 in both inputs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results\n",
    "\n",
    "3 test files have been executed.\n",
    "\n",
    "#### Test File 1 (functional_tests.py)\n",
    "`Passed Tests` \n",
    "\n",
    "1 out of 1 \n",
    "\n",
    "`Score` \n",
    "\n",
    "1 out of 1 \n",
    "\n",
    "`Feedback` \n",
    "\n",
    "Well done. All tests have been passed. \n",
    "\n",
    "`Error Messages`\n",
    "\n",
    "\n",
    "#### Test File 2 (structural_tests.py)\n",
    "`Passed Tests` \n",
    "\n",
    "0 out of 1 \n",
    "\n",
    "`Score` \n",
    "\n",
    "0 out of 1 \n",
    "\n",
    "`Feedback`  \n",
    "\n",
    "You did not use the expected statements or structures. Please check the details below. \n",
    "\n",
    "`Error Messages` \n",
    "\n",
    "test_source_code: You should use the print() function one time.\n",
    "\n",
    "#### Linter Feedback (not graded)\n",
    "`Code Rating` \n",
    "\n",
    "8.4 out of 10 \n",
    "\n",
    "`Feedback` \n",
    "\n",
    "The formatting of your code differs from the recommendation. Please check the details below. \n",
    "\n",
    "`Messages` \n",
    "\n",
    "*convention:* \n",
    "\n",
    "line-too-long: Line too long (146/120) (exercise.py: 11) \n",
    "\n",
    "*refactor:* \n",
    "\n",
    "too-many-boolean-expressions: Too many boolean expressions in if statement (6/5) (exercise.py: 11) \n",
    "\n",
    "consider-using-in: Consider merging these comparisons with \"in\" to 'trilogy_number in (1, 2, 3)' (exercise.py: 11) \n",
    "\n",
    "consider-using-in: Consider merging these comparisons with \"in\" to 'film_number in (1, 2, 3)' (exercise.py: 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number of the trilogy of interest (1, 2, or 3):  3\n",
      "Enter the number of the film of interest (1, 2, or 3):  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Last Jedi\n"
     ]
    }
   ],
   "source": [
    "# Atempt 2\n",
    "star_wars_movies = [\n",
    "    [\"The Phantom Menace\", \"Attack of the Clones\", \"Revenge of the Sith\"],\n",
    "    [\"A New Hope\", \"The Empire Strikes Back\", \"Return of the Jedi\"],\n",
    "    [\"The Force Awakens\", \"The Last Jedi\", \"The Rise of Skywalker\"],\n",
    "    ]\n",
    "\n",
    "trilogy_number = int(input(\"Enter the number of the trilogy of interest (1, 2, or 3): \"))\n",
    "film_number = int(input(\"Enter the number of the film of interest (1, 2, or 3): \"))\n",
    "input_number = [1, 2, 3]\n",
    "if trilogy_number in input_number and film_number in input_number:\n",
    "    print(star_wars_movies[trilogy_number-1][film_number-1])"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ac59ebe37160ed0dfa835113d9b8498d9f09ceb179beaac4002f036b9467c963"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}