3a - Arrays and loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is the third in a series of jupyter notebooks intended to introduce students to programing in python. I designed it for the Vaughan house Living Learning Community at UC Merced. It focuses on data structures and loops in python 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first discuss data structures. What is a data structure? A data structure is a way for computers to organize and store various pieces of data. For example, if you consider someone's name and phone number a piece of data, then the contact list on your phone would be a data structure. Or, you could think of your grocery list as a data structure, with each item on the list as a piece of data.\n",
    "\n",
    "Programmers have a number of data structures that they call upon, such as arrays, linked lists, binary trees, and hash tables, each with different costs and benefits, and one of the most important skills for programmers is recognizing which data structure is most appropriate for the task they are trying to accomplish. For the purposes of this notebook we are going to take a look at the two most commonly used data structures in python: lists and tuples.\n",
    "\n",
    "Let's start with lists. A list in python is a dynamically sized array that can contain any type of data (even within the same list). In addition, a list can be changed after it has been created, either by adding new items, removing current items, changing current items, or even reordering the list. The easiest way to create a list is with the open and close brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mnia', 'Hrant', 'Erik']\n"
     ]
    }
   ],
   "source": [
    "#create a list of the Vaughan house instructors\n",
    "instructorList = [\"Mnia\", \"Hrant\", \"Erik\"]\n",
    "print(instructorList)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get individual items from the list by referencing their index. Note that in python references start at zero!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mnia\n"
     ]
    }
   ],
   "source": [
    "#what's the first item in our list of instructors?\n",
    "print(instructorList[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The items in a list can also be lists! These are what we call multi-dimensional lists. They are created the same way as regular lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Mina', 'mina@ucm.edu'], ['Hrant', 'hrant@ucm.edu'], ['Erik', 'erik@ucm.edu']]\n"
     ]
    }
   ],
   "source": [
    "#create a list of instructors with emails\n",
    "emailList = [[\"Mina\", \"mina@ucm.edu\"],[\"Hrant\", \"hrant@ucm.edu\"],[\"Erik\", \"erik@ucm.edu\"]]\n",
    "print(emailList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We again reference items using brackets to get items from lists, but now we can have a series of brackets, where the first bracket gets the list, then the second bracket gets the item from that list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mina', 'mina@ucm.edu']\n",
      "erik@ucm.edu\n",
      "Compare Hrant with mina@ucm.edu\n"
     ]
    }
   ],
   "source": [
    "#what's the first list in our email list?\n",
    "print(emailList[0])\n",
    "\n",
    "#What's the second item in the third list in our email list?\n",
    "print(emailList[2][1])\n",
    "\n",
    "#Reference order is important!\n",
    "print(\"Compare \" + emailList[1][0] + \" with \" + emailList[0][1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the reference to change an item in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mnia\n",
      "Mina\n"
     ]
    }
   ],
   "source": [
    "#What's the first item in the instructor list again?\n",
    "print(instructorList[0])\n",
    "\n",
    "#Oops, typo! Better fix it\n",
    "instructorList[0] = \"Mina\"\n",
    "print(instructorList[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something really nice about python is that there are a few ways to reference items in a list. You can use negative numbers to count from the back of the list forward, and you can us a colon to get a range of items from a list. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erik\n",
      "['Hrant', 'Erik']\n"
     ]
    }
   ],
   "source": [
    "#what's the last item in the instructor list?\n",
    "print(instructorList[-1])\n",
    "\n",
    "#what are the second and third items in the instructor list? \n",
    "#Note that it goes up to the final reference, but doesn't include it!\n",
    "print(instructorList[1:3])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's more to discuss with lists, but before we continue I want to take a quick detour to talk about the second data structure common to python, which are called \"tuples\". In python tuple is very similar to a list, being an ordered array that can contain any type of data. Tuples are created with parenthesis, similar to how brackets are used to create lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mnia', 'Hrant', 'Erik')\n"
     ]
    }
   ],
   "source": [
    "#let's create a tuple for instructors\n",
    "instructorTuple = (\"Mnia\", \"Hrant\", \"Erik\")\n",
    "print(instructorTuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mnia\n",
      "Erik\n"
     ]
    }
   ],
   "source": [
    "#what's the first entry in this tuple?\n",
    "print(instructorTuple[0])\n",
    "\n",
    "#what's the final entry in this tuple?\n",
    "print(instructorTuple[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The primary difference between lists and tuples is that tuples are immutable, which means that they **cannot** be changed after they've been created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mnia\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-29cfb391b557>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m#what if I try to fix the typo?\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0minstructorTuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Mina\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#there's a typo again in the tuple!\n",
    "print(instructorTuple[0])\n",
    "\n",
    "#what if I try to fix the typo?\n",
    "instructorTuple[0] = \"Mina\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If lists and tuples are so similar, why do we have both? Why not just get rid of tuples? There are various reasons, primarily related to memory usage, to have both. But for you, the biggest reason to know about both is that there are some functions in python that require a tuple and won't work on lists, so it's important for you to be aware of both.\n",
    "\n",
    "Now that we've taken that detour, let's get back to lists. We've seen how to get items in a list and change/replace items in a list. How do we add items to a list? There are a two ways to do this. The first is to use the append() function, which adds an item to the end of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mina', 'Hrant', 'Erik', 'Jose']\n"
     ]
    }
   ],
   "source": [
    "#Add Jose as an instructor\n",
    "instructorList.append(\"Jose\")\n",
    "print(instructorList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If I don't want to add an item to the end of the list, but somewhere else, I need to use the insert() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Mina', 'mina@ucm.edu'], ['Jose', 'jose@ucm.edu'], ['Hrant', 'hrant@ucm.edu'], ['Erik', 'erik@ucm.edu']]\n"
     ]
    }
   ],
   "source": [
    "#Insert Jose and his email to the email list at the second position\n",
    "emailList.insert(1,[\"Jose\", \"jose@ucm.edu\"])\n",
    "print(emailList)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Finally, there are two ways to remove an element from a list. I can use the remove() function, which goes through the list until it finds the first instance of the function argument and removes it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mina', 'Hrant', 'Erik']\n",
      "['Mina', 'Jose', 'Hrant', 'Erik']\n"
     ]
    }
   ],
   "source": [
    "#Move Jose to the second position in the instructor list\n",
    "#First, take Jose out of the instructor list\n",
    "instructorList.remove(\"Jose\")\n",
    "print(instructorList)\n",
    "\n",
    "#Now, insert Jose into the second position\n",
    "instructorList.insert(1,\"Jose\")\n",
    "print(instructorList)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, I can use the pop() function to remove the element at the referenced position. What's nice about the pop function is that it also returns the removed element, so we can use a variable to store it if we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hrant', 'hrant@ucm.edu']\n",
      "[['Mina', 'mina@ucm.edu'], ['Jose', 'jose@ucm.edu'], ['Erik', 'erik@ucm.edu']]\n",
      "[['Mina', 'mina@ucm.edu'], ['Hrant', 'hrant@ucm.edu'], ['Jose', 'jose@ucm.edu'], ['Erik', 'erik@ucm.edu']]\n"
     ]
    }
   ],
   "source": [
    "#Move the third element of the email list to the second position\n",
    "#First, use the pop() function to get the third element and store it in a variable\n",
    "tempEmail = emailList.pop(2)\n",
    "print(tempEmail)\n",
    "print(emailList)\n",
    "\n",
    "#Now, put the removed item into the second position\n",
    "emailList.insert(1, tempEmail)\n",
    "print(emailList)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of these functions for adding, modifying, and removing items from a list can only operate on 1 element at a time. So, how do we make multiple changes to a list? Say, add 10 items to a list? For that, we need to use loops. Loops are used in computer programs to do the same (or, at least, similar) things multiple times. There are a wide variety of loops structures and syntax in different languages, but the most common loops fall into two categories: for loops, which do the same set of code a set number of times (add an element to a list 17 times, for example) and while loops, which do the same set of code until a boolean statement is false (add an element to a list until you have 100 elements, for example). Of these, the for loop is probably the most common, and it's what we'll focus on for this notebook. In python, the syntax for a for loop is similar to the syntax for an if statement, where you use the \"for\" command, followed by how many times to do the loop, and then all the indented lines below that command are run that many times. For example, here's how to print out all the individual elements in the instructor list: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mina', 'Jose', 'Hrant', 'Erik']\n",
      "Mina\n",
      "Jose\n",
      "Hrant\n",
      "Erik\n"
     ]
    }
   ],
   "source": [
    "#First, print out the whole list to see what all the elements are\n",
    "print(instructorList)\n",
    "\n",
    "#Now, let's print each element individually. First, I need to know how many elements \n",
    "#are in the list, so I can tell the for loop how many times to loop\n",
    "#I know that my list has 4 elements, but since I won't always know how big my list\n",
    "#is I'll use a built-in function, called len(), to tell me how many elements are in\n",
    "#my list\n",
    "listLength = len(instructorList)\n",
    "\n",
    "#Now I can create a for loop with a variable x, which starts at\n",
    "#zero and increases by one each time through the loop, and the\n",
    "#range() function plus the listLength variable to tell the for\n",
    "#loop how many times to run\n",
    "for x in range(listLength):\n",
    "    print(instructorList[x])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's nice about python, which is not true for most other languages, is that it's been built to be smart about figuring out the number of times to loop, if possible. In the example above, I first had to figure out how long my list is, then tell the for loop how many times it needed to loop. This is similar to what I would have to do in most languages, such as C. However, becaue python is more user friendly it's been built to make this easier. I can instead give it my list as the argument, rather than use the range() function to tell it how many times to go through the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mina\n",
      "Jose\n",
      "Hrant\n",
      "Erik\n"
     ]
    }
   ],
   "source": [
    "#Here's an easier way to iterate through my list\n",
    "for x in instructorList:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mina can be emailed at mina@ucm.edu\n",
      "Hrant can be emailed at hrant@ucm.edu\n",
      "Jose can be emailed at jose@ucm.edu\n",
      "Erik can be emailed at erik@ucm.edu\n"
     ]
    }
   ],
   "source": [
    "#Here's the email for each instructor\n",
    "for x in emailList:\n",
    "    print(x[0] + \" can be emailed at \" + x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The range function, which I used above in the first example, is useful when I don't have a list to start with, but instead want to use a for loop to create a list. For example, here's a for loop to get the first 15 binary numbers (i.e. 1, 2, 4, 8, 16, etc.)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384]\n"
     ]
    }
   ],
   "source": [
    "#first start with an empty list\n",
    "binaryNums = []\n",
    "\n",
    "#now, do a for loop 8 times, adding the next binary number to the list\n",
    "for x in range(15):\n",
    "    binaryNums.append(2 ** x)\n",
    "\n",
    "print(binaryNums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I can also use the range function to change the iteration behavior on my loop. For example, instead of getting every item, I can instead count by 2 to get every other item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "16\n",
      "64\n",
      "256\n",
      "1024\n",
      "4096\n",
      "16384\n"
     ]
    }
   ],
   "source": [
    "#go through the binaryNums list and get print every other entry\n",
    "#the range function needs three arguments in this case (start, stop, and stepsize)\n",
    "#also, remember python starts counting at zero, not one\n",
    "for x in range(0,15,2):\n",
    "    print(binaryNums[x])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you've seen how to create and modify lists, and how to use loops, move on to notebook 3b for some practice."
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}