05-storing-multiple-values-in-lists.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.3"
    },
    "colab": {
      "name": "05-storing-multiple-values-in-lists.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbx_j1qg0II-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# setup\n",
        "!wget https://swcarpentry.github.io/python-novice-inflammation/data/python-novice-inflammation-data.zip\n",
        "!wget https://swcarpentry.github.io/python-novice-inflammation/code/python-novice-inflammation-code.zip\n",
        "\n",
        "!unzip -jn python-novice-inflammation-data.zip\n",
        "!unzip -jn python-novice-inflammation-code.zip"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fW6mpe024O5_",
        "colab_type": "text"
      },
      "source": [
        "Original lesson and exercise solutions at [Software Carpentry Lesson 5](https://swcarpentry.github.io/python-novice-inflammation/05-lists/index.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G6HF9qHoMzzK",
        "colab_type": "text"
      },
      "source": [
        "# Storing Multiple Values in Lists"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PmCNs7YS0TQr",
        "colab_type": "text"
      },
      "source": [
        "Similar to a string that can contain many characters, a list is a container that can store many values. Unlike NumPy arrays, lists are built into the language (so we don’t have to load a library to use them). We create a list by putting values inside square brackets and separating the values with commas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GHDXTNBP0YES",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ee17698a-d77d-425e-b19e-1b83dfd154e6"
      },
      "source": [
        "odds = [1, 3, 5, 7]\n",
        "print('odds are:', odds)\n"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "odds are: [1, 3, 5, 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iRc6MFYg0bjQ",
        "colab_type": "text"
      },
      "source": [
        "We can access elements of a list using indices – numbered positions of elements in the list. These positions are numbered starting at 0, so the first element has an index of 0."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y71Dpn0e0eNm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "aebabcd5-c46b-4db1-81cd-ea93c96c3100"
      },
      "source": [
        "print('first element:', odds[0])\n",
        "print('last element:', odds[3])\n",
        "print('\"-1\" element:', odds[-1])\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "first element: 1\n",
            "last element: 7\n",
            "\"-1\" element: 7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LJYCUS8Z0j_6",
        "colab_type": "text"
      },
      "source": [
        "Yes, we can use negative numbers as indices in Python. When we do so, the index `-1` gives us the last element in the list, `-2` the second to last, and so on. Because of this, `odds[3]` and `odds[-1]` point to the same element here.\n",
        "\n",
        "If we loop over a list, the loop variable is assigned to its elements one at a time:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ij8tpxc300vf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "outputId": "36077527-5771-4a5c-afbd-d26bc12d9350"
      },
      "source": [
        "for number in odds:\n",
        "    print(number)\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LvW6iPGH04DF",
        "colab_type": "text"
      },
      "source": [
        "There is one important difference between lists and strings: we can change the values in a list, but we cannot change individual characters in a string. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7duS0Q3T064R",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "11fa09ad-038c-4130-cf09-d4ada273214d"
      },
      "source": [
        "names = ['Curie', 'Darwing', 'Turing']  # typo in Darwin's name\n",
        "print('names is originally:', names)\n",
        "names[1] = 'Darwin'  # correct the name\n",
        "print('final value of names:', names)\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "names is originally: ['Curie', 'Darwing', 'Turing']\n",
            "final value of names: ['Curie', 'Darwin', 'Turing']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aKHle1WP1DG-",
        "colab_type": "text"
      },
      "source": [
        "works, but:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NQkD0yAO1GfV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "outputId": "29c03ace-ae74-4c7e-b44e-af7937315cbf"
      },
      "source": [
        "name = 'Darwin'\n",
        "name[0] = 'd'\n"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-9030064e45ad>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'Darwin'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mname\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'd'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RZmBBfQI1UIQ",
        "colab_type": "text"
      },
      "source": [
        "does not."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q8fj_5zX1VAU",
        "colab_type": "text"
      },
      "source": [
        "##Ch-Ch-Ch-Ch-Changes\n",
        "Data which can be modified in place is called *mutable*, while data which cannot be modified is called *immutable*. Strings and numbers are immutable. This does not mean that variables with string or number values are constants, but when we want to change the value of a string or number variable, we can only replace the old value with a completely new value.\n",
        "\n",
        "Lists and arrays, on the other hand, are mutable: we can modify them after they have been created. We can change individual elements, append new elements, or reorder the whole list. For some operations, like sorting, we can choose whether to use a function that modifies the data in-place or a function that returns a modified copy and leaves the original unchanged.\n",
        "\n",
        "Be careful when modifying data in-place. If two variables refer to the same list, and you modify the list value, it will change for both variables!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TqM561pZ11WG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f1d0aeba-848a-4d38-cc3f-d27d08c2ea27"
      },
      "source": [
        "salsa = ['peppers', 'onions', 'cilantro', 'tomatoes']\n",
        "my_salsa = salsa        # <-- my_salsa and salsa point to the *same* list data in memory\n",
        "salsa[0] = 'hot peppers'\n",
        "print('Ingredients in my salsa:', my_salsa)\n",
        "\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ingredients in my salsa: ['hot peppers', 'onions', 'cilantro', 'tomatoes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TNmwSZ9u14Nk",
        "colab_type": "text"
      },
      "source": [
        "If you want variables with mutable values to be independent, you must make a copy of the value when you assign it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3hFIYz7G2AIy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f7dc561c-3084-422e-fc94-212177dd5627"
      },
      "source": [
        "salsa = ['peppers', 'onions', 'cilantro', 'tomatoes']\n",
        "my_salsa = list(salsa)        # <-- makes a *copy* of the list\n",
        "salsa[0] = 'hot peppers'\n",
        "print('Ingredients in my salsa:', my_salsa)\n",
        "\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ingredients in my salsa: ['peppers', 'onions', 'cilantro', 'tomatoes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B0IqiNud2Iwa",
        "colab_type": "text"
      },
      "source": [
        "Because of pitfalls like this, code which modifies data in place can be more difficult to understand. However, it is often far more efficient to modify a large data structure in place than to create a modified copy for every small change. You should consider both of these aspects when writing your code."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H13SAwFE2L4K",
        "colab_type": "text"
      },
      "source": [
        "## Nested Lists\n",
        "Since a list can contain any Python variables, it can even contain other lists.\n",
        "\n",
        "For example, we could represent the products in the shelves of a small grocery shop:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1CjQ9lrF2QwS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = [['pepper', 'zucchini', 'onion'],\n",
        "     ['cabbage', 'lettuce', 'garlic'],\n",
        "     ['apple', 'pear', 'banana']]\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y5ItYHvE2Vkz",
        "colab_type": "text"
      },
      "source": [
        "Here is a visual example of how indexing a list of lists `x` works:\n",
        "\n",
        "![alt text](https://swcarpentry.github.io/python-novice-inflammation/fig/indexing_lists_python.png)\n",
        "\n",
        "Using the previously declared list `x`, these would be the results of the index operations shown in the image:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "meZYw4Qq2opK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "67096fdc-9374-42f2-edf9-cfc7ddddd709"
      },
      "source": [
        "print([x[0]])\n",
        "\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[['pepper', 'zucchini', 'onion']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4GGZJ3Es21QH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "689a9d8c-e836-4fc0-ef20-5a05d05d6478"
      },
      "source": [
        "print(x[0])\n",
        "\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['pepper', 'zucchini', 'onion']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NnmE7s1q25EQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "91f706a9-306b-455c-d423-f22561686358"
      },
      "source": [
        "print(x[0][0])\n",
        "\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "pepper\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ts347zM0293T",
        "colab_type": "text"
      },
      "source": [
        "Thanks to Hadley Wickham for the image above."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JA9eusRG3Bwx",
        "colab_type": "text"
      },
      "source": [
        "## Heterogenous Lists\n",
        "\n",
        "Lists in Python can contain elements of different types. Example:\n",
        "```\n",
        "sample_ages = [10, 12.5, 'Unknown']\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WyzkDwbk3M8g",
        "colab_type": "text"
      },
      "source": [
        "## (Return to lesson)\n",
        "\n",
        "There are many ways to change the contents of lists besides assigning new values to individual elements:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FiBghxht3SgK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c71eb5b5-825c-428e-e0cb-29fcdd92ec25"
      },
      "source": [
        "odds.append(11)\n",
        "print('odds after adding a value:', odds)\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "odds after adding a value: [1, 3, 5, 7, 11]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AKseCSwz3Wrm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "82b6b84d-41ff-4e23-e1b3-12fdade614d8"
      },
      "source": [
        "removed_element = odds.pop(0)\n",
        "print('odds after removing the first element:', odds)\n",
        "print('removed_element:', removed_element)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "odds after removing the first element: [3, 5, 7, 11]\n",
            "removed_element: 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UHJnrgpT3ZTu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c52c7753-fae7-42b8-8bc3-33b273e7d5a4"
      },
      "source": [
        "odds.reverse()\n",
        "print('odds after reversing:', odds)\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "odds after reversing: [11, 7, 5, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zMeRpZHx3kXZ",
        "colab_type": "text"
      },
      "source": [
        "While modifying in place, it is useful to remember that Python treats lists in a slightly counter-intuitive way.\n",
        "\n",
        "As we saw earlier, when we modified the `salsa` list item in-place, if we make a list, (attempt to) copy it and then modify this list, we can cause all sorts of trouble. This also applies to modifying the list using the above functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aRivLxXU3q0_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "d06d4a64-2154-4e8b-f2d3-b232dd0abedf"
      },
      "source": [
        "odds = [1, 3, 5, 7]\n",
        "primes = odds\n",
        "primes.append(2)\n",
        "print('primes:', primes)\n",
        "print('odds:', odds)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "primes: [1, 3, 5, 7, 2]\n",
            "odds: [1, 3, 5, 7, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3BnUImvI3xCA",
        "colab_type": "text"
      },
      "source": [
        "This is because Python stores a list in memory, and then can use multiple names to refer to the same list. If all we want to do is copy a (simple) list, we can again use the `list` function, so we do not modify a list we did not mean to:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SJpbgcML31oj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "65ea93a2-2a56-4b92-8b89-2574ff2c741b"
      },
      "source": [
        "odds = [1, 3, 5, 7]\n",
        "primes = list(odds)\n",
        "primes.append(2)\n",
        "print('primes:', primes)\n",
        "print('odds:', odds)\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "primes: [1, 3, 5, 7, 2]\n",
            "odds: [1, 3, 5, 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uQwGfAEX36ji",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Turn a String into a list\n",
        "Use a for-loop to convert the string “hello” into a list of letters:\n",
        "```\n",
        "[\"h\", \"e\", \"l\", \"l\", \"o\"]\n",
        "```\n",
        "Hint: You can create an empty list like this:\n",
        "```\n",
        "my_list = []\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xmMr5be04Jxj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XKHY5aMQ4Kv3",
        "colab_type": "text"
      },
      "source": [
        "##(Return to lesson)\n",
        "Subsets of lists and strings can be accessed by specifying ranges of values in brackets, similar to how we accessed ranges of positions in a NumPy array. This is commonly referred to as “slicing” the list/string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NJOCyuQs4gLO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 86
        },
        "outputId": "6440a215-f554-4c87-fed7-5eb3298aefa9"
      },
      "source": [
        "binomial_name = \"Drosophila melanogaster\"\n",
        "group = binomial_name[0:10]\n",
        "print(\"group:\", group)\n",
        "\n",
        "species = binomial_name[11:23]\n",
        "print(\"species:\", species)\n",
        "\n",
        "chromosomes = [\"X\", \"Y\", \"2\", \"3\", \"4\"]\n",
        "autosomes = chromosomes[2:5]\n",
        "print(\"autosomes:\", autosomes)\n",
        "\n",
        "last = chromosomes[-1]\n",
        "print(\"last:\", last)\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "group: Drosophila\n",
            "species: melanogaster\n",
            "autosomes: ['2', '3', '4']\n",
            "last: 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nQER4f6r4xUj",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Slicing From the End\n",
        "Use slicing to access only the last four characters of a string or entries of a list.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jfRSpKGB45ME",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "string_for_slicing = \"Observation date: 02-Feb-2013\"\n",
        "list_for_slicing = [[\"fluorine\", \"F\"],\n",
        "                    [\"chlorine\", \"Cl\"],\n",
        "                    [\"bromine\", \"Br\"],\n",
        "                    [\"iodine\", \"I\"],\n",
        "                    [\"astatine\", \"At\"]]\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4656zAQ15Uqj",
        "colab_type": "text"
      },
      "source": [
        "```\n",
        "#Desired output for string_for_slicing and list_for_slicing, respectively\n",
        "\"2013\" \n",
        "[[\"chlorine\", \"Cl\"], [\"bromine\", \"Br\"], [\"iodine\", \"I\"], [\"astatine\", \"At\"]] \n",
        "```\n",
        "Would your solution work regardless of whether you knew beforehand the length of the string or list (e.g. if you wanted to apply the solution to a set of lists of different lengths)? If not, try to change your approach to make it more robust.\n",
        "\n",
        "Hint: Remember that indices can be negative as well as positive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NR3Q1HQk5Lb2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vVBHhz8y59xn",
        "colab_type": "text"
      },
      "source": [
        "### Exercise: Non-Continuous Slices\n",
        "So far we’ve seen how to use slicing to take single blocks of successive entries from a sequence. But what if we want to take a subset of entries that aren’t next to each other in the sequence?\n",
        "\n",
        "You can achieve this by providing a third argument to the range within the brackets, called the *step size.* The example below shows how you can take every third entry in a list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PDMVI5P26G9R",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "37f0b592-252b-4d12-9ff9-8174fcd54c28"
      },
      "source": [
        "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]\n",
        "subset = primes[0:12:3]\n",
        "print(\"subset\", subset)\n",
        "\n"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "subset [2, 7, 17, 29]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y_mcaHDm6MYH",
        "colab_type": "text"
      },
      "source": [
        "Notice that the slice taken begins with the first entry in the range, followed by entries taken at equally-spaced intervals (the steps) thereafter. If you wanted to begin the subset with the third entry, you would need to specify that as the starting point of the sliced range:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kVKmeFGv6OXG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "00e5db08-6e29-49a5-bdc4-de07ed2c9907"
      },
      "source": [
        "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]\n",
        "subset = primes[2:12:3]\n",
        "print(\"subset\", subset)\n",
        "\n"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "subset [5, 13, 23, 37]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UE6wc3g_6Q7e",
        "colab_type": "text"
      },
      "source": [
        "Use the step size argument to create a new string that contains only every other character in the string “In an octopus’s garden in the shade”"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UXnEUf5t6TaI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "beatles = \"In an octopus's garden in the shade\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vcpvCGYJ6V-Q",
        "colab_type": "text"
      },
      "source": [
        "```\n",
        "#Desired output\n",
        "I notpssgre ntesae\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lboT-4Fr6a4c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NFHS2xKW6dZl",
        "colab_type": "text"
      },
      "source": [
        "##(Return to Lesson)\n",
        "If you want to take a slice from the beginning of a sequence, you can omit the first index in the range:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GFl6q6oj6kTr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        },
        "outputId": "11b539e5-54b8-4a5e-e590-47c2e25b2d07"
      },
      "source": [
        "date = \"Monday 4 January 2016\"\n",
        "day = date[0:6]\n",
        "print(\"Using 0 to begin range:\", day)\n",
        "day = date[:6]\n",
        "print(\"Omitting beginning index:\", day)\n"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using 0 to begin range: Monday\n",
            "Omitting beginning index: Monday\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7C5lDUVz6lgi",
        "colab_type": "text"
      },
      "source": [
        "And similarly, you can omit the ending index in the range to take a slice to the very end of the sequence:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PjAhxZGu6oMl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "cbe545e3-d2dc-413d-8951-7991fc09da3e"
      },
      "source": [
        "months = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"]\n",
        "sond = months[8:12]\n",
        "print(\"With known last position:\", sond)\n",
        "sond = months[8:len(months)]\n",
        "print(\"Using len() to get last entry:\", sond)\n",
        "sond = months[8:]\n",
        "print(\"Omitting ending index:\", sond)\n"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "With known last position: ['sep', 'oct', 'nov', 'dec']\n",
            "Using len() to get last entry: ['sep', 'oct', 'nov', 'dec']\n",
            "Omitting ending index: ['sep', 'oct', 'nov', 'dec']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pTX20qE76sbS",
        "colab_type": "text"
      },
      "source": [
        "###Exercise: Overloading\n",
        "\n",
        "`+` usually means addition, but when used on strings or lists, it means “concatenate”. Given that, what do you think the multiplication operator `*` does on lists? In particular, what will be the output of the following code?\n",
        "```\n",
        "counts = [2, 4, 6, 8, 10]\n",
        "repeats = counts * 2\n",
        "print(repeats)\n",
        "```\n",
        "\n",
        "1. `[2, 4, 6, 8, 10, 2, 4, 6, 8, 10]`\n",
        "2. `[4, 8, 12, 16, 20]`\n",
        "3. `[[2, 4, 6, 8, 10],[2, 4, 6, 8, 10]]`\n",
        "4.`[2, 4, 6, 8, 10, 4, 8, 12, 16, 20]`\n",
        "\n",
        "The technical term for this is *operator overloading*: a single operator, like `+` or `*`, can do different things depending on what it’s applied to."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RIIwgFQ861Mx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g5TQ0Fj17OV4",
        "colab_type": "text"
      },
      "source": [
        "## KEY POINTS\n",
        "\n",
        "- `[value1, value2, value3, ...]` creates a list.\n",
        "\n",
        "- Lists can contain any Python object, including lists (i.e., list of lists).\n",
        "\n",
        "- Lists are indexed and sliced with square brackets (e.g., `list[0]` and `list[2:9]`), in the same way as strings and arrays.\n",
        "\n",
        "- Lists are mutable (i.e., their values can be changed in place).\n",
        "\n",
        "- Strings are immutable (i.e., the characters in them cannot be changed).\n"
      ]
    }
  ]
}