docs/tutorials/pythontutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This page demonstrates some basic Python concepts and essentials. See the <a class=\"reference external\" href=\"http://docs.python.org/tutorial/index.html\">Python Tutorial</a> and <a class=\"reference external\" href=\"http://docs.python.org/library/index.html\">Reference</a> for more exhaustive resources.\n",
    "<p>This page provides a brief introduction to:</p>\n",
    "<ul class=\"simple\">\n",
    "<li>Python syntax</li>\n",
    "<li>Variables</li>\n",
    "<li>Lists and Dicts</li>\n",
    "<li>For loops and iterators</li>\n",
    "<li>Functions</li>\n",
    "<li>Classes</li>\n",
    "<li>Importing modules</li>\n",
    "<li>Writing and reading files with Pickling.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displaying results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following command simply prints \"Hello world!\". Run it, and then re-evaluate with a different string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here <tt>print</tt> is a function that displays its input on the screen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a string's <tt>format</tt> method with <tt>{}</tt> placeholders to substitute calculated values into the output in specific locations; for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"3 + 4 = {}. Amazing!\".format(3 + 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple values can be substituted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The length of the {} is {} microns.\".format(\"apical dendrite\", 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are more sophisticated ways of using <tt>format</tt>\n",
    "(see <a class=\"reference external\" href=\"https://docs.python.org/3/library/string.html#format-examples\">examples</a> on the Python website)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables: Strings, numbers, and dynamic type casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are easily assigned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_name = \"Tom\"\n",
    "my_age = 45"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s work with these variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be combined with the + operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = \"Hello, \" + my_name\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s move on to numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try using the + operator on my_name and my_age:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "print(my_name + my_age)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>You will get a <a class=\"reference external\" href=\"https://docs.python.org/3/library/exceptions.html#TypeError\" title=\"(in Python v3.6)\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">TypeError</span></code></a>. What is wrong?</p>\n",
    "<p>my_name is a string and my_age is a number. Adding in this context does not make any sense.</p>\n",
    "<p>We can determine an object’s type with the <code class=\"xref py py-func docutils literal\"><span class=\"pre\">type()</span></code> function.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(my_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(my_age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>The function <a class=\"reference external\" href=\"https://docs.python.org/3/library/functions.html#isinstance\" title=\"(in Python v3.6)\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">isinstance()</span></code></a> is typically more useful than comparing variable types as it allows handling subclasses:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isinstance(my_name, str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_valid_var = None\n",
    "if my_valid_var is not None:\n",
    "    print(my_valid_var)\n",
    "else:\n",
    "    print(\"The variable is None!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic: <tt>+</tt>, <tt>-</tt>, <tt>*</tt>, <tt>/</tt>, <tt>**</tt>, <tt>%</tt> and comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check for equality using two equal signs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 6 == 4 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 2 or 3 < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 2 and 3 < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 3 != 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tt>%</tt> is the modulus operator. It returns the remainder from doing a division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above is because 5 / 3 is 1 with a remainder of 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In decimal, that is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style='background-color:pink'>\n",
    "<p class=\"first admonition-title\"><b>Warning</b></p>\n",
    "<p class=\"last\">In older versions of Python (prior to 3.0), the <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">/</span></code> operator when used on integers performed integer division; i.e. <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">3/2</span></code> returned <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">1</span></code>, but <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">3/2.0</span></code> returned <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">1.5</span></code>. Beginning with Python 3.0, the <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">/</span></code> operator returns a float if integers do not divide evenly; i.e. <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">3/2</span></code> returns <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">1.5</span></code>. Integer division is still available using the <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">//</span></code> operator, i.e. <code class=\"docutils literal\" style='background-color:pink'><span class=\"pre\">3</span> <span class=\"pre\">//</span> <span class=\"pre\">2</span></code> evaluates to 1.</p></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making choices: if, else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "section = \"soma\"\n",
    "if section == \"soma\":\n",
    "    print(\"working on the soma\")\n",
    "else:\n",
    "    print(\"not working on the soma\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = 0.06\n",
    "if p < 0.05:\n",
    "    print(\"statistically significant\")\n",
    "else:\n",
    "    print(\"not statistically significant\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that here we used a single quote instead of a double quote to indicate the beginning and end of a string. Either way is fine, as long as the beginning and end of a string match."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also has a special object called <tt>None</tt>. This is one way you can specify whether or not an object is valid. When doing comparisons with <tt>None</tt>, it is generally recommended to use <tt>is</tt> and <tt>is not</tt>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "postsynaptic_cell = None\n",
    "if postsynaptic_cell is not None:\n",
    "    print(\"Connecting to postsynaptic cell\")\n",
    "else:\n",
    "    print(\"No postsynaptic cell to connect to\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are comma-separated values surrounded by square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 3, 5, 8, 13]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are zero-indexed. That is, the first element is 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may often find yourself wanting to know how many items are in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python interprets negative indices as counting backwards from the end of the list. That is, the -1 index refers to the last item, the -2 index refers to the second-to-last item, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list)\n",
    "print(my_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "“Slicing” is extracting particular sub-elements from the list in a particular range. However, notice that the right-side is excluded, and the left is included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list)\n",
    "print(my_list[2:4])  # Includes the range from index 2 to 3\n",
    "print(my_list[2:-1])  # Includes the range from index 2 to the element before -1\n",
    "print(my_list[:2])  # Includes everything before index 2\n",
    "print(my_list[2:])  # Includes everything from index 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check if our list contains a given value using the <tt>in</tt> operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "42 in my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 in my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can append an element to a list using the <tt>append</tt> method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.append(42)\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make a variable equal to a copy of a list, set it equal to <tt>list(the_old_list)</tt>. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_a = [1, 3, 5, 8, 13]\n",
    "list_b = list(list_a)\n",
    "list_b.reverse()\n",
    "print(\"list_a = \" + str(list_a))\n",
    "print(\"list_b = \" + str(list_b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In particular, note that assigning one list to another variable <i>does not</i> make a copy. Instead, it just gives another way of accessing the same list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"initial: list_a[0] = %g\" % list_a[0])\n",
    "foo = list_a\n",
    "foo[0] = 42\n",
    "print(\"final:   list_a[0] = %g\" % list_a[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>If the second line in the previous example was replaced with <tt>list_b = list_a</tt>, then what would happen?</p>\n",
    "<p>In that case, <tt>list_b</tt> is the same list as <tt>list_a</tt> (as opposed to a copy), so when <tt>list_b</tt> was reversed so is <tt>list_a</a> (since <tt>list_b<tt> <i>is</i> <tt>list_a</tt>).</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can sort a list and get a new list using the <tt>sorted</tt> function. e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([\"soma\", \"basal\", \"apical\", \"axon\", \"obliques\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have sorted by alphabetical order. If our list had only numbers, it would by default sort by numerical order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([6, 1, 165, 1.51, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to sort by another attribute, we can specify a function that returns that attribute value as the optional <tt>key</tt> keyword argument. For example, to sort our list of neuron parts by the length of the name (returned by the function <tt>len</tt>):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([\"soma\", \"basal\", \"apical\", \"axon\", \"obliques\"], key=len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Lists can contain arbitrary data types, but if you find yourself doing this, you should probably consider making classes or dictionaries (described below).</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "confusing_list = [\"abc\", 1.0, 2, \"another string\"]\n",
    "print(confusing_list)\n",
    "print(confusing_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is sometimes convenient to assign the elements of a list with a known length to an equivalent number of variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first, second, third = [42, 35, 25]\n",
    "print(second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <tt>range</tt> function can be used to create a list-like object (prior to Python 3.0, it generated lists; beginning with 3.0, it generates a more memory efficient structure) of evenly spaced integers; a list can be produced from this using the <tt>list</tt> function. With one argument, range produces integers from 0 to the argument, with two integer arguments, it produces integers between the two values, and with three arguments, the third specifies the interval between the first two. The ending value is not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(0, 10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(3, 10)))  # [3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(0, 10, 2)))  # [0, 2, 4, 6, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(0, -10)))  # []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(0, -10, -1)))  # [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list(range(0, -10, -2)))  # [0, -2, -4, -6, -8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For non-integer ranges, use <tt><a href=\"https://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html\">numpy.arange</a></tt> from the <tt><a href=\"http://www.numpy.org/\">numpy</a></tt> module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions (set theory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions provide a rule for building a list from another list (or any other Python iterable).\n",
    "\n",
    "For example, the list of all integers from 0 to 9 inclusive is <tt>range(10)</tt> as shown above. We can get a list of the squares of all those integers via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x**2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Including an <tt>if</tt> condition allows us to filter the list:\n",
    "\n",
    "What are all the integers <tt>x</tt> between 0 and 29 inclusive that satisfy <tt>(x - 3) * (x - 10) == 0</tt>?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x for x in range(30) if (x - 3) * (x - 10) == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loops and iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can iterate over elements in a list by following the format: <tt>for element in list:</tt> Notice that indentation is important in Python! After a colon, the block needs to be indented. (Any consistent indentation will work, but the Python standard is 4 spaces)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_parts = [\"soma\", \"axon\", \"dendrites\"]\n",
    "for part in cell_parts:\n",
    "    print(part)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we are iterating over the elements of a list; much of the time, the index of the items is irrelevant. If, on the other hand, we need to know the index as well, we can use <tt>enumerate</tt>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_parts = [\"soma\", \"axon\", \"dendrites\"]\n",
    "for part_num, part in enumerate(cell_parts):\n",
    "    print(\"%d %s\" % (part_num, part))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple aligned lists (such as occurs with time series data) can be looped over simultaneously using <tt>zip</tt>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cell_parts = [\"soma\", \"axon\", \"dendrites\"]\n",
    "diams = [20, 2, 3]\n",
    "for diam, part in zip(diams, cell_parts):\n",
    "    print(\"%10s %g\" % (part, diam))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
    "x = list(range(len(y)))\n",
    "print(\"x = {}\".format(x))\n",
    "print(\"y = {}\".format(y))\n",
    "print(list(zip(x, y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a list of tuples. Given a list of tuples, then we iterate with each tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x_val, y_val in zip(x, y):\n",
    "    print(\"index {}: {}\".format(x_val, y_val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are similar to lists, except they are immutable (cannot be changed). You can retrieve individual elements of a tuple, but once they are set upon creation, you cannot change them. Also, you cannot add or remove elements of a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, \"two\", 3)\n",
    "print(my_tuple)\n",
    "print(my_tuple[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attempting to modify a tuple, e.g."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "my_tuple[1] = 2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "will cause a <a class=\"reference external\" href=\"https://docs.python.org/3/library/exceptions.html#TypeError\" title=\"(in Python v3.6)\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">TypeError</span></code></a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because you cannot modify an element in a tuple, or add or remove individual elements of it, it can operate in Python more efficiently than a list. A tuple can even serve as a key to a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary (also called a dict or hash table) is a set of (key, value) pairs, denoted by curly brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "about_me = {\"name\": my_name, \"age\": my_age, \"height\": \"5'8\"}\n",
    "print(about_me)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can obtain values by referencing the key:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(about_me[\"height\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can modify existing values by referencing the key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "about_me[\"name\"] = \"Thomas\"\n",
    "print(about_me)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even add new values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "about_me[\"eye_color\"] = \"brown\"\n",
    "print(about_me)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use curly braces with keys to indicate dictionary fields when using <tt>format</tt>. e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\n",
    "    \"I am a {age} year old person named {name}. Again, my name is {name}.\".format(\n",
    "        **about_me\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Important: note the use of the <tt>**</tt> inside the <tt>format</tt> call."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can iterate keys (<tt>.keys()</tt>), values (<tt>.values()</tt>) or key-value value pairs (<tt>.items()</tt>)in the dict. Here is an example of key-value pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in about_me.items():\n",
    "    print(\"key = {:10s}    val = {}\".format(k, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test for the presence of a key in a dict, we just ask:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if \"hair_color\" in about_me:\n",
    "    print(\"Yes. 'hair_color' is a key in the dict\")\n",
    "else:\n",
    "    print(\"No. 'hair_color' is NOT a key in the dict\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries can be nested, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "neurons = {\n",
    "    \"purkinje cells\": {\"location\": \"cerebellum\", \"role\": \"motor movement\"},\n",
    "    \"ca1 pyramidal cells\": {\"location\": \"hippocampus\", \"role\": \"learning and memory\"},\n",
    "}\n",
    "print(neurons[\"purkinje cells\"][\"location\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are defined with a “def” keyword in front of them, end with a colon, and the next line is indented. Indentation of 4-spaces (again, any non-zero consistent amount will do) demarcates functional blocks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_hello():\n",
    "    print(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's call our function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also pass in an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_print(the_arg):\n",
    "    print(the_arg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try passing various things to the <tt>my_print()</tt> function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_print(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even make default arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_print(message=\"Hello\"):\n",
    "    print(message)\n",
    "\n",
    "\n",
    "my_print()\n",
    "my_print(list(range(4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can also return values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n=5):\n",
    "    \"\"\"Get a Fibonacci series up to n.\"\"\"\n",
    "    a, b = 0, 1\n",
    "    series = [a]\n",
    "    while b < n:\n",
    "        a, b = b, a + b\n",
    "        series.append(a)\n",
    "    return series\n",
    "\n",
    "\n",
    "print(fib())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the assignment line for a and b inside the while loop. That line says that a becomes the old value of b and that b becomes the old value of a plus the old value of b. The ability to calculate multiple values before assigning them allows Python to do things like swapping the values of two variables in one line while many other programming languages would require the introduction of a temporary variable.\n",
    "\n",
    "When a function begins with a string as in the above, that string is known as a doc string, and is shown whenever <tt>help</tt> is invoked on the function (this, by the way, is a way to learn more about Python's many functions):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(fib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have noticed the string beginning the <tt>fib</tt> function was triple-quoted. This enables a string to span multiple lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multi_line_str = \"\"\"This is the first line\n",
    "This is the second,\n",
    "and a third.\"\"\"\n",
    "\n",
    "print(multi_line_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objects are instances of a <tt>class</tt>. They are useful for encapsulating ideas, and mostly for having multiple instances of a structure. (In NEURON, for example, one might use a class to represent a neuron type and create many instances.) Usually you will have an <tt>__init__()</tt> method. Also note that every method of the class will have <tt>self</tt> as the first argument. While <tt>self</tt> has to be listed in the argument list of a class's method, you do not pass a <tt>self</tt> argument when calling any of the class’s methods; instead, you refer to those methods as <tt>self.method_name</tt>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Contact(object):\n",
    "    \"\"\"A given person for my database of friends.\"\"\"\n",
    "\n",
    "    def __init__(self, first_name=None, last_name=None, email=None, phone=None):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.email = email\n",
    "        self.phone = phone\n",
    "\n",
    "    def print_info(self):\n",
    "        \"\"\"Print all of the information of this contact.\"\"\"\n",
    "        my_str = \"Contact info:\"\n",
    "        if self.first_name:\n",
    "            my_str += \" \" + self.first_name\n",
    "        if self.last_name:\n",
    "            my_str += \" \" + self.last_name\n",
    "        if self.email:\n",
    "            my_str += \" \" + self.email\n",
    "        if self.phone:\n",
    "            my_str += \" \" + self.phone\n",
    "        print(my_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By convention, the first letter of a class name is capitalized. Notice in the class definition above that the object can contain fields, which are used within the class as <tt>self.field</tt>. This field can be another method in the class, or another object of another class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make a couple instances of Contact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob = Contact(\"Bob\", \"Smith\")\n",
    "joe = Contact(email=\"someone@somewhere.com\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that in the first case, if we are filling each argument, we do not need to explicitly denote “first_name” and “last_name”. However, in the second case, since “first” and “last” are omitted, the first parameter passed in would be assigned to the first_name field so we have to explicitly set it to “email”."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s set a field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "joe.first_name = \"Joe\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can retrieve fields from the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_name = joe.first_name\n",
    "print(the_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we call methods of the object using the format instance.method()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "joe.print_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember the importance of docstrings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Contact)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extensions to core Python are made by importing modules, which may contain more variables, objects, methods, and functions. Many modules come with Python, but are not part of its core. Other packages and modules have to be installed.\n",
    "\n",
    "The <tt>numpy</tt> module contains a function called <tt>arange()</tt> that is similar to Python’s <tt>range()</tt> function, but permits non-integer steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "my_vec = numpy.arange(0, 1, 0.1)\n",
    "print(my_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note</b>: <tt>numpy</tt> is available in many distributions of Python, but it is not part of Python itself. If the <tt>import numpy</tt> line gave an error message, you either do not have numpy installed or Python cannot find it for some reason. You should resolve this issue before proceeding because we will use numpy in some of the examples in other parts of the tutorial. The standard tool for installing Python modules is called pip; other options may be available depending on your platform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get 20 evenly spaced values between 0 and $\\pi$ using <tt>numpy.linspace</tt>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = numpy.linspace(0, numpy.pi, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides vectorized trig (and other) functions. For example, we can get another array with the sines of all those x values via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = numpy.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <tt>bokeh</tt> module is one way to plot graphics that works especially well in a Jupyter notebook environment. To use this library in a Jupyter notebook, we first load it and tell it to display in the notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bokeh.io import output_notebook\n",
    "import bokeh.plotting as plt\n",
    "\n",
    "output_notebook()  # skip this line if not working in Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we plot y = sin(x) vs x:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = plt.figure(x_axis_label=\"x\", y_axis_label=\"sin(x)\")\n",
    "f.line(x, y, line_width=2)\n",
    "plt.show(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pickling objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are various file io operations in Python, but one of the easiest is “<a class=\"reference external\" href=\"https://docs.python.org/3/library/pickle.html#module-pickle\" title=\"(in Python v3.6)\"><code class=\"xref py py-mod docutils literal\"><span class=\"pre\">Pickling</span></code></a>”, which attempts to save a Python object to a file for later restoration with the load command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "contacts = [joe, bob]  # Make a list of contacts\n",
    "\n",
    "with open(\"contacts.p\", \"wb\") as pickle_file:  # Make a new file\n",
    "    pickle.dump(contacts, pickle_file)  # Write contact list\n",
    "\n",
    "with open(\"contacts.p\", \"rb\") as pickle_file:  # Open the file for reading\n",
    "    contacts2 = pickle.load(pickle_file)  # Load the pickled contents\n",
    "\n",
    "for elem in contacts2:\n",
    "    elem.print_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next part of this tutorial introduces basic NEURON commands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}