Additional Programming Concepts in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional Programming Concepts in Python\n",
    "\n",
    "In this notebook, you will learn about additional programming concepts in Python. They are not part of the learning objectives of the course, but you may run into them at some point, or wonder what they are, or find them fun and useful if you already have some programming experience. \n",
    "\n",
    "*(Much of this material we wrote up in an earlier version of the notebooks, but then moved here when we tweaked the course to fit in the time we have available.)*\n",
    "\n",
    "## Tuples\n",
    "\n",
    "### What is a tuple?\n",
    "\n",
    "The first more complicated data structure we will discuss is a `tuple`. A tuple is a collection of values inside curved brackets. Here is the basic syntax for making a tuple: \n",
    "\n",
    "```\n",
    "my_tuple = (a, b, c, ...etc...)\n",
    "```\n",
    "\n",
    "As a concrete example, this will create a tuple of three integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "tup1 = (5,6,7)\n",
    "print(tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like the other data types we've see, we can see the tuples we create using `%whos`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable   Type     Data/Info\n",
      "-----------------------------\n",
      "tup1       tuple    n=3\n"
     ]
    }
   ],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are like lists, but behave a bit differently than python lists. In fact, we've already seen tuples before in the previous notebook when we were looking at `for` loops!\n",
    "\n",
    "If you are given a tuple, you can check how long it by using the `len()` function built into python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(tup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that tuples do not have to contain integers, they can contain any type of data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A tuple of strings\n",
    "str_tup = ('foo', 'bar')\n",
    "print(str_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different than how numpy arrays are typically used, tuples can even be mixed, with each element of a different type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_tup = (1, 1.05, 7+3j, 'foo')\n",
    "print(mixed_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And you can even have tuples of tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup_of_tup = (str_tup, mixed_tup)\n",
    "print(tup_of_tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples support all the same indexing and slicing as arrays. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples can also contain other tuples! If your tuple contains another tuple, like the example `tup_of_tup`, you can use the square brackets a second time to index into the tuple you extract by the first set of square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tup_of_tup)\n",
    "print(tup_of_tup[0])\n",
    "print(tup_of_tup[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping over tuples without using indices\n",
    "\n",
    "As mentioned briefly in Notebook 2, python `for` loops can also directly iterate over \"iteratable\" objects. \n",
    "\n",
    "The `tuple` (along with lists, which we will see in a bit, and numpy arrays, which we will see in the next notebook), is one such iteratable objecte. \n",
    "\n",
    "For example, to print all of entries of a `tuple` out in order, we can use directly following:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in tup1:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During each subsequent iteartion of the loop, the variable `n` will be assigned to the next item that is stored in the tuple. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",