chapters/Chapter 3 - Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "Lists are one of the more common data types that you will come across.\n",
    "They serve as simple containers that can hold objects.\n",
    "They are collections of similar items, like a grocery list.\n",
    "\n",
    "```py\n",
    "groceries = [\"milk\", \"bread\", \"flashlight\", \"blizzard survival guide\"]\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "random_values = [\"foo\", 1, True, None]\n",
    "```\n",
    "\n",
    "The only special syntax for the list is the _square brackets_ `[]`.\n",
    "Every element in the list is separated by a comma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "Go ahead and create a list, or two. \n",
    "You should already know some different types available from Chapter 1.. \n",
    "Stick some values in your list, try it with different types.\n",
    "Print our your results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create your list(s) here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print your results here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Accessing Elements\n",
    "\n",
    "Ok, so you have a list. \n",
    "How do you get at the different values within the list?\n",
    "How can you get the first element?\n",
    "The last element?\n",
    "The first 5 elements???\n",
    "Last 3?\n",
    "Every other?\n",
    "\n",
    "So many questions!\n",
    "Only one answer.\n",
    "By **_slicing_** the list at its **_indices_**.\n",
    "\n",
    "**Python starts at the number 0**.\n",
    "It is **zero-indexed**.\n",
    "\n",
    "So, with that in mind, every element in a list is automatically assigned a number, starting with zero.\n",
    "Let's take an example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every fruit has an index (0-6): \n",
    "* `orange`: 0\n",
    "* `apple`: 1\n",
    "* `pear`: 2 \n",
    "* `banana`: 3\n",
    "* `kiwi`: 4\n",
    "* `apple`: 5\n",
    "* `banana`: 6\n",
    "\n",
    "The index is _ALWAYS_ sequential, and updates when items get added or removed from the list.\n",
    "If we were to shuffle this list and mix up the values, the indices will still be 0-6.\n",
    "\n",
    "If we wanted to _be certain of this_, we could use the `enumerate` function.\n",
    "This will give us every value in our list, AND the index.\n",
    "Try running the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(enumerate(fruits)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "1. Create a new list of ten (10) animals. \n",
    "Assign this list to a variable called `animals`.\n",
    "2. Print your list of animals.\n",
    "3. Print out the enumerated list of animals.\n",
    "Look at the code above as a guide and feel free to add extra cells.\n",
    "\n",
    "What animal is at the 0 index?\n",
    "What is the last index in your list? \n",
    "How long it your list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "Getting back to our original questions..\n",
    "\n",
    ">Ok, so you have a list. How do you get at the different values within the list? How can you get the first element? The last element? The first 5 elements??? Last 3? Every other?\n",
    "\n",
    ">So many questions! Only one answer. By slicing the list at it's indices.\n",
    "\n",
    "**GREAT**\n",
    "\n",
    "Now we know that a list has **_values_** AND **_indices_**.\n",
    "We can use the index number to access the value at that index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# start by seeing what's available\n",
    "print(list(enumerate(fruits)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "**_How do you get at the different values within the list?_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replace the ??? with an index value.\n",
    "# HINT: use one of the numbers you see from the previous cell\n",
    "index = ???\n",
    "\n",
    "print(fruits[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "**_How can you get the first element?_**\n",
    "\n",
    "We know that the _very first_ index in a list will be 0.. \n",
    "Let's go with that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "**_The last element?_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Based on literal index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*__Is there another way??..__*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "**_The first 5 elements???_**\n",
    "\n",
    "WHOA THERE.\n",
    "\n",
    "We know how to get a _single_ element from a list.. \n",
    "How could we get multiple elements??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['apple', 'banana', 'carrot', 'durian', 'elderberry']\n",
    "\n",
    "print(my_list[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists have the ability to return a elements with a range of indices.\n",
    "You can specify the range using brackets and a colon. \n",
    "The syntax is like this: \n",
    "\n",
    "```\n",
    "my_list[ start_index : stop_index ]\n",
    "```\n",
    "* The `start_index` is *__included__* in the result.\n",
    "* The `stop_index` is *__NOT included__* in the result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Knowing this, let's approach our question again.\n",
    "\n",
    "*__The first 5 elements???__*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first 5 of our fruits list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "*__Last 3?__*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's do it with the same syntax structure, different indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "*__Every other?__*\n",
    "\n",
    "Python lists have one other attribute to their slicing methods.\n",
    "This is the skip (step) argument to the slicer!\n",
    "\n",
    "```\n",
    "my_list[ start_index : stop_index : step ]\n",
    "```\n",
    "* The `step` argument let's you specify an \"every n\" pattern.\n",
    "\n",
    "Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['apple', 'banana', 'carrot', 'durian', 'elderberry']\n",
    "\n",
    "print(my_list[0:5:1])\n",
    "print(my_list[0:5:2])\n",
    "print(my_list[0:5:3])\n",
    "print(my_list[0:5:4])\n",
    "print(my_list[0:5:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also just _omit_ the start and stop if you know you want to reference the entire list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so now print out every other value from the `fruits` list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### Travel back in time..\n",
    "\n",
    "So far, we have explored list indices with positive numbers. \n",
    "What happens when we start to apply negative numbers as arguments to our slicer??\n",
    "\n",
    "Let's think about this like we would a clock face.\n",
    "\n",
    "<img src=\"./images/clock.jpg\" alt=\"clock\" style=\"width: 400px;\"/>\n",
    "\n",
    "If the time was 1pm, and we went back 3 hours.. \n",
    "What would the new time be?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Current time is the 0 index!\n",
    "hours = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n",
    "\n",
    "# let's ignore AM/PM for now..\n",
    "hours[-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the `start` argument to the slicer is 0.\n",
    "For our list of `hours`, the last index is 11.\n",
    "If we cycle back 3 from 0, we get `[0] -> 11 -> 10 -> 9`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hours[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pretty wild!\n",
    "\n",
    "<hr>\n",
    "\n",
    "### YOUR TURN\n",
    "\n",
    "Using only negative arguments in the slicer..\n",
    "* Print hours 9 through 12\n",
    "* Print hours 1 through 9\n",
    "* Print hours 3 through 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge!\n",
    "\n",
    "Using only negative arguments in the slicer..\n",
    "* Print all numbers less than 9 that are divisible by 3.. \n",
    "**_IN REVERSE_**!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "### List Methods\n",
    "\n",
    "Just like strings, lists also have _methods_ that we can use.\n",
    "\n",
    "* `count` - Shows how many times something shows up in my list\n",
    "* `index` - At which position does something show up in my list\n",
    "* `reverse` - Reverse it!\n",
    "* `append` - Adds something to the end of the list\n",
    "* `sort` - Sorts it\n",
    "* `pop` - remove an element from the end of the list\n",
    "\n",
    "Go ahead and run the next cell. \n",
    "See what happens to our list!\n",
    "\n",
    "Of course, these are _just a few methods_.\n",
    "There are [many more](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Count ----> \", fruits.count('apple'))\n",
    "print(\"Count ----> \", fruits.count('tangerine'))\n",
    "print(\"Index ----> \", fruits.index('banana'))\n",
    "print(\"Index ----> \", fruits.index('banana', 4))  # Find next banana starting a position 4\n",
    "\n",
    "fruits.reverse()\n",
    "print(\"Reverse --> \", fruits)\n",
    "\n",
    "fruits.append('grape')\n",
    "print(\"Append ---> \", fruits)\n",
    "\n",
    "fruits.sort()\n",
    "print(\"Sort -----> \", fruits)\n",
    "\n",
    "last_fruit = fruits.pop()\n",
    "print(\"Pop ------> \", fruits)\n",
    "print(\"\\nLast fruit: \", last_fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### YOUR TURN\n",
    "\n",
    "Using your `animals` list as a reference..\n",
    "* Pick an animal. \n",
    "Print how many times that animal shows up in your list using `count`.\n",
    "* At which index does this animal show up?\n",
    "* Sort your list.\n",
    "* What index does your animal show up now?\n",
    "* `Pop` off the last animal in your list, and print out that animal.\n",
    "* Print your animals list.\n",
    "* How many animals are in your list now?\n",
    "* Remove _all_ the items in your list in one go, and print out your list. \n",
    "You may have to look up a list method to do this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}