tu008-AdvancedDataTypesContainers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "60242d2c",
   "metadata": {},
   "source": [
    "# Introduction to Advanced Python Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e05c6cf",
   "metadata": {},
   "source": [
    "### Learning Goals\n",
    "\n",
    "  - Advanced python data types\n",
    "  - The concept of data container\n",
    "  - Python Containers\n",
    "    - Lists\n",
    "    - Strings\n",
    "    - Tuples\n",
    "    - Dictionaries\n",
    "    - Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "520d3e76",
   "metadata": {},
   "source": [
    "In the previous tutorial we have focussed the simple data types in python, `int`, `float`, `complex`, `bool`, and `str`. In geenral these simple variables types store individual variable values (a = 10; or b = 2 + 2j).\n",
    "\n",
    "If you look back at the previous turorial, `str` (strings) are a little bit different. They can store multiple characters all at onces. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "432900fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystring = 'this list contains five words.'\n",
    "print(mystring)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96daffab",
   "metadata": {},
   "source": [
    "Python Strings are a type of [*container*](https://en.wikipedia.org/wiki/Container_(abstract_data_type)). Containers are data types that contain other data. A container is an object with complex properties. Whereas a variable has a name -say `a`- and a single value is stored in it -say `2`-, containers contains multitudes of values and often (as we will see later) can contain variables of different type (`int` and `bool` etc). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4d1ed25",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystring = 'this list contains forty one characters!!'\n",
    "print(mystring)\n",
    "\n",
    "len(mystring) # let's check the length of the sting (count the number of characters)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f75b21d0",
   "metadata": {},
   "source": [
    "**Containers** are one of the major ways Python offers to work with data. Later on we will learn about one of the most commonly used Python containers (the [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html)). \n",
    "\n",
    "As a start and in addition to `str`, below we will learn about some of the basic containers, most notably `lists`, and then mention also tuples, dictionaries, and sets  \n",
    "\n",
    "So, first we will get an overview of the various containers and then we are going to learn how to work with `lists`. Lists are handy! Thye are the beginning of data management and organization in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36908f04",
   "metadata": {},
   "source": [
    "### Python Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "517a47dc",
   "metadata": {},
   "source": [
    "Lists are containers of indexed, ordered and mutable data. They are variables used to contain multiple elements. Lists are created by writing a set of values inside square brakets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbe015e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [2, 3, 4, 5] # this list contains 4 numbers\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef24b5a",
   "metadata": {},
   "source": [
    "Python lists can contain elements of any type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bfc1391",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_int = [10, 4, 2, 5]                                  # This list contains integers\n",
    "print(list_of_int)\n",
    "type(list_of_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e6efb4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_float = [2.3, 4.3, 5.5, 6.1]                         # This list contains floating numbers\n",
    "print(list_of_float)\n",
    "type(list_of_float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0cdccfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_complex = [2 + 1j, 4 + 2j, 5 + 33j, 9 + 6j]          # This list contains complex numbers\n",
    "print(list_of_complex)\n",
    "type(list_of_complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4480ede",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_boolean = [True, False, True, True]                  # This list contains boolean values \n",
    "print(list_of_boolean)\n",
    "type(list_of_boolean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57ed7169",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_strings = ['this', 'is', 'a', 'list','of','strings'] # This list contains strings\n",
    "print(list_of_strings)\n",
    "type(list_of_strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a6c4997",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Can you create a list with different types of variable in it?\n",
    "  [Use the cell below to create a list containing different types of variables and the following one to describe the result of the experiment in your own words]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ee87993",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "80724e80",
   "metadata": {},
   "source": [
    "[Describe the results of the experiment above here:]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb8faa1",
   "metadata": {},
   "source": [
    "### Python Tuple\n",
    "\n",
    "Tuples are ordered collections of data. They are similar to lists but immuatable. Whereas you can add new elements to a previously defined lists you cannot do that with Tuples.\n",
    "\n",
    "Tuples are defined with parenthesis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b022386e",
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple = (9,4,5)\n",
    "print(mytuple)\n",
    "type(mytuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc26300",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Can you create a Tuple with different types of variable in it?\n",
    "  [Use the cell below to create a list containing different types of variables and the following one to describe the result of the experiment in your own words]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1512dd6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "72119485",
   "metadata": {},
   "source": [
    "[Describe the results of the experiment above here:]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "434d109c",
   "metadata": {},
   "source": [
    "Lists and Tuple differ in a variety of ways. The most noticble one is that lists are mutable, tuple are immutable. This means that, we can add elements to a list but not a tuple (in the example we will use the method `.append` to attempt to add elements to a list and a tuple):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63f91a90",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [1,2,3] # this list has three elements\n",
    "print(mylist)\n",
    "type(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6032a364",
   "metadata": {},
   "source": [
    "Now, we attempt to add a forth element to the list (using `.append()`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3831cdcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist.append(4) \n",
    "print(mylist)\n",
    "type(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6aa706d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple = (1,2,3)\n",
    "print(mytuple)\n",
    "type(mytuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "193524b7",
   "metadata": {},
   "source": [
    "Now, we attempt to add a forth element to the tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97b35ac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple.append(4) # it does not work"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "499b2f57",
   "metadata": {},
   "source": [
    "*note. You can explore all the other methods of a container (or any variable in Python) by typing: `<containerName>.` and then hit the `TAB` key on your keyboard.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2504bf45",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - How many methods does a `Tuple` have?\n",
    "  [Report your answer here]\n",
    "  \n",
    "  - Which methods does a `List` have?\n",
    "  [Report your answer here]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43e1ebe5",
   "metadata": {},
   "source": [
    "### Python Set\n",
    "\n",
    "A set is defined as an unordered, unidexed and immutable collection of items. Whereas lists are defined by `[]`, tuple are defined by `()`, sets are defined by `{}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "460998dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "myset = {\"A\", \"B\", \"C\", \"D\"}\n",
    "print(myset)\n",
    "type(myset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f10a65da",
   "metadata": {},
   "source": [
    "Unordered means that items in the set do not have an assigned order, so they cannot be indexed: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c592826c",
   "metadata": {},
   "outputs": [],
   "source": [
    "myset{1}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db55c5cc",
   "metadata": {},
   "source": [
    "This is means also that a set is immutable and elements cannot be replaced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acf15a3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "myset{2} = \"F\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b566cc7d",
   "metadata": {},
   "source": [
    "This is different from Tuple and Lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "992c4b96",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [\"A\",\"B\",\"C\",\"D\"]\n",
    "print(mylist[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e848ec4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[3] = \"F\"\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "626791fd",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - In the line above I changed the element of `mylist` indexed by the number `3`, why did that operation change the last element in the list?\n",
    "  [Report your answer here]\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f617dc63",
   "metadata": {},
   "source": [
    "Sets have some cool properties, similar to the \"sets\" you might have studied in highschool or college. We can perform union operations with sets. \n",
    "\n",
    "Ok so let's remind ourselves what `myset` contained:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0d4767c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(myset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29ba0366",
   "metadata": {},
   "source": [
    "Now let's create a new set (`myset2`) with numbers in it, and then construct the union of `myset` and `myset2`, we will save the union set in a variable called `myset3`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bf691db",
   "metadata": {},
   "outputs": [],
   "source": [
    "myset2 = {'E', 'F', 'G'}\n",
    "print(myset2)\n",
    "myset3 = {}\n",
    "myset3 = myset.union(myset2)\n",
    "print(myset3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d243f10",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - can you repeate the same union experiment with lists? For example, can you take the list `mylist`  create a second one called `mylist2` containing other elements (your pick) and create a third list `mylist3` that is the union of mylist` and `mylist2`?\n",
    "  \n",
    "  [Use the cell below to try the experiment]\n",
    "  \n",
    "  [Report your verbal description of the results of the experiment here.]\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8e73aa4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b8c465bd",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - can `lists` or `sets` contain a mixture of different data types, say letters, float numbers and integers? Attempt to make a list containing letters, float numbers and integers call it `myWonderList`, show its result using `print()`, then also make a set containing letters, float numbers and integers, call it `myWonderSet`, show its result using `print()`:\n",
    "\n",
    "  [Use the cell below to implement the experiment]\n",
    "  \n",
    "  [Report your verbal description of the results of the experiment here.]\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ed0071f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6522ed8b",
   "metadata": {},
   "source": [
    "### Python Dictionaries\n",
    "\n",
    "A dictionary is an ordered, changeable, collection of items but do not allow duplicates. Dictionaries are defined by pairs of variables where one of the two variables in the pair is generally thought of as a label, the other one as a value. Whereas lists are defined by `[]`, tuple are defined by `()`, dictionaries just liek sets are defined by `{}`. \n",
    "\n",
    "The structure of the content of dictionaries is differently organized than, lists, tuples and sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "577551f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "mydictionary = {\n",
    "    \"apples\": 3, \n",
    "    \"oranges\": 5, \n",
    "    \"bananas\": 2, \n",
    "    \"pinapples\": 1}\n",
    "print(mydictionary)\n",
    "type(mydictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b41d146",
   "metadata": {},
   "source": [
    "Dictionaries allow efficient and human friendly addressing of items. For example, we can recall how many organes we have in the dictionary by directly calling the oranges label and the corresponding value in the pair of values will be returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd709d64",
   "metadata": {},
   "outputs": [],
   "source": [
    "mydictionary[\"oranges\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "308c28c1",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Use the cell below to write code that let you find out how many bananas we have in our container `mydictionary` of fruits?\n",
    "  [Report your answer here]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea34fa15",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "24b260c5",
   "metadata": {},
   "source": [
    "### A few exercises as a reminder"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66e24530",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Answer the following questions.}}$\n",
    "\n",
    "  - Build a `List` of pets called `home`, where each pet name (a string) is followed by the number of pets I own and have at home (say (cats, 2, dogs, 1, etc)?\n",
    "  \n",
    "  [Show your list in the cell below]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "966bf323",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a3e5d154",
   "metadata": {},
   "source": [
    "  - Build a dictionary called `home_dict`, similar to the `home` list but using the features of the dictionary where a pet name can be associated to its correspoding number.\n",
    "  \n",
    "    [Show your dictionary in the cell below]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f479bf45",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dee46bcf",
   "metadata": {},
   "source": [
    "  - Find the number of dogs in `home` and in `home_dict`.\n",
    "  \n",
    "    [Show your code in the cell below]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6633a73e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8d36562f",
   "metadata": {},
   "source": [
    " [Use this cell, to explain in your own words how you found the dog and the corresponding number of dogs in `home` first and in `home_dict` after that] \n",
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2be116d5",
   "metadata": {},
   "source": [
    "### More practicing with using Python Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d75ecec",
   "metadata": {},
   "source": [
    "Although Lists, Containers, Tuple, and Dictionary are all interesting and important datatypes in python, we will use primarily Lists in thsi class. Below some additional material to practice making lists and accessing them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0099343",
   "metadata": {},
   "source": [
    "Lists in Python are just what they sound like, lists of things. We make them using `[square brackets]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42710c7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [1, 3, 5, 7, 11, 13]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd8cb115",
   "metadata": {},
   "source": [
    "A list is an extension of a regular (or \"scalar\") `variable`, which can only hold one thing at the time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e80fe5f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "notalist = 3.14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73b16e77",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(notalist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f72a6ca1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7ebceaf",
   "metadata": {},
   "source": [
    "Aside: If we're working with only numbers, then you can think of a regular variable as a \"scalar\" and a list as a \"vector\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8460dfde",
   "metadata": {},
   "source": [
    "Lists can, however, hold things besides numbers. For example, they can hold 'text'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4e6d26c",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist2 = ['this', 'is', 'a', 'list', 'of', 'words']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e405f1a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73b9d62b",
   "metadata": {},
   "source": [
    "(Some people, even us, might casually call this a vector but that's technically not true.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d11607f",
   "metadata": {},
   "source": [
    "In reality, lists can hold all sort of things, say numbers (scalars), 'text' and even other lists, and all at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d48c6eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist3 = [1, 'one', [2, 3, 4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c501bfbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d4fc5e7",
   "metadata": {},
   "source": [
    "Note that this last list holds a list at index=2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73428ff5",
   "metadata": {},
   "source": [
    "We can get elements of a list by using `index` values in square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0354066e",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1c7eec6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mylist[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5087d5a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist3[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d0be1ae",
   "metadata": {},
   "source": [
    "**Python uses a 0-based indexing, not a 1-based indexing (the first value in container is indexed with the number 0). This means that the first value in a list is at index=0, not index=1. This is different than many other languages including R and MatLab!**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a97c258",
   "metadata": {},
   "source": [
    "We can address more than one element in a list by using the `:` (colon) operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a06fd7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09ae6a64",
   "metadata": {},
   "source": [
    "We can read this as \"Give me all the elements in the interval between 0 **inclusive** to 3 **exclusive**.\"\n",
    "\n",
    "I know this is weird. But at least for any two indexes `a` and `b`, the number of elements you get back from `mylist[a,b]` is always equal to `b` minus `a`, so I guess that's good!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97c3441e",
   "metadata": {},
   "source": [
    "We can get any consecutive hunk of elements using `:`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a6dbc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "432eb54a",
   "metadata": {},
   "source": [
    "If you omit the indexes, Python will assume you want everything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f32671ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b28978b",
   "metadata": {},
   "source": [
    "That doesn't seem very useful... But, actually, it will turn out to be **really** useful later on, when we will start using numpy arrays!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8440369",
   "metadata": {},
   "source": [
    "If you just use one index, the `:` is assumed to mean \"from the beginning\" or \"to the end\". Like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0da9410f",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[:3] # from the beginning to 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f27b36f",
   "metadata": {},
   "source": [
    "And this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36c50220",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[3:] # from 3 to the end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a82376cd",
   "metadata": {},
   "source": [
    "In addition to the `list[start:stop]` syntax, you can add a step after a second colon, as in `list[start:stop:step]`. This asks for all the element between `start` and `stop` but in steps of `step`, not necessarily consecutive elements. For example every other element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09e1cec1",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[0:5:2] # get every other element"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd25f983",
   "metadata": {},
   "source": [
    "As you've probably figured out, all our outputs above have been lists. So if we assign the output a name, it will be another list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f59d732",
   "metadata": {},
   "outputs": [],
   "source": [
    "every_other_one = mylist[0:-1:2] # could also do mylist[0::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e584a75",
   "metadata": {},
   "outputs": [],
   "source": [
    "every_other_one"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44125e74",
   "metadata": {},
   "source": [
    "See!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "707a58c5",
   "metadata": {},
   "source": [
    "If we want a group of elements that aren't evenly spaced, we'll need to specify the indexes \"by hand\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed25cb5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "anothernewlist = [mylist[1],mylist[2],mylist[4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23094e01",
   "metadata": {},
   "outputs": [],
   "source": [
    "anothernewlist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64f4fec3",
   "metadata": {},
   "source": [
    "So those are the basics of lists. They:\n",
    "\n",
    "* store a list of things (duh)\n",
    "* start at index zero\n",
    "* can be accessed using three things together:\n",
    "    - square brackets `[]`\n",
    "    - integer indexes (including negative \"start from the end\" indexes)\n",
    "    - a colon `:` (or two if you want a step value other than 1)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ed2e42b",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = [2, 4,  3, 6, 5, 8, 11, 10, 9, 14, 13, 12, 7]\n",
    "# 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
    "\n",
    "string_letters = str(letters)\n",
    "lists_letters = list(letters)\n",
    "tuples_letters = tuple(letters)\n",
    "sets_letters = set(letters)\n",
    "\n",
    "\n",
    "print(\"String: \", string_letters)\n",
    "print(\"Lists: \", lists_letters)\n",
    "print(\"Tuples: \", tuples_letters)\n",
    "print(\"Sets: \", sets_letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f6ab47a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}