03_Storing_Multiple_Values_in_Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# III. Storing Multiple Values in Lists\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Teaching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercices\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Turn a String Into a List\n",
    "\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 = []`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing From the End\n",
    "\n",
    "Use slicing to access only the last four characters of a string or entries of a list.\n",
    "\n",
    "```\n",
    "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",
    "# output\n",
    "\"2013\"\n",
    "[[\"chlorine\", \"Cl\"], [\"bromine\", \"Br\"], [\"iodine\", \"I\"], [\"astatine\", \"At\"]]\n",
    "```\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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-Continuous Slices\n",
    "\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:\n",
    "\n",
    "```\n",
    "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",
    "# output\n",
    "subset [2, 7, 17, 29]\n",
    "```\n",
    "\n",
    "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:\n",
    "\n",
    "```\n",
    "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",
    "# output\n",
    "subset [5, 13, 23, 37]\n",
    "```\n",
    "\n",
    "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”\n",
    "\n",
    "```\n",
    "beatles = \"In an octopus's garden in the shade\"\n",
    "\n",
    "# output\n",
    "I notpssgre ntesae\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 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",
    "```\n",
    "counts = [2, 4, 6, 8, 10]\n",
    "repeats = counts * 2\n",
    "print(repeats)\n",
    "```\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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}