09-lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8z5cONg8rUrX",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists\n",
    "\n",
    "## Programming Fundamentals (NB09)\n",
    "\n",
    "### MIEIC/2020-21\n",
    "\n",
    "#### João Correia Lopes\n",
    "\n",
    "FEUP/DEI and INESC TEC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MZzE7pYorju5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Goals\n",
    "\n",
    "By the end of this class, the student should be able to:\n",
    "\n",
    "- Describe the use of lists, which are sequences of elements of\n",
    "    different types\n",
    "\n",
    "- Enumerate the main methods available to work with lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eR5Lh1jNroE2",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bibliography\n",
    "\n",
    "- Peter Wentworth, Jeffrey Elkner, Allen B. Downey, and Chris Meyers, *How to Think Like a Computer Scientist — Learning with Python 3* (Section 5.3)\n",
    "\n",
    "- Brad Miller and David Ranum, Learning with Python: Interactive Edition. Based on material by Jeffrey Elkner, Allen B. Downey, and Chris Meyers (Chapter 10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rc7T5CsYRHFI",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Data types: Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LRXkCaElRLHq",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### A compound data type (recap)\n",
    "\n",
    "- So far we have seen built-in types like `int`, `float`, `bool`,\n",
    "    `str` and we've seen lists and pairs\n",
    "\n",
    "- Strings, **lists**, and tuples are qualitatively different from the\n",
    "    others because they are made up of smaller pieces\n",
    "\n",
    "- **Lists (and tuples) group any number of items, of different types,\n",
    "    into a single compound value**\n",
    "\n",
    "- Types that comprise smaller pieces are called **collections** or\n",
    "    **compound data types**\n",
    "\n",
    "- Depending on what we are doing, we may want to treat a compound data\n",
    "    type as a single thing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "f8Wk_NqPR0nW",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.1 List values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4RMWAXZYStBQ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Lists\n",
    "\n",
    "- A **list** is an ordered collection of values\n",
    "\n",
    "- The values that make up a list are called its **elements**, or its\n",
    "    **items**\n",
    "\n",
    "- Lists are similar to strings (which are ordered collections of characters) except that the elements of a list can have any type and for any one list, the items can be of **different types**.\n",
    "\n",
    "- Lists and strings --- and other collections that maintain the order\n",
    "    of their items --- are called **sequences**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l_O2Pi9gSxNe",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### List values\n",
    "\n",
    "- There are several ways to create a new list\n",
    "\n",
    "```\n",
    "  numbers = [10, 20, 30, 40]\n",
    "\n",
    "  words = [\"spam\", \"bungee\", \"swallow\"]\n",
    "\n",
    "  stuffs = [\"hello\", 2.0, 5, [10, 20]]\n",
    "```\n",
    "\n",
    "- A list within another list is said to be **nested**\n",
    "\n",
    "- A list with no elements is called an **empty list**, and is denoted\n",
    "    `[]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5zKCHQcp-tAS",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "stuffs = [\"hello\", 2.0, 5, [10, 20]]\n",
    "print(stuffs)\n",
    "type(stuffs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KCh9yTzy-8G7",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vocabulary = [\"iteration\", \"selection\", \"control\"]\n",
    "numbers = [17, 123]\n",
    "mixed_list = [\"hello\", 2.0, 5*2, [10, 20]]\n",
    "empty = []\n",
    "\n",
    "print(numbers)\n",
    "print(mixed_list)\n",
    "print(empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "newlist = [ numbers, vocabulary ]\n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5QMxKSY0R3hS",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.2 Accessing elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "arv8GzZoS5BX",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Index operator\n",
    "\n",
    "- The syntax for accessing the elements of a list is the index\n",
    "    operator: `[]`\n",
    "\n",
    "    - the syntax is the same as the syntax for accessing the\n",
    "        characters of a string\n",
    "\n",
    "- The expression inside the brackets specifies the index\n",
    "\n",
    "- Remember that the indices start at 0\n",
    "\n",
    "- Negative numbers represent reverse indexing\n",
    "\n",
    "```\n",
    "  >>> numbers = [10, 20, 30, 40]\n",
    "    \n",
    "  >>> numbers[1]\n",
    "  >>> numbers[-3]\n",
    "```\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/09/lindex.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "h5RlS9e1EfQS",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "numbers = [17, 123, 87, 34, 66, 8398, 44]\n",
    "print(numbers[2])\n",
    "print(numbers[9 - 8])\n",
    "print(numbers[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M9s2nWLM_Nxa",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### List traversal\n",
    "\n",
    "It is common to use a loop variable as a list index as in the following:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "q_znilvP_Ue7",
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "horsemen = [\"war\", \"famine\", \"pestilence\", \"death\"]\n",
    "for i in [0, 1, 2, 3]:\n",
    "    print(horsemen[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "But, sometimes, there is no need for indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OJ03Mz3Q_jXC",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "horsemen = [\"war\", \"famine\", \"pestilence\", \"death\"]\n",
    "for h in horsemen:\n",
    "    print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fMCaltwJS_UV",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## 5.3.3 List length\n",
    "\n",
    "- The function `len` returns the length of a list, which is equal to\n",
    "    the number of its elements\n",
    "\n",
    "- It is a good idea to use this value as the upper bound of a loop, as\n",
    "    it accommodates changes in the list\n",
    "\n",
    "```\n",
    "   horsemen = [\"war\", \"famine\", \"pestilence\", \"death\"]\n",
    "\n",
    "   for i in range(len(horsemen)):\n",
    "       print(horsemen[i])\n",
    "\n",
    "   len([\"car makers\", 1, [\"Ford\", \"Toyota\", \"BMW\"], [1, 2, 3]])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kDmbSaLP_s8G",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "horsemen = [\"war\", \"famine\", \"pestilence\", \"death\"]\n",
    "\n",
    "for i in range(len(horsemen)):\n",
    "    print(horsemen[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "q-KJEYHt_2Zw",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try the following and explain the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VR5Msk0p_xE5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "len([\"car makers\", 1, [\"Ford\", \"Toyota\", \"BMW\"], [1, 2, 3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "m0B9nY_CEOw2",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list =  [\"hello\", 2.0, 5, [10, 20]]\n",
    "print(len(a_list))\n",
    "print(len(['spam!', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ermJ2531TDb3",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.4 List membership\n",
    "\n",
    "- `in` and `not in` are Boolean operators that test membership in a\n",
    "    sequence\n",
    "\n",
    "```\n",
    "  >>> horsemen = [\"war\", \"famine\", \"pestilence\", \"death\"]\n",
    "  >>> \"pestilence\" in horsemen\n",
    "  True\n",
    "  >>> \"debauchery\" in horsemen\n",
    "  False\n",
    "  >>> \"debauchery\" not in horsemen\n",
    "  True\n",
    "```\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/09/students.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Think about the result, before trying the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YXsTW9jBEscR",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a_list = [3, 67, \"cat\", [56, 57, \"dog\"], [ ], 3.14, False]\n",
    "print(3.14 in a_list)\n",
    "print(\"dog\" in a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AOxgzxP-AnYB",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Nested loop revisited"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "u09W84uVATr_",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Count how many students are taking \"CompSci\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bFKD12tvALyw",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "students = [\n",
    "    (\"John\", [\"CompSci\", \"Physics\"]),\n",
    "    (\"Vusi\", [\"Maths\", \"CompSci\", \"Stats\"]),\n",
    "    (\"Jess\", [\"CompSci\", \"Accounting\", \"Economics\", \"Management\"]),\n",
    "    (\"Sarah\", [\"InfSys\", \"Accounting\", \"Economics\", \"CommLaw\"]),\n",
    "    (\"Zuki\", [\"Sociology\", \"Economics\", \"Law\", \"Stats\", \"Music\"])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pjoopDoGAZKn",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "counter = 0\n",
    "for name, subjects in students:\n",
    "    if \"CompSci\" in subjects:\n",
    "        counter += 1\n",
    "\n",
    "print(\"The number of students taking CompSci is\", counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qM1SumtITJ8K",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.5 List operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The `+` operator\n",
    "\n",
    "- The `+` operator concatenates lists:\n",
    "\n",
    "```\n",
    "   >>> a = [1, 2, 3]\n",
    "   >>> b = [4, 5, 6]\n",
    "   >>> c = a + b\n",
    "   >>> c\n",
    "   [1, 2, 3, 4, 5, 6]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WP5eGCdBBJWb",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "first_list = [1, 2, 3]\n",
    "second_list = [4, 5, 6]\n",
    "both_lists = first_list + second_list\n",
    "print(both_lists)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oocpeePbTNdh",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The `*` operator\n",
    "\n",
    "- Similarly, the `*` operator repeats a list a given number of times:\n",
    "\n",
    "```\n",
    "   >>> [0] * 4\n",
    "   [0, 0, 0, 0]\n",
    "   >>> [1, 2, 3] * 3\n",
    "   [1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "l8wBm0zXBQeA",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print([0] * 4)\n",
    "print([1, 2, 3] * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TWy4ShB5SF5B",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.6 List slices\n",
    "\n",
    "- The slice operations we saw previously with strings let us work with\n",
    "    sublists:\n",
    "\n",
    "```\n",
    "   >>> a_list = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n",
    "   >>> a_list[1:3]\n",
    "   ['b', 'c']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4JXyeeFTxWeU",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n",
    "a_list[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VKhkbTMExrzV",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "g_R8jLZpxqKh",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6XZ-iIXqTWoN",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.7 Lists are mutable\n",
    "\n",
    "- Unlike strings, lists are **mutable**, which means we can change their\n",
    "    elements\n",
    "\n",
    "- An assignment to an element of a list is called **item assignment**\n",
    "\n",
    "```\n",
    "   >>> fruit = [\"banana\", \"apple\", \"quince\"]\n",
    "   >>> fruit[0] = \"pear\"\n",
    "   >>> fruit[2] = \"orange\"\n",
    "   >>> fruit\n",
    "   ['pear', 'apple', 'orange']\n",
    "```\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/09/lassign.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "L2CJnl79yv_4",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a_list = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n",
    "a_list[1:3] = []\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tdtBDNFazDI3",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list = [\"a\", \"d\", \"f\"]\n",
    "a_list[1:1] = [\"b\", \"c\"]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "O2I1HopPzJrL",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list[4:4] = [\"e\"]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4HEq24kPTdRz",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.8 List deletion\n",
    "\n",
    "- Using slices to delete list elements can be error-prone\n",
    "\n",
    "- The `del` statement removes an element from a list\n",
    "\n",
    "```\n",
    "   >>> a = [\"one\", \"two\", \"three\"]\n",
    "   >>> del a[1]\n",
    "   >>> a\n",
    "   [\"one\", \"three\"]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "83Yid19Szfh3",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a_list = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n",
    "del a_list[1:5]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dpPRsprnSPDZ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.9 Objects and references"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TCWAo1zKTma2",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Objects and references with strings\n",
    "\n",
    "- Since strings are *immutable*, Python optimizes resources by making\n",
    "    two names that **refer** to the same string value refer to the same\n",
    "    object\n",
    "\n",
    "```\n",
    "   >>> a = \"banana\"\n",
    "   >>> b = \"banana\"\n",
    "   >>> a is b\n",
    "   True\n",
    "```\n",
    "![banana](images/09/banana.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ToYnko-L03A8",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Objects and references with lists\n",
    "\n",
    "-  But, with lists, that's not the case!\n",
    "\n",
    "```\n",
    "   >>> a = [1, 2, 3]\n",
    "   >>> b = [1, 2, 3]\n",
    "   >>> a == b\n",
    "   True\n",
    "   \n",
    "   >>> a is b\n",
    "   False\n",
    "```\n",
    "\n",
    "![lists](images/09/lists.png)\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/09/references.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BQuGGbIl1hSl",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Another example\n",
    "\n",
    "-  a and b have the same value but do not refer to the same object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pXax2TYp1Kiy",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [81, 82, 83]\n",
    "b = [81, 82, 83]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_HmHC5aXGKvo",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![references](images/09/refs.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KVe9UbgfGJuZ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IUv51SXM1Yay",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SUcA8Ecc5xFU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Repetition and References\n",
    "\n",
    "\n",
    "With a list, the repetition operator creates copies of the references."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yIcJj0Pu5s6n",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "origlist = [45, 76, 34, 55]\n",
    "print(origlist * 3)\n",
    "\n",
    "newlist = [origlist] * 3\n",
    "\n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uNCSSMZ96Oiq",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![repetition](images/09/repetition.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "y6cwa5tE7FxU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "origlist[1] = 99\n",
    "\n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zq0Lbbc77Wl5",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![alises2](images/09/alias2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Hc6u-ou-TsRT",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.10 Aliasing\n",
    "\n",
    "- Since variables refer to objects, if we assign one variable to\n",
    "    another, both variables refer to the same object\n",
    "\n",
    "- Although this behavior can be useful, it is sometimes unexpected or\n",
    "    undesirable\n",
    "\n",
    "```\n",
    "   >>> a = [1, 2, 3]\n",
    "   >>> b = a\n",
    "\n",
    "   >>> a is b\n",
    "   True\n",
    "\n",
    "   >>> b[0] = 5\n",
    "   >>> a\n",
    "   [5, 2, 3]\n",
    "```\n",
    "![aliases](images/09/lists2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oNkR6p9a2Ik1",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Whatch out with aliases!\n",
    "\n",
    "- Because the same list has two different names, `a` and `b`, we say that it is **aliased**. \n",
    "- Changes made with one alias affect the other:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lNMLH9nK2ULT",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = [81, 82, 83]\n",
    "b = a\n",
    "print(b is a)\n",
    "b[0] = 85\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9JMjWESdGpDE",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Alias\n",
    "\n",
    "![alias](images/09/alias.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WSUtXtyXoxi1",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The use of aliases\n",
    "\n",
    "Why would you want to refer to one and the same variable by two different names? \n",
    "\n",
    "- Ordinarily, you don't. \n",
    "\n",
    "- However, some Python programming constructs automatically make use of aliases. \n",
    "\n",
    "- Actually, function argument identifiers are actually an alias to the variable they represent outside the function, with some consequences.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xFlvXvekTwC5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.3.11 Cloning lists\n",
    "\n",
    "- If we want to modify a list and also keep a copy of the original\n",
    "\n",
    "- The easiest way to **clone** a list is to use the slice operator\n",
    "\n",
    "```\n",
    "   >>> a = [1, 2, 3]\n",
    "   >>> b = a[:]       # considered bad practice\n",
    "   >>> c = a.copy()   # better in Python3\n",
    "   \n",
    "   >>> b\n",
    "   [1, 2, 3]\n",
    "\n",
    "   >>> b[0] = 5\n",
    "\n",
    "   >>> a\n",
    "   [1, 2, 3]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7HuEiSwP2nj1",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Z4F8ZZl32qEh",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a.copy()   # get a clone of a\n",
    "print(b is a)  # is it the same object?\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aBqqPS7A25Ns",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Now we are free to make changes to `b` without worrying that we’ll inadvertently be changing `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5CG3sd1s27TE",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "b[0] = 5\n",
    "print(\"b =\", b)\n",
    "print(\"a =\", a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sW8Kg_ma4j8r",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To see it all, go to [Python tutor](http://www.pythontutor.com/visualize.html#code=a%20%3D%20%5B81,%2082,%2083%5D%0Ab%20%3D%20%5B81,%2082,%2083%5D%0A%0Aprint%28a%20%3D%3D%20b%29%0Aprint%28a%20is%20b%29%0A%0Ab%20%3D%20a%0Aprint%28a%20%3D%3D%20b%29%0Aprint%28a%20is%20b%29%0A%0Ab%5B0%5D%20%3D%205%0Aprint%28a%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false), now!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wJHg8Bf1SlGl",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using `zip()`\n",
    "\n",
    "![zip](images/09/zip.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JIv668tJhXdI",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `zip()`\n",
    "\n",
    "- `zip()` is available in the built-in namespace\n",
    "\n",
    "- According to [the official documentation](https://docs.python.org/3/library/functions.html#zip), Python’s `zip()` function behaves as follows:\n",
    "\n",
    "> Returns an iterator of tuples, where the i-th tuple contains the i-th element \n",
    "> from each of the argument sequences or iterables. \n",
    "> \n",
    "> The iterator stops when the shortest input iterable is exhausted. \n",
    "> \n",
    "> With a single iterable argument, it returns an iterator of 1-tuples. \n",
    "> With no arguments, it returns an empty iterator. \n",
    "\n",
    "\n",
    "[Understanding the Python zip() Function](https://realpython.com/python-zip-function/#understanding-the-python-zip-function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sPbUPw7ZT12U",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Using `zip()`\n",
    "\n",
    "\n",
    "```\n",
    "    coordinate = ['x', 'y', 'z']\n",
    "    value = [1, 2, 3, 4, 5]\n",
    "\n",
    "    result = zip(coordinate, value)\n",
    "    result_list = list(result)\n",
    "    print(result_list)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### The inverse of `zip`\n",
    "\n",
    "- zip is its own inverse! Provided you use the special `*` operator.\n",
    "\n",
    "```\n",
    "    c, v =  zip(*result_list)\n",
    "    print(\"c =\", c)\n",
    "    print(\"v =\", v)\n",
    "```\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/09/zip.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r93ZkAVTkV6H",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it yourself here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ai37hyE03RPL",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "l1 = ['a', 'b', 'c']\n",
    "l2 = [1, 2, 3, 4]\n",
    "\n",
    "z1 = zip(l1, l2)\n",
    "print(z1)\n",
    "print(type(z1))\n",
    "\n",
    "l3 = list(z1)\n",
    "print(l3)\n",
    "print(type(l3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BBG6jDzN4eOY",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "c, n =  zip(*l3)\n",
    "print(\"c =\", c)\n",
    "print(\"n =\", n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TcLnGXLRkRP_",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "One more example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EfEQOdHTkGpR",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "letters = ['a', 'b', 'c']\n",
    "numbers = [0, 1, 2]\n",
    "for l, n in zip(letters, numbers):\n",
    "    print(f'Letter: {l}')\n",
    "    print(f'Number: {n}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hK1W8IroT5f8",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Visualise it in python tutor\n",
    "\n",
    "$\\Rightarrow$\n",
    "<http://www.pythontutor.com/visualize.html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Using `sorted()`\n",
    "\n",
    "  - All programmers will have to write code to sort items or data at some point\n",
    "  - Sorting can be critical to the user experience in your application\n",
    "  \n",
    "  - `sorted(iterable, /, *, key=None, reverse=False)`\n",
    "    - Return a *new list* containing all items from the iterable in ascending order\n",
    "    - A custom *key function* can be supplied to customize the sort order, and \n",
    "    - the *reverse* flag can be set to request the result in descending order\n",
    "  \n",
    "  - `sorted()`, with no additional arguments, is ordering the values in numbers in an ascending order, meaning smallest to largest.\n",
    "  \n",
    " [Ordering Values With sorted()](https://realpython.com/python-sort/#ordering-values-with-sorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "students = [\n",
    "    (\"John\", [\"CompSci\", \"Physics\"]),\n",
    "    (\"Vus\", [\"Maths\", \"CompSci\", \"Stats\"]),\n",
    "    (\"Ann\", [\"CompSci\", \"Accounting\", \"Economics\", \"Management\"]),\n",
    "    (\"Sarah\", [\"InfSys\", \"Accounting\", \"Economics\", \"CommLaw\"]),\n",
    "    (\"Zuki\", [\"Sociology\", \"Economics\", \"Law\", \"Stats\", \"Music\"])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sorted(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "sorted(students, reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def reverse_tuple(t):\n",
    "    return t[0][::-1]\n",
    "\n",
    "sorted(students, key=reverse_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-88zpLeGUG3t",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## List Operations\n",
    "\n",
    "\n",
    "- See the Python Standard Library for:\n",
    "\n",
    "  - a comprehensive list of \"Common Sequence Operations\":\n",
    "    [[PSL](https://docs.python.org/3.7/library/stdtypes.html#common-sequence-operations)]\n",
    "\n",
    "  - a comprehensive list of operations on \"Mutable Sequence Types\":\n",
    "    [[PSL](https://docs.python.org/3.7/library/stdtypes.html#mutable-sequence-types)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bonus\n",
    "\n",
    "On how to use the Spyder debugger to find errors in the programs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('vNfCfowr-pQ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Zz-UtV8ORH_t",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ticket to leave"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C-hchAExRRVh",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moodle activity\n",
    "\n",
    "[LE09: Lists](https://moodle.up.pt/course/view.php?id=1738#section-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uV1OP6ahRYne",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "\n",
    "$\\Rightarrow$ \n",
    "[Go back to the Table of Contents](00-contents.ipynb)\n",
    "\n",
    "$\\Rightarrow$ \n",
    "[Read the Preface](00-preface.ipynb)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "Zz-UtV8ORH_t"
   ],
   "name": "09-lists.ipynb",
   "private_outputs": true,
   "provenance": [],
   "toc_visible": true
  },
  "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.5"
  },
  "rise": {
   "enable_chalkboard": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}